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

 

이 글에서는 하스켈 설치방법에 대해 언급하지 않습니다.

필요하다면 아래 링크를 참고하여 하스켈 개발에 필요한 환경을 구성해주세요.

2021.03.11 - [개발 언어/Haskell] - 하스켈 개발환경 (stack + IntelliJ plugin)

하스켈 개발환경 (stack + IntelliJ plugin)

 

하스켈은 정말 엄격한 문법을 가진 순수 함수형 프로그래밍 언어라서 Main코드부터 작성하기 어렵습니다.

보통 stack 라이브러리를 이용하여 프로젝트를 생성합니다. 이 과정이 귀찮다면 아래 사이트를 이용합시다.

Try Haskell! An interactive tutorial in your browser

 

#0. 하스켈 소스코드

하스켈이 어떻게 사용되는지 대충 살펴봅시다. 모르는 문법은 천천히 알아가면 되니, 일단 넘어갑시다.

-- Main.hs

-- Coord 변수 정의. 다른 언어처럼 메모리를 할당하는게 아니라 정의만 한다.
type Coord = (Double, Double)

-- Config 객체를 만드는 방법 (정확히는 정의만 한다.)
data Config = Config { 
	rotAt :: Coord
	, theta :: Double
	, ofs :: (Double, Double)
}


-- 간단한 함수 정의 방법. 변수의 정의와 동일하다.
type CoordConverter = Coord -> Coord


-- 이런식으로 함수를 사용해서 코드의 가독성을 직관적으로 만든다.
-- trans 함수 정의, dx와 dy를 입력받아 (x,y)에 더한다.
trans :: (Double, Double) -> CoordConverter
trans (dx, dy) = \(x,y) -> (x+dx, y+dy)


-- rotate 함수 정의, t를 입력받아 (x,y)에 더한다.
rotate :: Double -> CoordConverter
rotate t = \(x, y) -> ( x + t, y + t)


-- transByConfig 함수 정의, config 객체의 속성 값을 trans 함수를 적용한다.
-- config 객체 안에 있는 ofs를 trans 함수에 적용한다.
-- ofs :: (Double, Double)
transByConfig :: Config -> CoordConverter
transByConfig config = trans (ofs config)


-- rotateByConfig 함수 정의, 마찬가지로 config 객체의 속성값을 rotate 함수에 적용
-- theta :: Double
rotateByConfig :: Config -> CoordConverter
rotateByConfig config = postTrans . rotate (theta config) . preTrans where


-- 위에서 만든 함수들을 재사용하여 더 복잡한 기능을 수행하는 함수를 정의한다.
rotateAt = rotAt config
preTrans = trans (rotate pi $ rotateAt)
postTrans = trans rotateAt

convertByConfig :: Config -> CoordConverter
convertByConfig config = transByConfig config . rotateByConfig config


-- 메인코드 정의
-- 코드가 한줄이 아니라면 do 키워드를 이용하여 여러줄로 작성 할 수 있다.
-- 함수형 프로그래밍에서는 콘솔 입력을 정의할 수 없다. 그래서 모나드 IO() 를 사용해 구현한다.
main :: IO ()
main = do 
	let config = Config { rotAt = (0.5,0.5), theta = pi / 4, ofs = (-0.5, -0.5) }
	let unitRect = [(0,0),(0,1),(1,1),(1,0)]
	let convertedRect = map (convertByConfig config) unitRect

---

 

#1. 자료형

하스켈 기본 타입은 Int, Integer, Double, Float, Bool, Char, String이 있다.

자료형은 기본적으로 let 으로 선언하나, 보통 생략해서 사용한다.

• Int는 최소 -2^29부터 +2^29의 범위를 보장하는 정수입니다. (* OS에 따라 범위가 달라질 수 있다.)
• Integer는 값의 한계가 없는 정수 타입이다.
• Double과 Float는 각각 배정밀도, 단정밀도 부동소수점 수 타입이다.
• Bool은 True와 False를 유이한 값으로 가지는 불리언 타입이다.
• Char는 유니코드 문자를 표현하는 타입이다.
• String은 Char의 리스트지만, 문자열 표현을 허용한 타입이다.

