haskell님의 노트

Hello Haskell

Wed, 14 May 2008 21:38:57 +0900

C 언어를 배운 사람들은 누구나 다음과 같은 코드를 기억할 것이다.

#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}

위와 동일한 결과를 출력하는 하스켈 코드는 아래와 같다.

import System.IO
main = putStrLn "Hello, World!"

와~ 더 짧고 간단하다! 이미 C 코딩을 해본 사람이라면 위에 있는 하스켈 코드를 이해하는데 큰 무리가 없을 것이다.

import 는 C언어의 #include 와 비슷하다. 아니 좀더 정확하게 말하자면 자바의 import 와 더 비슷하다. C에서 #include 는 실제 해당 모듈을 연동하는 것이 아니라 헤더 파일을 참조할 뿐이다. 실제 연동은 링크 단계에서 이루어진다. 하지만 하스켈은 소스 파일과 헤더 파일이 분리되어 있지 않기 때문에 import 를 사용해서 바로 해당 모듈을 연동한다. System.IO 는 C의 stdio.h 처럼 입출력에 관련된 표준 함수들을 미리 정의해 놓은 표준 라이브러리 모듈이다. 따라서 앞으로 입출력 작업을 한다면 C에서 그랬듯이 항상 import System.IO 를 덧붙이면 된다.

하스켈 역시 시작은 main 이다. 즉, C처럼 하스켈도 진입함수(entry point)의 이름이 main 이다. 하스켈에는 컴파일러와 인터프리터가 둘다 제공되는데 인터프리터를 사용할 때는 상관이 없지만 컴파일을 해서 실행 파일로 만드려면 항상 main 함수를 정의해야 한다. C에서는 main 함수의 반환타입이 int 이지만(컴파일러에 따라 void도 사용할 수 있지만 표준에서는 int 만을 허용한다.) 하스켈에서는 IO () 라는 다소 낯선 타입이 반환 타입이다. 이에 대해서는 나중에 자세히 설명하겠지만 지금 간단하게 말하자면 IO () 란 main 함수가 입출력 작업을 수행하며 아무런 값도 반환하지 않는다는 뜻이다. 하스켈에서 main 은 언제나 IO () 타입이다.

putStrLn 은 이름에서 짐작할 수 있듯이 문자열(Str)을 출력(put)하고 줄바꿈(Ln)을 하는 함수이다. 자바를 해본 사람이라면 System.out.println() 함수를 떠올리면 되겠다.

이번엔 좀 더 난이도를 높여보도록 하자. 표준 입력으로 사용자의 이름을 입력 받아 Hello, <사용자 이름>! 을 화면에 출력하는 것이다. C 로 만들면 아래와 같다.

#include <stdio.h>
int main() {
char* buf[1024];
printf("What's your name?\n");
scanf("%s", buf);
printf("Hello, %s\n", buf);
return 0;
}

하스켈 코드는 다음과 같다.

System.IO
main = do
putStrLn "What's your name?"
buf <- getLine
putStrLn ("Hello, " ++ buf)

역시 간단하다! 게다가 여기 사용된 함수이름이 매우 직관적이다보니 코드를 이해하는데 별다른 어려움이 없을 것이다. getLine 은 말그대로 표준 입력에서 한줄을 읽어서 반환하는 함수이다. 앞서 '먼저 알아두어야 할 것들'에서 언급했듯이 하스켈에서 = 연산자는 할당의 의미가 아니라 정의한다는 뜻이다. getLine 함수처럼 외부 입력값을 저장해야 할 때는 <- 연산자를 사용한다. 따라서 눈치가 빠른 사람이라면 buf <- getLine 은 표준 입력에서 한줄을 받아 buf 에 저장한다는 의미라고 생각할 수 있다. 그런데 역시 '먼저 알아두어야 할 것들'에서 언급했듯이 하스켈에는 변수에 값을 할당한다는 개념이 없다. 나중에 좀더 자세히 알게 되겠지만 buf <- getLine 은 엄밀히 말하면 buf 에 값을 저장하는 것이 아니라 'getLine의 결과값을 임시로 buf 라고 부르자' 라는 뜻에 더 가깝다. 일종의 별칭(alias)인 셈이다. 따라서 buf 에 다시 다른 함수의 값을 저장할 수 없다. 오직 buf는 getLine의 결과를 대신할 뿐이다. 정리하자면 'A <- B' 라고 하면 이것은 'B 함수의 결과를 A 라고 하자' 라는 뜻이다.

