mmitou

#include <iostream>
#include <vector>

// これはテストです

int main()
{
  std::vector<char*> v0;  
  std::cout << "hello" << std::endl;
  return 0;

mmitou

import Data.Char
import Prelude hiding (maximum, minimum, splitAt)

-- ex 5.9
pyths :: Int -> [(Int,Int,Int)]
pyths x | x <= 0 = [(0,0,0)]
        | otherwise = [(a,b,c) | a <- [1..x],
                                 b <- [a..x],
                                 c <- [b..x],

mmitou

import Data.Char

-- homework 2.1

type Bit = Int
bin2int :: [Bit] -> Int
bin2int = foldr (\x y -> x + 2 * y) 0

int2bin :: Int -> [Bit]

mmitou

import Prelude hiding (return, (>>=))
import Data.Char 

-- 8.2

type Parser a = String -> [(a, String)]

-- 8.3 
return :: a -> Parser a

mmitou

data Tree a = E
              | T (Tree a) a (Tree a)
              deriving (Show)

empty :: Tree a -> Bool
empty E = True
empty (T _ _ _) = False

insert :: Ord a => a -> Tree a -> Tree a
insert x E = (T E x E)

mmitou

-- 10.5

data Expr = Val Int | Add Expr Expr

value :: Expr -> Int
value (Val n) = n
value (Add x y) = value x + value y

type Cont = [Op]
data Op = EVAL Expr | ADD Int

mmitou

import Maybe

mwrap :: a -> Maybe a
mwrap v = Just v

mbind :: Maybe a -> (a -> Maybe b) -> Maybe b
mbind Nothing _ = Nothing
mbind (Just x) f = x

mmitou

import Monad

data Parser a = Parser (String -> [(a, String)])

pwrap :: a -> Parser a
pwrap v = Parser $ \inp -> [(v, inp)]

pbind :: Parser a -> (a -> Parser b) -> Parser b 
pbind (Parser p) f = Parser $ \inp -> case p inp of
                                        [] ->  []

mmitou

class Mappable m where
  (<$>) :: (a -> b) -> m a -> m b

mmap :: (a -> b) -> Maybe a -> Maybe b
mmap _ Nothing  = Nothing
mmap f (Just x) = Just $ f x
                    

mmitou

data LeftistHeap  a = E | T Int a (LeftistHeap a) (LeftistHeap a)
  deriving(Show)

rank E = 0
rank (T r _ _ _) = r

makeT x a b = if rank a >= rank b
                then T (rank b + 1) x a b
                else T (rank a + 1) x b a