let lostNumbers = [4,8,15,16,23,42]
-- let을 생략해도 상관없다.
-- lostNumbers = [4,8,15,16,23,42]

"HELLO" 
-- 하스켈에서 스트링은 문자열을 허용한 리스트 자료형이다.
-- ['H','E','L','L','O']

-- types.hs
i :: Int
i = -78
 
biggestInt, smallestInt :: Int
biggestInt  = maxBound -- 자료형의 최대값을 반환하는 함수
smallestInt = minBound -- 자료형의 최소값을 반환하는 함수
 
-- 임의 크기 정수
n :: Integer
n = 1234567890987654321987340982334987349872349874534

19 - 27
(-3) * (-7) -- 음수를 사용할 때는 괄호를 사용한다.
 
-- 배정밀도 부동소수점 수
d1, d2 :: Double
d1 = 4.5387
d2 = 6.2831e-4
 
-- 불리언
b1, b2, b3 :: Bool
b1 = True
b2 = False
b3 = not (False || b1) && ( b2 || True)
 
-- 유니코드 문자
c1, c2, c3 :: Char
c1 = 'x'
c2 = 'Ø'
c3 = 'ダ'
 
-- 문자열
s :: String
s = "Hello, Haskell!"

 

참고로 하스켈은 자료형에 매우 엄격한 규칙을 가지고 있다.

True == 1 
-- 컴파일 에러!

5 + 4.0 
-- 이는 5(INT)가 5.0(DOUBLE)으로 변환되어 인식하게 된다.
-- 단 반대로 double형이 int로 캐스팅 되는 경우는 없다. 하면 컴파일 에러!

 

---

 

#2. 함수

하스켈에서는 함수도 변수와 동일하게 정의(선언)해주어야 한다.

함수를 정의할 때, 함수 이름과 파라메타 변수 사이 공백만으로 구분 가능한 경우 괄호를 생략해도 상관없다.

 

• 이름 :: 선언 변수와 똑같이 :: 기호를 사용해 정의한다.

-> 는 왼쪽 타입의 값을 인자(입력, 매개변수)로 받아서 오른쪽에 전달하는 함수라는 의미이다.

parity :: Integer -> Integer
parity n = if (n `mod` 2) == 0 then 0 else 1 
-- parity n = n `mod` 2 로도 가능
 
{- 참고로 mod같은 함수가 값 가운데 들어갈 때는 ' ' 를 사용한다. -}
mod 19 3
19 'mod' 3

 

• 다음과 같은 재귀적인 호출도 자주 사용된다.

-- sumtorial.hs
-- 1부터 n까지 정수의 합을 계산한다
sumtorial :: Integer -> Integer
sumtorial 0 = 0
sumtorial n = n + sumtorial (n-1)

 

• 인자가 여러 개라면 커링(currying)을 이용하여 다음과 같이 정의 할 수 있다.

-- args.hs
f :: Int -> Int -> Int -> Int
f x y z = x + y + z
 
ex17 = f 3 17 8  -- 28

 

• 물론, 기존의 프로그래밍 방식처럼 여러 개의 인자를 튜플(Pair)로 묶어서 하나처럼 사용 할 수 도 있다.

p :: (Int, Char)
p = (3, 'x')
 
-- sumPair.hs
sumPair :: (Int,Int) -> Int
sumPair (x,y) = x + y

---

 

#3. 함수의 커링 (Curring)

인자를 여러 개를 받는 함수를 분리하여, 인자를 하나씩만 받도록 만드는 기법이다.

구현은 조금 어려울 수 있지만, 함수의 재사용성과 가독성을 올려준다는 장점이 있다.

 

함수를 변수처럼 반환 할 수 있기 때문에, 반환 값에 함수를 넣어 사용한다고 생각하면 된다.

이해하기 쉽게 자바스크립트로 예를 들어보자

// uncurrying
function greet(greeting, name){
    console.log(greeting + , ", " + name);
}

greeting("Hello","Jiwon");

// currying
function greet(greeting){
    return function(name){
        console.log(greeting + ", " + name);
    }
}

greet('Hello')('Jiwon')

 