마지막 줄에 보면 "Hello, " ++ buf 라는 문장이 있다. ++ 라는 연산자는 (대충 짐작했겠지만) 두 문자열을 합쳐서 하나의 문자열로 만들어 준다. 이 때 괄호로 묶어준 이유는 (역시 눈치챘겠지만) 우선 순위에 의해 putStrLn 보다 먼저 실행하기 위해서이다. 만약 괄호로 묶어주지 않으면 putStrLn "Hello" 가 먼저 실행되고 나서 그 결과값과 buf 를 ++ 연산자에 적용하게 된다. ++ 연산자는 두 개의 문자열을 인자로 받아야 하는데 putStrLn 함수의 반환 타입은 main 처럼 IO () 타입이다. 따라서 타입이 맞지 않기 때문에 컴파일 단계에서 타입 에러가 발생한다.

타입 에러 말이 나왔으니 하는 말인데 하스켈은 C, C++, JAVA 처럼 정적 타입(Static Typing) 언어이다. 모든 함수들은 타입을 가지고 있다. 게다가 강 타입(Strong Typed) 언어이기도 하다. C++나 JAVA 보다 타입 간 변환을 훨씬 엄격하게 제한한다. 타입간의 암묵적인 변환을 '전혀' 허용하지 않는다. 하지만 그럼에도 불구하고 대부분의 경우 프로그래밍 시에 타입에 대해 거의 신경을 쓰지 않아도 된다. 왜냐하면 하스켈은 매우 훌륭한 타입 추론 시스템을 가지고 있기 때문이다. 그래서 특별한 경우를 제외하고는 컴파일러에 의해 해당 함수나 변수의 타입이 자동으로 추론된다. 위의 코드에서도 buf 가 getLine 함수의 결과값을 대신하는 대리자 역할을 하며 getLine의 결과 타입이 String 이기 때문에 프로그래머가 굳이 buf의 타입이 String 이라고 선언하지 않더라도 컴파일러가 자동으로 String 타입이라는 사실을 추론할 수 있다. 때문에 마치 파이썬이나 루비같은 정적 타입 언어처럼 편하게 인자값을 사용할 수 있으면서도 잘못된 타입 적용 시에는 컴파일 단계에서 자동으로 오류를 검출할 수 있다(동적 타입 언어처럼 테스트 코드를 작성할 필요가 없다).

마지막으로 do 에 대해서 알아보자. do 는 간단하게 말하면 앞으로 나오는 함수들을 차례로 실행하라는 뜻이다. C에서는 세미콜론(;)으로 각 문장(statement)를 구분하며 이렇게 구분된 문장들은 특별한 제어구문이 없다면 코드에 적힌 순서대로 실행된다. 하스켈에서는 이런 순차적인 실행을 하지 않는다. 하스켈의 함수들은 단지 해당 함수의 결과값이 필요한 시점에서만 실행된다. 이것을 지연 평가(Lazy Evaluation) 이라고 한다. 자세한 사항은 좀 복잡하니 나중에 설명하도록 하고 어쨌든 위 코드처럼 여러 문장을 순서대로 실행하려면 함수 앞에 do 를 붙여야 한다는 사실을 기억하기 바란다.

먼저 알아두어야 할 것들

Wed, 14 May 2008 21:37:44 +0900

먼저 알아두어야 할 것들

C, C++, JAVA 등의 언어들과 달리 하스켈에는 할당 연산자(assignment operator)가 없습니다. 하스켈에서도 = 연산자가 사용되기는 하지만 이것은 기존의 언어들과 다른 의미를 갖습니다. 예를 들어 C 에서

x = 1;

라고 하면 이것은 '변수 x에 1을 할당한다.' 라는 의미입니다. 하지만 하스켈에서 = 연산자는 'assign to' 가 아니라 'define'을 뜻합니다. 따라서 'x 는 1이다.'라는 뜻을 갖습니다. 한편 하스켈은 순수 함수형 언어입니다. 이 말이 무슨 뜻인가 하면 간단히 말해서 하스켈에서 모든 것들은 다 함수라는 뜻입니다. 예를 들어 순수 객체 지향 언어인 스몰토크에서는 정수나 문자열 등이 모두 객체입니다. 비슷하게 하스켈에서는 정수 1, 2, 3... 등이 해당 값을 반환하는 함수로 취급됩니다(이런 고정 값을 반환하는 함수를 상수 함수라고 합니다). 따라서 하스켈에서 x = 1 라고 한 것은 C 코드로 표현하면 다음과 같습니다.

int x() { return 1; }

다른 예를 더 들어보자면,

x = x+1;

이라는 코드는 C 언어에서 사용하면 'x 라는 변수에 1을 더해서 다시 x 에 저장해라.' 라는 의미를 갖지만 하스켈에서는 다음과 같이 해석됩니다.

int x() { return x() + 1; }

