아주 멋진 하스켈을 같이 배워보자 #3

이번시간에는 직접 GHCI를 다루며 다른 언어와 비슷한 사용법을 배워봅시다.

실제 Main코드를 다루는 건 다음글에 설명하겠습니다. 지금은 간단하게 어떤 기능들이 있는지 가볍게 알아보고 갑시다.

 

참고로 함수를 중간에 입력하고 싶다면 따음표( ' ~ ' ) 를 통해 함수임을 알려주어야 합니다.

myFunc 3 5

3 'myFunc' 5

 

0. GHCI 사용방법  ( 강제종료 Ctrl + D ) 

콘솔창에 GHCI를 입력하면 되며 스택을 이용하여 설치했다면 아래 명령어로 실행가능합니다.

stack ghci

 

 

1. max min succ (successor, 해당 값에 +1)

ghci> succ 9
10
ghci> (succ 9) + (max 5 4) + 1  
16  

---

2. 첫번째 함수

doubleMe x = x + x 

ghci> :l baby  
[1 of 1] Compiling Main             ( baby.hs, interpreted )  
Ok, modules loaded: Main.

ghci> doubleMe 9  
18  
ghci> doubleMe 8.3  
16.6

---

3. 인자가 2개인 함수

doubleUs x y = x*2 + y*2  

ghci> doubleUs 4 9  
26  
ghci> doubleUs 2.3 34.2  
73.0  

---

4. if문 사용 (함수형에서 사용하는 방법은 아님.)

ghci> :{ doubleSmallNumber x = if x > 100  
                        then x	-- 조건이 참인경우
                        else x*2  -- else
:}

ghci> doubleSmallNumber2 x = (if x > 100 then x else x*2) + 1  

ghci> doubleSmallNumber 99
198
ghci> doubleSmallNumber2 10
21

---

5. 튜플

하스켈에서는 모든 값을 하나로 보고, 하나로 전달합니다. 여러 값이 필요하다면 (튜플)로 묶어서 사용합니다.

 

( a, b ) 와 ( a, b, c ) 는 다른 자료형으로 인식됩니다. 

( 3, "Hi" ) 와 ( 3, 4 ) 도 다른 자료형으로 인식합니다. 튜플은 내부의 자료형과 길이가 같아야 같은 자료형으로 봅니다.

[(1,2), (3,4), (5,6)] -- 가능
[(1,2), (3,4,5), (6,7)] -- 에러!

 

길이가 2인 튜플은 fst와 snd를 사용 할 수 있습니다.

ghci> fst (8,11)  
8  
ghci> fst ("Wow", False)  
"Wow" 

ghci> fst(1,2,3) -- 에러!

 

zip [..] [..] 를 이용하면 손쉽게 길이가 2인 튜플을 만들 수 있습니다.

ghci> zip [1..] ["one", "two", "three", "four", "five"]  
[(1,"one"),(2,"two"),(3,"three"),(4,"four"),(5,"five")]  

ghci> zip [5,3,2,6,2,7,2,5,4,6,6] ["im","a","turtle"]  
[(5,"im"),(3,"a"),(2,"turtle")]  

---

6. 리스트 컴프리헨션 (생성)

리스트 Comprehension은 리스트 내에 간단한 조건식을 적어 요소를 생성하는 방법입니다.

[ 출력 값 | 생성 규칙, 조건 ]

ghci> let mylist = [ (a,b,c) | a <- [1], b <- [1,2], c <- [1..3] ]  
ghci> mylist
[(1,1,1),(1,1,2),(1,1,3),(1,2,1),(1,2,2),(1,2,3)]

ghci> [x*2 | x <- [1..10]]  
[2,4,6,8,10,12,14,16,18,20]  

ghci> [x*2 | x <- [1..10], x*2 >= 12]  
[12,14,16,18,20]  

ghci> [ x | x <- [50..100], x `mod` 7 == 3]  
[52,59,66,73,80,87,94]   

 

• 함수처럼 만들어 입력 값을 받아 생성하는 것도 가능합니다.

ghci> boomBangs xs = [ if x < 10 then "BOOM!" else "BANG!" | x <- xs, odd x]
-- xs 중 짝수만 입력받아서 if .. 조건에 넣음.

ghci> boomBangs [7..13]  
["BOOM!","BOOM!","BANG!","BANG!"]   

ghci> removeNonUppercase st = [ c | c <- st, c `elem` ['A'..'Z']]  

ghci> removeNonUppercase "Hahaha! Ahahaha!"  
"HA"  
ghci> removeNonUppercase "IdontLIKEFROGS"  
"ILIKEFROGS"   

 

• 조건을 여러 개 적는 것도 가능합니다.

-- /= 는 다른 언어의 != 와 같은 의미입니다.
ghci> [ x | x <- [10..20], x /= 13, x /= 15, x /= 19]  
[10,11,12,14,16,17,18,20]  

ghci> [ x*y | x <- [2,5,10], y <- [8,10,11]]  
[16,20,22,40,50,55,80,100,110]   

 

• 다른 변수를 가져와 사용 할 수도 있습니다.

ghci> let nouns = ["hobo","frog","pope"]  
ghci> let adjectives = ["lazy","grouchy","scheming"]  
ghci> [adjective ++ " " ++ noun | adjective <- adjectives, noun <- nouns]  
["lazy hobo","lazy frog","lazy pope","grouchy hobo","grouchy frog",  
"grouchy pope","scheming hobo","scheming frog","scheming pope"]  

 

