4. 아름다운 언어 Haskell 프로그래밍 (2)

Arity로부터의 자유, 커링

f x y z = x + y + z

f = (\x -> (y -> (\z -> x + y + z)))

f x = (\y -> (\z -> x + y + z))
(f x) y = (\z -> x + y + z)
((f x) y) z = x + y + z

cadd x y = x

sadd(x, y) = x

add5(x) = sadd(5, x)

cadd5 x= (cadd 5)x

cadd5 = cadd 5

map (cadd 5) [2, 3, 4, 5]

(+)  = \x y -> x + y
(x+) = \y -> x + y
(+y) = \x -> x + y

-- 함수를 이항 연산처럼 중간에 놓는다.
-- 어떤 함수나 작은따옴표로 싸주기만 하면 된다.
merge :: Ord a => [a] -> [a] -> [(a,a)]
xs‘merge’ ys = [(max x y, min x y) | x <- xs,y <- ys]

-- 새로운 기호를 연산자로 곧바로 정의해서 쓸 수 있다
(=!) :: Eq a => a -> [a] -> [a]
x =! ys = [y | y <- ys, x /= y]

-- 우선순위가 5이고 오른편 결합 규칙을 사용한다는 선언.
-- 왼편 결합에는 infixl
infixr 5 merge, (=!)

혁신은 언제나 기본으로부터

형 클래스, 재사용을 위한 또 다른 생각

오버로딩의 장단점

add :: Num a => a -> a -> a  -- Parametric polymorphism
add x y = ...

class Thing { public static Number add(Number a, Number b) { ... } } // Subtyping

int add(int x, int y);
float add(float x, float y);
double add(double x, double y); ...

boolean add(int x, int[] a); // 정수 x를 배열 a에 집어넣는다(?).

complex add(complex a, complex b);

drawLine(Color rgb, LineStyle lstyle);
  //선을 그리는데 색과 굵기를 모두 조정하고 싶다면
drawLine(Color rgb);
  // 색만 지정하고 굵기는 기본으로 정한 값을 쓴다.
drawLine(LineStyle lstyle); ...

int add(int x, int y);
Number add(Number x, Number y);

서브타이핑과 함수식 다형성

elem x [] = False
elem x (y:ys) = (x == y) || (elem x ys)

elem 10 [1..]

pair2point (x, y) = Point x y

answer = elem (Point 1 2) (map pair2point [(x, y)| x <- xSpace, y <- ySpace])
    where xSpace = [2..10]; ySpace = [-10..4]

(Point x y) == (Point u v) = (x == u) && (y == v)

elem :: a -> [a] -> Bool

EQ a

class Eq a where
	(==), (/=) :: a -> a -> Bool
	x == y = not (x /= y)
	x /= y = not (x == y)

	(==), (/=) :: a -> a -> Bool
	x == y = not (x /= y)
	x /= y = not (x == y)

Eq (Point2D a) where 
	(Point x y) == (Point u v) = (x == u) && (y == v)

instance Eq => Eq (Point2D a) where
	....

data Eq a => Set a = Set[a]
-- 형 생성함수 Set a와 데이터 생성함수 Set [a]는 같은 이름을 써도 
-- 구분하는 데 아무 문제가 없다.

data Ord a => OrderedSet a = OrdSet [a]
-- class Ord는 strict ordering을 뜻하며,
-- Prelude에 정의된 표준 클래스다.

형 검사와 서브클래싱

class (Eq a) => Ord a where
	compare              :: a -> a -> Ordering
	(<), (<=), (>=), (>) :: a -> a -> Bool
	max, min             :: a -> a

compare x y   | x == y    = EQ
              | x <= y    = LT
              | otherwise = GT

-- 왜 굳이 compare를 만들어 쓰는 지 알만하다.
x <= y = compare x y /= GT
x <  y = compare x y == LT
x >= y = compare x y /= LT
x >  y = compare x y == GT

-- max, min 연산도 조건에 포함시켜 편리함을 더한다.
max x y  | x <= y    = y
         | otherwise = x