즉, x 함수는 무한히 자신을 재귀적으로 호출하는 함수입니다. 따라서 저렇게 x를 정의하고 x 함수를 호출하면 무한 반복 호출을 하며 종료하지 않습니다. 여기서 알 수 있듯이 하스켈에서는 명령형 프로그래밍 언어에서 당연하게 생각하는 '변수에 값을 할당한다'는 개념이 없습니다. 이 때문에 하스켈에서는 함수에 부수 효과(side effect)가 없습니다. 부수 효과(side effect)란 어떤 함수를 실행할 때 그 결과값 외에 다른 어떤 상태가 변화하는 것을 말합니다. 예를 들면 다음과 같은 경우가 있겠습니다.

extern int globalVar;
int foo(int x) {
++globalVar;
return x+globalVar;
}

위에 있는 foo() 함수는 x+globalVar 식을 계산해서 결과값을 반환하는 작업 외에도 globalVar의 값을 하나씩 증가시키는 부수 효과가 있습니다. 즉, globalVar 라는 변수의 상태가 변화합니다. 따라서 foo()함수는 동일한 입력값 x에 대해서도 globalVar라는 전역 변수의 값이 무엇이냐에 따라 다른 결과값을 출력할 수 있습니다. 하지만 하스켈에서 함수는 부수 효과가 없기 때문에 입력값이 같으면 결과값도 항상 같습니다(이것을 참조 투명성 - referential transparency - 이라고 합니다).

어쨌든 이런 특성 때문에 하스켈에서는 절차적인 작업을 수행할 때 사용하는 방식이 C 언어와 많이 다릅니다. 예를 들어 반복 작업을 수행할 때 C에서는 while 이나 for 와 같은 loop 문을 사용하지만 하스켈에서는 재귀 호출을 사용합니다. 가령 펙토리얼 함수를 C로 만들면 아래와 같습니다.

int factorial(int x) {
int ret = 1;
while (x-- > 0)
ret *= x;
return ret;
}

하지만 하스켈에서는 다음과 같습니다.

factorial x = if x == 0
then 1
else x * factorial (x-1)

C에서는 순차적인 작업을 표현할 때 다음과 같이 코딩을 하지만,

int main() {
int x, y, z;
x = foo();
y = bar(x);
z = zoo(y);
return z;
}

하스켈에서는 함수를 다른 함수의 인자로 직접 전달합니다.

main = zoo (bar (foo))