함수의 구현은 까다롭게 보일 수 있지만, 커링을 이용하면 다음과 같은 체이닝(Chaining) 문법을 쉽게 만들 수 있다

function multiplyThree(x) {
  return function(y) {
    return function(z) {
      return x * y * z;
     }
  };
}
multiplyThree(4)(8)(2); 
// multiplyThree(x) 의 반환값은 function이라 이런식으로 사용 가능하다.

 

그리고 프로그래밍 언어 개발자들도 이렇게 구현하는 것이 어렵고 가독성이 떨어진다는 걸 알고 있기에, 보통 하스켈 처럼 한 줄로 작성할 수 있는 함수형 문법(화살표 함수, 람다 등)을 따로 제공해준다.

// 자바스크립트의 화살표 함수, 위의 greet()과 동일한 함수이다.
greet = greeting => name => console.log(greeting + ', ' + name);
//    = gretting => function() {...}
//    = gretting => ( name => console.log )
greet('Hello')('name')

mulriplyThree = x => y => z => x * y * z;
multiplyThree(4)(8)(2); 

---

 

#4. 조건문 (if, guard)

• 하스켈에서 if문을 지원하긴 하지만, 함수형 프로그래밍 방식에서는 잘 사용하지는 않는다.

-- b가 참이면 t를, 거짓이면 f를 값으로 대입한다.(정의한다)
if b then t else f

 

함수형 프로그래밍에서는 조건 절은 {key : value} 같은 자료형을 이용해 패턴 매칭을 주로 사용한다.

하스켈에선 guard( | ) 연산자를 적절히 이용해서 패턴 매칭을 구현할 수 있다..

parity2 :: Integer -> Integer
parity2 n
  | n `mod` 2 == 0 = 100 // n%2 == 0 이면 100 반환
  | otherwise == 1 = 200 // else 200 반환
  
  // else == otherwise

count :: Integer -> String
count 0 = "패턴매칭0" 
count 1 = "패턴매칭1"
count 2 = "패턴매칭2" 
count n = "Default"

보통 아래와 같이 위의 2가지 문법을 적절히 섞어 사용한다.

-- foo.hs
foo :: Integer -> Integer
foo 0 = 16
foo 1 
  | "Haskell" > "C++" = 3
  | otherwise         = 4
foo n
  | n < 0            = 0
  | n `mod` 17 == 2  = -43
  | otherwise        = n + 3

---

 

#5. Type과 Data

Type

선언하지 않아도 기본적으로 제공되는 타입도 있지만, 우리가 직접 타입을 만들어서 사용해도 된다.

-- 스트링은 [Char] 타입이다.
type MyString = [Char] 
type Pos = (Int, Int)

str :: MyString
str = "Hello"

origin :: Pos
origin = (0, 0)

left :: Pos -> Pos
left (x, y) = (x-1, y)

 

• 참고로 객체의 타입을 알고싶다면 :type 또는 :t 를 이용하면 타입을 출력 할 수 있다.

Prelude> :type True
True :: Bool

Prelude> :t (3 < 5)
(3 < 5) :: Bool

Prelude> :t 'H'   -- 따음표는 한 문자 (Char)을 의미한다.
'H' :: Char

Prelude> :t "Hello World"   -- 쌍 따음표는 스트링(=리스트)을 의미한다
"Hello World" :: [Char]

 

Data

다른 언어의 MyClass a = MyClass() 처럼 아예 새로운 자료형을 만들고 싶은 경우 Data 키워드를 이용하면 됩니다.

-- Bool 자료형은 False와 True를 값으로 사용합니다.
data Bool = False | True

-- Answer 자료형은 Yes와 No와 Unknown을 값으로 사용합니다.
data Answer = Yes | No | Unknown

answers :: [Answer]
answers = [Yes, No, Unknown]

flip :: Answer -> Answer
flip Yes = No
flip No = Yes
flip Unknown = Unknown

data Move = Left 
	| Right 
	| Up 
	| Down

move :: Move -> Pos -> Pos
move Up (x, y) = (x, y-1)
move Left (x, y) = (x-1, y)
move Down (x, y) = (x, y+1)
move Right (x, y) = (x+1, y)