min x y  | x <= y    = x 
         | otherwise = y

instance Ord a => Ord (Point2D a) where
	compare (Point x y) (Point u v) = compare (x, y) (u, v) 
-- tuple 정렬 기능을 살짝 빌어서 간단하게

class (Eq a, Show a) => Num a where
	(+), (-), (*), :: a -> a -> a ->
...생략...

data Point2D a = Point (a, a)

data Point2D a = Point(a, a) derriving Eq

instance Eq (Point2D a) where
	(Point this) == (Point that) = this == that

instance Ord a => Ord (Point2D a) where
	compare (Point this) (Point that) = compare this that

data Point2D a = Point (a,a) deriving (Eq, Ord)

class Show where
	show    :: a -> String
...생략...

instance Show a => Show (Point2D a) where
	show (Point x y) = “Point“ ++ show (x, y) 
-- (a, a) 데이터는 이미 Show의 인스턴스다.

data Point2D a = Point (a,a) deriving Show

I/O 모나드의 문법과 의미

Shall I be pure or impure?

getLine :: IO String
getLine = do
	c <- getChar
	if c == '\n' then return ""
		else do
			cs <- getLine
			return (c:cs)

getChar :: IO Char

char getchar();          // in C++ or Java

putChar :: Char -> IO ()

void putchar(char c);    // In C++ or Java

putLine :; String -> IO ()
putLine [] = putChar '\n'
putLine (c:cs) = putChar c >> putLine cs

void putLine(char* s)
{
		...
		putchar(*s);
		...
}

(>>) :: Monad a => a b -> a c-> a c

putLine s = foldr (>>) (putChar '\n') (map putChar s)

putLine s = foldr (>>) (putChar '\n')) . (map putChar)) s

putLine = foldr (>>) (putChar '\n' . map putChar

(>>=) :: Monad a => a b -> (b -> a c) -> a c

(>>=) :: IO a -> (a -> IO b) -> IO b

putLine2 s = do
	putString s
	putChar '\n'

putString s = if s == ""
	then return ""
	else do
		putChar c
	  putString cs
		where
			(c:cs) = s

do c <- getChar
...

getChar (>>=) putChar

do 
  c <- getChar
  result <- putChar c

do
	c <- getChar
	putChar c

-- 대화형 입출력
palindrome :: IO ()
palindrome = do
	putString "Input a String: "
	cs <- getLine
	if palin cs then putLine "Ye!" else putLine "Joking?"

-- 함수형으로 일괄 처리
palin :; String -> Bool
palin xs = (cs == reverse cs)
	where cs = map toUpper (filter isLetter xs)

isLetter = not . isControl

-- [Introduction to Functional Programming using Haskell, p331에 있는 코드를 약간 고침]

굴레를 벗어나

참고 문헌

• Herold Abelson, Gerald Jay Sussman with Juile Sussman,“Structure and Interpretation of Computer Programs,” 2nd Ed. MIT Press, 1996

• Richard Bird, “Introduction to Functional Programming using Haskell,” 2nd Ed. Prentice Hall, 1998

• Richard Bird, Philip Wadler, “Introduction To Functional Programming,”Prentice Hall, 1988

• Anthony J. Field, Peter G.Harrison “Functional Programming,” Addison Wesley, 1988

• Timothy Budd , ”Multiparadigm Programming in Leda,” Addison Wesley, 1995

• Paul Hudak John Peterson,Joseph Fasel, ”The Gentle Introduction to Haskell,” http://www.haskell.org/tutorial/, 2000

• Simon Peyton Jones, About Haskell,” http://www.haskell.org/aboutHaskell.html, 2001

• Andrew Hunt, David Thomas, “The Pragmatic Programmer : From Jorneyman to Master,”Addison-Wesley 1999.

• Why Functional Programming Matters by John Hughes, The Computer Journal, Vol. 32, No. 2, 1989, pp. 98 - 107. Also in: David A. Turner (ed.): Research Topics in Functional Programming, Addison-Wesley, 1990, pp. 17 - 42.