하스켈은 코딩 스타일에 대한 몇 가지 문법적인 제약을 가지고 있습니다. 먼저 함수는 항상 소문자로 시작해야 합니다. 반면 클래스나 타입은 반드시 대문자로 시작해야 합니다. 함수 이름에는 알파벳과 숫자를 사용할 수 있으며 특수 문자에서는 작은 따옴표(')와 밑줄(_)을 사용할 수 있습니다. 특수 문자로만으로 이루어진 함수도 정의할 수 있는데 이렇게 특수 문자로 이루어진 함수는 특별히 '연산자(operator)'라고 부릅니다. 일반 함수와 연산자 함수의 가장 큰 차이점은 일반 함수가 전위(prefix) 연산을 수행하는 반면 연산자 함수는 중위(infix) 연산을 수행한다는 것입니다. 또한 C에서는 {} 기호를 사용해서 블럭을 구분하지만 하스켈에서는 소스의 레이아웃을 사용해서 블럭을 구분합니다. 다시 말하면 같은 열에서 시작하는 문장은 같은 레벨의 블럭을 갖습니다. 예를 들어 아래의 C 소스는,

int main() {
statement1;
if (...) {
statement2;
if (...) {
statement3;
} else {
statement4;
}
} else {
statement5;
}
}

하스켈로 표현하면 다음과 같습니다.

main = do
statement1
if (...) then do statement2
if (...) then statement3
else statement4
else statement5

이 때 주의할 점은 하스켈에서는 탭 문자와 공백 문자를 다르게 취급한다는 점입니다. 따라서 가급적 에디터에서 탭 문자를 자동으로 공백문자로 변환하도록 설정하는 것이 좋습니다. 이렇게 하스켈에서는 코딩 스타일에 대한 문법적 제약이 있기 때문에 처음에는 다소 불편하고 어색할 수 있지만 반면 어떤 하스켈 소스라도 스타일 면에서 일관성을 갖게 되는 장점이 있습니다.

지금까지의 설명을 보고나면 아마 하스켈이 너무 낯설고 어색하다고 느낄지 모릅니다. 특히 변수에 값을 저장할 수 없다는 제약이 매우 크게 느껴질 것입니다. 하지만 실상 하스켈에는 위에서 설명하지 않은 매우 다양한 문법적 특성과 편의성을 가지고 있기 때문에 C나 기타 여러 명령형 언어들보다 간결하면서도 강력한 프로그래밍이 가능합니다. 실제로 하스켈에서 불가능한 프로그래밍은 거의 없으며 성능면에서도 여타 스크립트 언어들에 비해 월등한 결과를 보여줍니다. 그럼 이제부터 본격적으로 하스켈 프로그래밍에 대해서 하나씩 설명해 나가도록 하겠습니다.

함수와 타입

Wed, 14 May 2008 21:36:12 +0900

하스켈은 정적 타입 언어이면서 강타입 언어이다. 정적 타입 언어라는 뜻은 변수나 함수의 타입이 컴파일 시에 명시적으로 결정된다는 뜻이다. C, C++, JAVA같은 언어가 대표적인 정적 타입 언어이다. 보통 정적 타입 언어는 컴파일 시에 타입이 결정되기 때문에 타입 오류를 컴파일 시간에 찾을 수 있는 장점을 갖는 반면 프로그래밍 시 타입을 일일이 명시해 줘야 하는 불편함이 있다고 알려져 있다. 하지만 하스켈은 정적 타입 언어이면서 강력한 타입 추론 시스템을 갖고 있기 때문에 C 언어처럼 변수나 함수의 타입을 명시적으로 지정해 줄 필요가 없다. 이전 장의 코드를 다시 살펴보면,

System.IO
main = do
putStrLn "What's your name?"
buf <- getLine
putStrLn ("Hello, " ++ buf)

4번째 줄에서 getLine 의 반환값은 String 타입이다. 따라서 buf 의 타입이 String 이 되어야 한다. 하스켈의 타입 시스템은 getLine의 타입을 통해 buf의 타입을 유추할 수 있으므로 프로그래머가 명시적으로 buf의 타입을 표시해 줄 필요가 없다. 때문에 마치 동적 타입 언어와 비슷한 편리함을 갖고 있다. 여기에 추가적으로 동적 타입 언어의 경우 모든 타입 검사가 실행 시간에 일어나기 때문에 타입 오류가 있는 코드가 실행 시점에 예외로 처리되지만 하스켈은 대부분의 타입 오류를 컴파일 단계에서 완벽하게 찾아내기 때문에 동적 타입 언어보다 더 안전한 프로그래밍이 가능하다. 즉, 동적 타입 언어에서 해줘야 하는 타입 검사용 테스트 코드가 전혀 필요없게 된다. 한편 하스켈은 강타입 언어이다. C 언어처럼 묵시적인 타입 변환을 전혀 허용하지 않는다. 때문에 의도하지 않은 타입 변환에 의한 오류의 가능성이 전혀 없으며 매우 안전하고 신뢰성 높은 프로그래밍이 가능하다.

하스켈에는 많은 타입들이 존재한다. 이들 미리 정의된 타입 중 대표적인 타입들은 아래와 같다.

Boolean - 말그대로 참,거짓을 구분하는 타입, True, False 값을 갖는다.
Char - 문자 타입
String - 문자열 타입, 이것은 문자의 리스트인 [Char] 과 동의타입(synonym)이다. 리스트에 대해서는 나중에 자세히 설명하겠다.
Integer - 정수 타입, C 언어와 달리 제한 값이 없다.
Int - Integer와 같은 정수 타입이지만 -2^29 에서 2^29 - 1 까지의 범위를 갖는다. 대신 이 타입은 Integer 보다 좋은 성능을 갖는다.
Float, Double - 실수 타입, C와 비슷하다.

이 외에 C 언어에 없는 하스켈만의 독특한 타입이 몇 개 더 있는데 그 중 대표적인 것이 리스트(List)와 튜플(Tuple)이다. 리스트는 동일 타입의 복수 개의 값을 표현할 때 사용하는 타입이다. 얼핏 C 언어의 배열과 비슷하지만 고정 사이즈가 아니다. 오히려 C++ 에 있는 std::vector<> 와 더 비슷하다. 리스트는 [1,2,3,4] 나 ['a'. 'b'. 'c'] 와 같이 표현된다. 위에서 잠깐 언급했듯이 String 은 문자 리스트인 [Char]이다. 따라서 "Hello, World!" 라는 문자열은 사실 ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'] 을 보기 편하게 바꾼 것이다. 실제 의미적으로 볼 때 둘은 완전히 같다. 튜플은 리스트와 달리 고정 사이즈이면서 여러 타입을 갖는 데이터를 표현할 때 사용한다. (1, 'a') 나 ('x', True, 3, 'y') 같은 식으로 표현한다. 둘 다 여러 개의 값을 반환하고자 할 때 유용하게 사용할 수 있다.

하스켈의 함수는 C와 생김새가 많이 틀리다. Hello Haskell 에서 만들었던 프로그램 소스를 다시 살펴보자.

// C
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
-- Haskell

import System.IO
main = putStrLn "Hello, World!"

하스켈에서는 함수 정의 시 반환 타입을 표시하지 않으며 앞서 언급했듯이 = 연산자를 사용해서 함수 이름과 함수 내용을 구분한다. 게다가 인자값을 주는 형태도 많이 틀리다. 예를 들어 두 수의 합을 계산하는 add 함수를 정의하면 다음과 같다.

int add(int x, int y) { return x + y; } // C 함수
add x y = x + y -- 하스켈 함수

하스켈에서는 인자들을 괄호로 묶지 않고 쉼표(,)로 구분하지도 않는다. 단지 공백 문자로 구분한 첫 단어가 함수 이름이고 뒤에 나오는 단어들이 차례로 인자가 된다. 물론 앞서 말했듯이 함수 반환값이나 인자값의 타입을 명시해줄 필요가 없다. 여러분이 GHCi 라는 하스켈 인터프리터를 사용한다면 위 add 함수를 인터프리터 상에서 바로 정의해 줄 수 있다. 인터프리터 상에서 바로 함수를 정의할 때는 let 을 맨 앞에 붙여준다. 즉, 다음과 같이 하면 된다.

let add x y = x + y

이제 add 2 3 이라고 하고 엔터를 치면 결과값인 5 가 출력될 것이다. 파일을 따로 만들어서 함수를 정의할 때는 let 을 빼고 정의한다. 이제 인터프리터 상에서 :t add 라고 입력하고 엔터를 쳐보자. 그럼 다음과 같은 결과가 출력될 것이다.

add :: (Num a) => a -> a -> a

:t 는 GHCi 인터프리터에서 제공하는 명령어인데 뒤에 나오는 함수의 타입을 출력해준다. 하스켈 함수의 타입은 C 함수 타입과 크게 다르지 않다. 가령 위 int add(int x, int y) 함수의 타입은 int (*)(int,int) 이다. C 언어에서 이 타입이 의미하는 뜻은 '반환값이 int 형이고 두 개의 int 형 인자를 받는 함수 타입' 이다. 하스켈 역시 함수 타입을 반환 타입과 인자 타입을 가지고 표현한다. 그런데 저 위에 나온 결과가 다소 낯설다. 어디가 반환 타입이고 인자 타입인지 헷갈릴 것이다. 우선 맨 앞에 add 는 당연히 함수 이름을 뜻한다. :: 는 그 뒤에 나오는 것들이 add 의 타입을 뜻한다는 구분자이다. (Num a) 란 앞으로 나올 a 라는 문자가 Num 이라는 타입을 의미한다는 뜻이다. 그리고 a -> a -> a 는 앞에서부터 차례로 인자 타입을 나타내며 마지막 a 가 반환 타입이 된다. 다시 말하면 위에 'add :: (Num a) => a -> a -> a' 가 의미하는 것은 'add 라는 함수는 두 개의 Num 타입 인자를 받아 Num 타입 결과를 반환하는 함수' 라는 뜻이다. 실상 'add :: Num -> Num -> Num' 이라고 해도 될 것을 굳이 헷갈리게 'add :: (Num a) => a -> a -> a' 이라고 했냐? 고 반문한다면 여기에는 아직 여러분이 이해할 수 없는 고매한 뜻이 담겨 있기 때문이라고 밖에 말할 수 없다. 실제로 '(Num a) =>' 라는 표기에는 정말 심오한 의미가 담겨 있다! 이에 대해서는 나중에 자세히 알아보도록 하겠다. 어쨌든 함수의 타입은 다음과 같은 형식으로 이루어져 있다고 생각하면 된다.

함수 이름 :: (타입 대리자) => 타입 -> 타입 -> ... -> 타입

여러분은 단지 마지막 타입은 반환 타입이고 그 앞에 있는 것들은 인자 타입이구나...라고 생각하면 된다. 만약 인자가 하나도 없는 함수라면 당연히 함수의 타입은 결과 타입과 같다. 그럼 반환값도 없는 함수는 어떻게 하나? 예를 들어 C 언어에서 void foo(void) 같은 함수말이다. 하스켈에서는 결과값이 없는 함수란 존재하지 않는다. 자고로 함수란 어떤 일이든 해야 하는데 부수 효과(side effect)가 없는 하스켈에서는 결과값이 없다는 말은 아무 일도 하지 않는다는 뜻이므로 그런 함수를 정의하는 것을 허용하지 않는다. 물론 예외가 있긴한데 대표적인 예가 입출력 작업을 수행하는 함수이다. 입출력 작업은 실제로 어떤 결과값을 반환하지 않더라도 의미있는 작업을 수행할 수 있다. 가령 콘솔에 'Hello, World!' 따위의 문자열을 출력하는 함수는 결과값을 반환하지 않는다. 이런 함수는 앞서 언급했듯이 IO () 라는 타입을 갖는다.

참고로 C 에서는 한 줄 주석을 // 로, 블럭 주석을 /* ... */ 로 표시하지만 하스켈에서는 한 줄 주석을 -- 로, 블럭 주석을 {- ... -} 로 표시한다.

여기서 한 가지 의문점이 생길지 모른다. '왜 하스켈의 함수 타입은 C 언어의 함수처럼 인자 타입과 반환 타입이 명확하게 구별되어 있지 않을까?' 라는 것이다. 그 이유는 하스켈 함수의 매우 특이한(동시에 매력적인) 성질 때문이다. 앞서 언급했듯이 하스켈에서 모든 것은 함수로 이루어져 있다. 따라서 인자도 함수이고 결과값도 함수이다. 이것은 단지 상징적인 특성이 아니다. 정말로 하스켈의 함수는 함수를 인자로 받을 수 있고 함수를 결과값으로 반환할 수 있다! 예를 들어 위에 add 함수는 '두 개의 인자를 받아 더한 값을 반환하는 함수'라고 생각할 수도 있지만 한편으로는 '하나의 인자 x를 받아 또 다른 인자 y를 받아 x와 더한 값을 반환하는 함수를 반환하는 함수'라고 생각할 수도 있다! 헷갈리는가? 다시 말하면 add x y = x + y 라는 함수는 x와 y 를 입력값으로 받아 x+y 값을 반환하는 함수이기도 하지만 한편으론 x 값을 받아 (x+) 라는 함수를 반환하는 함수이기도 하다. 의심스러운가? 그러면 여러분의 인터프리터에서 다음과 같은 함수를 정의해보기 바란다.

let inc = add 1

이제 inc 4 라고 하면 5 가 출력될 것이다. C 언어로 표현하자면 다음과 같다.

int inc(int y) {
return add(1, y);
}

정확히 말하자면 하스켈 함수는 인자를 하나 받아서 다음 인자를 처리할 수 있는 함수를 반환하는 구조로 되어 있다. 그러니까 위의 add 함수는 원래 첫번째 인자만을 받아서 나머지 인자를 받아 처리할 함수(위의 inc 함수)를 반환하며 이 때 반환된 함수가 다시 두 번째 인자를 받고서 결과값을 반환하는 것이다. 이런 함수를 '커리(curry) 함수'라고 부른다. 즉, 하스켈의 함수들은 모두 커리 함수이다. 쓸데없이 복잡해 보이지만 이런 하스켈의 특성은 함수를 재활용하기 쉽게 해준다(당장 위 코드 예를 보더라도 우리는 add 함수를 사용해서 inc 함수를 굉장히 쉽게 정의할 수 있었다).

스프링로그 사이드바

Mon, 31 Mar 2008 19:09:47 +0900

글 목록

스프링로그 글 목록(haskell)

Mon, 31 Mar 2008 19:09:27 +0900

haskell님의 노트

Mon, 31 Mar 2008 19:09:09 +0900

소개글

이 곳은 하스켈(Haskell) 이라고 하는 함수형 언어에 관련해서 제가 틈틈히 정리한 번역물, 팁, 레퍼런스 등의 자료를 기록하는 장소입니다.

각종 피드백은 제 블로그(http://agbird.egloos.com) 에 있는 방명록이나 이메일( gimmesilver@gmail.com ) 로 연락주시기 바랍니다.

계산기프로그램 만들기

Mon, 31 Mar 2008 18:04:25 +0900

GtkHs와 Glade 편집툴을 이용해서 만든 간단한 계산기 프로그램입니다.

Parsec.Expr 모듈을 이용하면 EBNF 문법을 거의 그대로 이용해서 파서를 만들 수 있습니다.

exprParser 함수가 바로 그렇게 구현한 파서입니다.

아래 소스는 크게 두 부분으로 나뉩니다.

glade를 이용해서 기술한 UI description file을 읽어서 UI를 만들고 각 버튼 클릭 메시지를 처리하는 등의 GUI 처리 부분이 한 부분이고, GUI를 통해 화면에 출력된 수식을 파싱하여 계산 결과를 처리하는 계산 엔진 부분이 있습니다. 그리고 이 둘은 거의 완벽하게 분리가 가능합니다.

UI용 Glade 소스 - calculator(1).glade

하스켈 소스

module Calculator where
import Graphics.UI.Gtk
import Graphics.UI.Gtk.Glade
import Text.ParserCombinators.Parsec
import Text.ParserCombinators.Parsec.Expr
import Data.IORef
buttons = [("button0", "0"), ("button1", "1"), ("button2", "2"), ("button3", "3"), ("button4", "4"),
("button5", "5"), ("button6", "6"), ("button7", "7"), ("button8", "8"), ("button9", "9"),
("button_add", "+"), ("button_sub", "-"), ("button_times", "*"), ("button_div", "/") ]
main = do
    initGUI
    state <- newIORef True -- True: clear previous value
    Just xml <- xmlNew "calculator.glade"
    window <- xmlGetWidget xml castToWindow "window1"
    field <- xmlGetWidget xml castToEntry "entry1"
    result <- xmlGetWidget xml castToButton "button_result"
    onDestroy window mainQuit
    mapM_ (\(widgetName,text) -> do
        widget <- xmlGetWidget xml castToButton widgetName
        onClicked widget $ do
            clear <- readIORef state
            prev <- (\clear -> if (clear)
                then writeIORef state False >> return ""
                else get field entryText >>= return) =<< readIORef state
            entrySetText field (prev ++ text)
        ) buttons
    onClicked result $ do
        expr <- get field entryText
        case (parse exprParser "" expr) of
            Left err -> entrySetText field "0"
            Right ret -> entrySetText field $ show ret
        writeIORef state True
    widgetShowAll window
    mainGUI
exprParser :: Parser Float
exprParser = buildExpressionParser table factor
        <?> "expression"

table = [[op "*" (*) AssocLeft, op "/" (/) AssocLeft]
        ,[op "+" (+) AssocLeft, op "-" (-) AssocLeft]
        ]
        where
            op s f assoc
                = Infix (do {string s; return f}) assoc

factor = do { char '('
            ; x <- exprParser
            ; char ')'
            ; return x
            }
        <|> number
        <?> "simple expression"

number :: Parser Float
number = do { ds <- many1 digit
            ; return (read ds) }
         <?> "number"

IO 프로그래밍을 위한 팁 7가지

Mon, 31 Mar 2008 18:01:12 +0900

참고 사이트: Haskell IO

하스켈은 참 멋진 언어입니다.
완벽에 가까운 타입 추론 기능에 기반한 '람다'나 '고차 함수'와 같은 세련된 함수 처리 기법들이나 패턴 매칭기법은 정말 처음 보는 사람을 '혹'하게 하는 하스켈만의 매력입니다.

그런데...

이런 멋진 놈으로 뭐 좀 해보려고 하면...뭔가 연습삼아 간단한 프로그램 좀 만들어 볼라치면 바로 좌절에 빠지고 맙니다. 바로 IO(입/출력) 처리 때문이죠...
네... 전 하스켈 참 멋진 언어라 생각합니다만 IO 처리에서 만큼은 정말이지 C++의 std::iostream 보다도 더 친하게 지내고 싶지 않은 놈이라 생각합니다. (하긴...하스켈의 모나드나 C++의 std::streambuf_iterator 나 그게 그놈이지만요...)

어쨌든 전 하스켈이 사람들에게 쉽게 다가가지 못하는 이유는 전적으로 기존의 튜터리얼 문서나 책들이 대부분 IO 를 공부할 때 하스켈 IO 작업의 이론적 기반이 되는 '모나드'라는 개념에 대한 이해를 강요하기 때문이라고 생각합니다. 때문에 기초적인 IO 예제를 만들기 위해서 사람들은 레벨도 낮은 초보시절부터 강력한 보스를 만나 고전하다가 뻗어버리곤 하죠...

따라서 우리가 C++를 공부할 때

std::cout << "Hello World" << std::endl;

이 라는 문장을 놓고 연산자 재정의나 함수 오버로딩, 템플릿 등등을 주저리주저리 설명하지 않듯이(아마 std::endl이 함수라는 사실을 모르고 사용하는 C++프로그래머들이 상당수일 것이라 생각합니다. 그리고 전 그게 그리 큰 문제라고 생각하지 않습니다.) 하스켈에서도 초보자를 위한 문서라면 어쨌든 1장에서 IO 사용법을 예제를 통한 주입식 방법으로 익숙하게 만든 다음 나중에 '모나드가 어쩌구...'라는 심화학습을 해야 한다고 생각합니다.

아마 저 위에 링크의 글을 쓴 사람도 그런 생각을 했나 봅니다. 어쨌든 IO 관련 작업은 이런식으로 해봐라...라는 주입식 규칙 7가지를 이야기하는 군요. 요약하자면 아래와 같습니다.(설명 및 소스는 제가 약간 첨언했습니다.)

규칙 1. - IO 작업이 포함된 함수는 do 로 시작해라...(여기서 do가 어떤 역할을 하는지 자세한 설명을 하면 큰일남!)

규칙 2. - import System.IO 를 추가해라 (C++로 따지면 #include <iostream>과 같음)

규칙 3. - 순수한 IO 작업만 하는 함수라면 리턴값 필요없다.
예) main = do putStrLn "Hello, World!!!"

규칙 4. - 만약 어떤 IO 작업 결과를 저장하고 싶으면 '<-' 를 사용해라
예) main = do
          text <- getLine
          putStrLn text;

규칙 5. - 만약 IO 작업이 아닌 순수 하스켈 함수 값을 저장하고 싶으면 'let' 을 사용해라. (물론 엄밀한 의미에서 저장하는 것이 아니지만 이 또한 지금 당장에 자세히 파고들 필요는 없습니다.)
예)
convertUpper = map Char.toUpper
main = do
        text <- readFile "somefile.txt"
        let upperText = convertUpper text
        putStrLn upperText

