Haskell& Functional

Peeking functional programming

P L U S

프로그래밍 언어의 변화 기계 중심 언어와 인간 중심 언어

기계어 , 어셈블러 , …C, Pascal, …C++, Java, …Prolog, Perl, Python, …

P L U S

프로그래밍 언어의 변화 주 프로그래밍 언어의 변화

이전 : 기계 중심 언어가 주로 사용되었다 . 컴퓨터의 성능이 좋지 않았다 . 고급 개념의 컴퓨터 구현이 부족했다 .

현대 : 점점 인간 중심 언어로 이동 C 와 같은 기계 중심 언어에서 인간 중심 언어로 주 사용

언어가 이동하고 있다 .

P L U S

인간 중심 언어 ?

기계 중심 언어기계 중심으로 사고해야 한다 .프로그램 제작 , 유지 , 보수가 어렵다 .

인간 중심 언어인간의 사고 방식에 가까운 언어이다 .에러가 적고 , 코드를 읽기가 쉽다 .

P L U S

인간의 사고 방식 ?

사람이 생각하는 것을 어떻게 하면 명확하게 표현할 수 있을까 ?

수학적 표기 방법을 이용한다 .Functional programming 은 수학적인 표현

방법과 유사하다 .

P L U S

Functional Programming?

함수가 특별하지 않다 . 계산을 어떻게 하는 지가 아니라 , 무엇을

계산하는지에 초점이 맞춰져 있다 . 프로그램은 명령의 나열이 아니라 , 값을

계산하기 위한 계산식이다 . 기계적인 부분 ( 메모리 관리 등 ) 에 신경 쓸

필요가 없다 .

P L U S

퀵 소트 알고리즘 수열에서 한 수를 선택한다 . 그 수보다 작은 수는 그 수 왼쪽으로 , 큰 수는

그 수 오른쪽으로 보낸다 . 각 부분에 대하여 이 과정을 반복한다 .

P L U S

퀵 소트 알고리즘 ( in C )qsort( a, lo, hi ) int a[], hi, lo; { int h, l, p, t; if (lo < hi) { l = lo; h = hi; p = a[hi]; do { while ((l < h) && (a[l] <= p)) l = l+1; while ((h > l) && (a[h] >= p)) h = h-1; if (l < h) { t = a[l]; a[l] = a[h]; a[h] = t; } } while (l < h); t = a[l]; a[l] = a[hi]; a[hi] = t;

qsort( a, lo, l-1 ); qsort( a, l+1, hi ); }}

P L U S

퀵 소트 알고리즘 ( in Haskell )

qsort [] = []qsort (x:xs) = qsort lt_x ++ [x] ++ qsort

greq_xwhere

lt_x = [y | y<- xs, y< x]greq_x = [y | y<- xs, y>= x]

P L U S

비교 분석 C

기계적인 과정을 세세하게 처리해 주어야 한다 . 코드를 알아보기가 힘들고 , 복잡하다 . 속도가 빠르다 .

Haskell 수학적인 표현을 거의 그대로 옮겼다 . 간결하고 , 이해하기 쉽다 . 속도가 C 에 비해 느리다 .

P L U S

Haskell 의 장점 간결하고 , 이해하기 쉽다 . 안전하다 . ( 강력한 타입 체크로 , 실행 중에 Cor

e dump 가 발생하지 않는다 .) Code 를 쉽게 재사용할 수 있다 . higher-order function 으로 , 강력한 추상화가

가능하다 . 메모리 관리를 자동으로 해 준다 . 프로그램의 의미에 혼돈의 여지가 없다 .( 정확한

정의가 제공된다 .)

P L U S

Haskell 의 특징 변수가 없다 . Side effect 가 없다 . ( 같은 값이 인수로 들어가면

항상 같은 결과가 나온다 .) Loop 가 없다 . 프로그램 순서가 없다 .

J = 1+II = 5

모든 것이 함수이다 .

P L U S

함수 정의n :: Intn = 12 + 10

squareInt :: Int -> IntsquareInt n = n*n

difSquare x y = (x-y)^2 -- polymorphic type

f = \x -> 2 * n

P L U S

Recursion

fac1 :: Int -> Intfac1 n = if n==1 then 1 else (n * fac (n-1))

fac2 :: Int -> Intfac2 n = prodList [1 .. n ]prodList lt = if (length h)==1 then head lt

else head lt * (prodList (tail lt))

P L U S

Pattern matching

prodLst2 [] = 0prodLst2 [x] = xprodLst2 (x:xs) = x * prodLst2 xs

isSubseq [] _ = TrueisSubseq _ [] = FalseisSubseq lt (x:xs) = (lt==start) || isSubseq lt xs

where start = take (length lt) (x:xs)

P L U S

Guards

prodLst3 lst | length lst==0 = 0| length lst==1 = head lst| otherwise = head lst * prodLst3 (tail lst)

isSublist [] _ = TrueisSublist _ [] = FalseisSublist (e:es) (x:xs)

| e==x && isSublist es xs = True| otherwise = isSublist (e:es) xs

P L U S

List comprehensions

myLst :: [(Int,Int,Int)]myLst = [(i,j,i*j) | i <- [2,4..100],

j <- [3,6..100], 0==((i+j) `rem` 7)]

qsort [] = []qsort (x:xs) = qsort [y | y<-xs, y<=x] ++ [x] ++ qsort

[y | y<-xs, y>x]

P L U S

Lazy evaluation

primes :: [Int]primes = sieve [2 .. ]sieve (x:xs) = x : sieve [y | y <- xs, (y `rem` x)/=0]

memberOrd (x:xs) n| x<n = memberOrd xs n| x==n = True| otherwise = False

isPrime n = memberOrd primes n

P L U S

Passing functions

qsortF f [] = []qsortF f (x:xs) = qsortF f [y | y<-xs, f y x] ++

[x] ++qsortF f [y | y<-xs, not (f y x)]

tailComp :: String -> String -> BooltailComp s t = reverse s < reverse t

P L U S

Indent rule

isMonotonic f n= mapping == qsort mappingwhere mapping = map f rangerange = [0..n]

iter n f x| n == 0 = x | otherwise = f (iter (n-1) f x)

P L U S

Reference

http://www.haskell.org http://ropas.kaist.ac.kr/n Haskell Tutorials

http://www.di.uminho.pt/afp98/PAPERS/Tutorial.ps

http://www.haskell.org/tutorial/Beginning Haskell @ IBM developerWorks