• 입력 값이 필요 없는 경우 _ 를 사용합니다.

length xs = sum [1 | _ <- xs] 
-- xs의 요소 갯수만큼 1을 만듭니다.
-- 그 1을 더하면 길이가 나옵니다. 네 비효율적인 쓸모없는 함수에요.

 

• 중첩 리스트도 가능합니다. 다음과 같이 사용하면 됩니다.

ghci> let xxs = [[1,3,5,2,3,1,2,4,5],[1,2,3,4,5,6,7,8,9],[1,2,4,2,1,6,3,1,3,2,3,6]] 

ghci> [ [ x | x <- xs, even x ] | xs <- xxs]  
[[2,2,4],[2,4,6,8],[2,4,2,6,2,6]]  

---

7. 리스트 함수

변수를 선언할 때 사용하는 let은 생략해도 됩니다. (자동으로 인식)

리스트는 같은 자료형만 넣을 수 있습니다. 자료형이 다르면 컴파일 에러

하스켈의 문자열은 문자로 된 리스트입니다. "HELLO" ==  ['H','E','L','L','O'] 

ghci> let lostNumbers = [4,8,15,16,23,42]  
ghci> lostNumbers  
[4,8,15,16,23,42]  

 

• range( .. ) 연산자로 규칙적인 요소를 생성 할 수 있습니다.

ghci> [1..20]  
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]  
ghci> ['a'..'z']  
"abcdefghijklmnopqrstuvwxyz"  
ghci> ['K'..'Z']  
"KLMNOPQRSTUVWXYZ" 

ghci> [2,4..20]  
[2,4,6,8,10,12,14,16,18,20]  
ghci> [3,6..20]  
[3,6,9,12,15,18]   

다만, 소수점을 사용할 때에는 값이 정확하지 않을 수 있습니다. ( 부동소수점 오차 )

ghci> [0.1, 0.3 .. 1]  
[0.1,0.3,0.5,0.7,0.8999999999999999,1.0999999999999999]  

 

 

• 콜론 ( : ) 연산자를 이용하여 한 문자를 리스트 앞에 합칠 수 있습니다.

ghci> 'A':" SMALL CAT"  
"A SMALL CAT"  
ghci> 5:[1,2,3,4,5]  
[5,1,2,3,4,5]  

 

• Conact ( ++ ) 연산자를 이용해 리스트를 이어 붙일 수 있습니다.

ghci> > [1,2,3,4] ++ [5,6,7,8]
[1,2,3,4,5,6,7,8]

ghci> let b = [[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]  
ghci> b ++ [[1,1,1,1]]  
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3],[1,1,1,1]]  

 

• head는 첫번째 값을, tail은 나머지 값을 반환합니다. (마지막 값은 last, 마지막을 뺀 나머지는 init)

ghci> head [5,4,3,2,1]  
5   
ghci> tail [5,4,3,2,1]  
[4,3,2,1]   

ghci> last [5,4,3,2,1]  
1   
ghci> init [5,4,3,2,1]  
[5,4,3,2]   

ghci> head []  -- 빈 리스트는 에러
*** Exception: Prelude.head: empty list  

 

• length(길이), null(비어있는지 확인) reverse(반전)

ghci> length [5,4,3,2,1]  
5  

ghci> null [1,2,3]  -- 빈 리스트인지 확인
False  
ghci> null []  
True  

ghci> reverse [5,4,3,2,1]  
[1,2,3,4,5] 

 

• take (0~n개 까지 리스트 추출), drop(n~마지막까지 리스트 추출)
• take 5 [2, 4..] 와 같이 응용도 가능합니다.

ghci> take 3 [5,4,3,2,1]  
[5,4,3]  
ghci> take 1 [3,9,3]  
[3]  
ghci> take 5 [1,2]  
[1,2] -- 갯수가 부족하면 전체 리스트를 반환합니다. 
ghci> take 0 [6,6,6]  
[]  

ghci> drop 3 [8,4,2,1,5,6]  
[1,5,6]  
ghci> drop 0 [1,2,3,4]  
[1,2,3,4]  
ghci> drop 100 [1,2,3,4]  
[] 

 

• Cycle (구간반복) 과 repeat(단순반복)을 이용하면 쉽게 무한 리스트를 생성 할 수 있습니다.
• 무한 리스트를 만들고 싶지 않다면 replicate 요소 n 으로 생성 할 수 있습니다.

ghci> take 10 (cycle [1,2,3])  
[1,2,3,1,2,3,1,2,3,1]  
ghci> take 12 (cycle "LOL ")  
"LOL LOL LOL " 

ghci> take 10 (repeat 5)  
[5,5,5,5,5,5,5,5,5,5] 

ghci> replicate 3 10
[10,10,10]

 

• minimum(최소), maximum(최대), sum(전체합계), product(전체곱셈)

ghci> minimum [8,4,2,1,5,6]  
1  
ghci> maximum [1,9,2,3,4]  
9   

ghci> sum [5,2,1,6,3,2,5,7]  
31  

ghci> product [6,2,1,2]  
24  
ghci> product [1,2,5,6,7,9,2,0]  
0   

 

• 요소 'elem' ( 존재 여부 확인 )

ghci> 4 `elem` [3,4,5,6]  
True  
ghci> 10 `elem` [3,4,5,6]  
False  

 

이제 대충 사용법에 대해 익혔으니, 다음 글에서는 Main을 배워 실행가능한 코드를 작성해봅시다.