규칙 6. - 만약 함수가 do로 시작했으면 마지막에는 IO 타입의 어떤 값을 리턴해야한다. 여기에는 아래와 같은 두 가지 방법이 있다.
6-1. IO 타입을 리턴하는 함수가 마지막에 오면 된다. 규칙 3,4,5의 예제가 이에 해당한다.
6-2. IO 타입이 아닌 어떤 값을 리턴하려면 return 문 다음에 리턴하고자하는 값을 쓴다. 예를 들어 규칙 5의 main함수는 다음과 같이 바꿀 수 있다.

myReadFile filename = do
        text <- readFile filename
        let upperText = convertUpper text
        return upperText

main = do
        text <- myReadFile "somefile.txt"
        putStrLn text

규 칙 5의 main함수는 putStrLn 함수로 끝나는데 이 함수는 IO 타입을 반환하는 함수이므로 return이 필요없으며 바로 위의 myReadFile 함수는 upperText라는 값을 반환하므로 return upperText라고 했다. 만약 어떤 값도 리턴할 필요가 없으면 그냥 return () 라고 하면 된다.

규칙 7. - 모든 IO 작업마다 일일히 <- 를 하는게 귀찮을지 몰라도 그렇게 하는게 더 쉽다.(더 짧게 쓰려면 모나드를 이용해야 하는데 그건 나중에 생각하자.)