moves :: [Move] -> Pos -> Pos
moves [] p = p
moves (m:ms) p = moves ms (move m p)

> move Left (1, 1)
-- 출력값: (0,1)

> moves [Left, Right, Up, Down, Left] (0, 0)
-- 출력값: (-1,0)

---

#6. list (리스트)의 기본 사용법

리스트는 같은 자료형을 가진 값들을 하나로 합칠 수 있습니다. ( 자료형이 다르면 컴파일 에러 )

-- let은 생략해도 상관없다.
let numbers = [1,2,3,4]
let truths  = [True, False, False]
let strings = ["here", "are", "some", "strings"]


-- 앞에도 말했지만, 하스켈의 문자열은 리스트로 이루어져있다.
"hello"
// ['h','e','l','l','o']


-- 리스트 중첩도 가능하다.
-- 아래의 경우 자료형은 [Int]이다. 이는 Int와 다른 자료형으로 판단한다.
let listOfLists = [[1,2],[3,4],[5,6]]

 

• 리스트와 기본 자료형을 이어 붙이고 싶다면 값을 건네주는 Constructor 연산자 (:)를 사용한다.

5:[1,2,3,4]
-- 출력값 : [5,1,2,3,4]

'가' : "나다라마"
-- 출력값 : "가나다라마"

1:2:3:[]
-- 출력값 : [1,2,3]

 

• 리스트를 연결하는 Concate 연산자(++)를 이용해 두 리스트를 이어 붙일 수 있다.

[1,2,3,4] ++ [9,10,11,12]
-- 출력값 : [1,2,3,4,9,10,11,12]  

'WO' ++ 'OT'
--  출력값 : 'WOOT'

['w','o'] ++ ['o','t'] 
--  출력값 : 'woot'

 

• 리스트의 특정 인덱스 값을 가져오고 싶다면 (!! n)을 사용한다.

 "Steve Buscemi" !! 6
 -- 출력값 'B' (6번째 인덱스 값)
 
 [0, 1, 2, 3, 4] !! 1  
 -- 출력값 1

 

• 이중점 연산자(..)를 이용해 연속적인 값이나 무한 리스트를 만들 수 있습니다.

[1..10]          --출력값 : [1,2,3,4,5,6,7,8,9,10]
[2,4..10]        --출력값 : [2,4,6,8,10]
[5,4..1]         --출력값 : [5,4,3,2,1]
[1,3..10]        --출력값 : [1,3,5,7,9]


[1..] -- 무한 리스트 생성

-- 당연히 무한리스트 자체를 사용하지는 않고, 일부를 추출합니다.
-- take 키워드를 이용하여 무한리스트의 일부분 추출
take 10 [1..]   -- 출력값: [1,2,3,4,5,6,7,8,9,10]

 

• 리스트를 재귀적으로 생성 할 수도 있다. 만약 마지막 값(빈 리스트)의 처리를 적지않으면 재귀함수가 끝나지 않기 때문에 무한 리스트를 생성하게 된다.

doubleList :: [Integer] -> [Integer]
doubleList [] = []   -- 빈 리스트를 입력받으면 빈 리스트를 반환한다.
doubleList (n:ns) = (n * 2) : doubleList ns   -- 그 외 입력

doubleList [1,2,3,4]
-- 출력값 : [2,4,6,8]

{- 이 코드는 아래의 정의와 똑같이 동작한다.  -}
doubleList 1:[2,3,4] = (1*2) : doubleList (2 : [3,4])
                     = (1*2) : (2*2) : doubleList (3 : [4])
                     = (1*2) : (2*2) : (3*2) : doubleList (4 : [])
                     = (1*2) : (2*2) : (3*2) : (4*2) : doubleList []
                     = (1*2) : (2*2) : (3*2) : (4*2) : []
                     = 2 : 4 : 6 : 8 : []
                     = [2, 4, 6, 8]

 

우와! 오늘치 공부 다했다!

하스켈은 러닝커브(배우는 과정)이 끔찍한 언어입니다. 여기까지 읽는다고 고생하셨습니다.

아직 설명안한 내용이 많지만, 일단 한번 쉬어가도록 합시다.