이 규칙만 잘 이해하면 기본적인 IO 작업하는데 큰 무리는 없을 듯 싶군요...
어쨌든 결론은 초보시절부터 '모나드'를 이해하려고 하면 안된다는 것! 그건 나중에 생각하자구요~ ^^

덧붙임 - 위 규칙들은 다음 순서대로 이해하시면 더 좋을 것 같습니다.

규칙2. import System.IO 추가
규칙1. 입/출력 작업이 있는 함수는 do로 시작
규칙6. do로 시작한 함수는 return으로 끝냄
규칙3. 단, 순수하게 IO작업만 하는 함수라면 return 생략 가능
규칙4. 입/출력 결과 저장 시 <- 사용
규칙5. 입/출력 값이 아닌 값을 저장하고 싶으면 let 사용
규칙7. 모든 작업은 한 줄에 한 작업씩...

스프링로그 프로퍼티

Mon, 31 Mar 2008 17:47:24 +0900

C 프로그래머를 위한 하스켈

Fri, 14 Mar 2008 11:40:34 +0900

이 글은 C 언어와 같은 명령형 언어들에 익숙한 프로그래머를 위한 하스켈 입문서입니다.

먼저 알아두어야 할 것들

Hello Haskell

함수와 타입

하스켈로 펙토리얼 함수를 만드는 24가지 방법

Thu, 13 Mar 2008 21:01:53 +0900

원문 보기: The Evolution of a Haskell Programmer

예전에 본 Hello world 프로그램 짜기에 관한 유머를 연상케 하는 글...
Haskell.org 에는 유머라고 분류해 놓았긴 하지만 단순히 유머라 하기엔 하스켈에서 지원하는 람다식, 패턴매칭, points-free, continuation-passing, accumulating recursive 등등의 다양한 기법들을 한번에 접할 수 있어 유용한 글 인듯...
밑으로 가면 말도 안되는 소스가 나오는데 그건 무시...^^

참고로 가장 적은 글자수로 구현한 펙토리얼 함수는 아래와 같다. (위 글에 의하면 종신 재직 교수의 방법 ^^)

f n=product[1..n]

빈칸 포함 17자...

원문에 보면 모나드를 사용한 방법이 없어서 아쉽다는 말이 나오는데...
방법이야 무궁무진 하지만 이런 문제에는 모나드가 어울리진 않는다.

어쨌든 당장 생각나는 방법은 IORef 를 사용하는 방법인데 아래와 같다.

import Data.IORef
import Monad
fac n = newIORef 1 >>= (\x->fac' n x >> readIORef x)
fac' n ret = when (n>0) (readIORef ret >>= (\x
-> writeIORef ret (x*n) >> fac' (n-1) ret))