3장 유형과 유형클래스¶

아래 주피터 노트북은 James Brock의 learn-you-a-haskell-notebook을 기본틀로 사용합니다.

참고: 린팅(linting) 기능 끄기

린팅(linting): IHaskell에서 HLint라고 불리는 린터(linter)에 의해 보다 적절하다고 판단하는 표현식을 제안하는 기능
보다 세련된 표현식(expression)을 제안하는 도구임. 하지만 반드시 필요한 기능은 아니다
참조: IHaskell의 린팅 기능 설정하기

:opt no-lint

참고: 주피터랩 단축키

주피터랩에서 가장 유용한 단축키 조합은 다음과 같다.

단축키 조합	실행결과
`Shift`+`Enter`	선택한 셀을 실행하고 다음 셀로 이동
`Ctrl`+`Enter`	선택한 셀을 실행. 다음 셀로 이동하지 않음
`Alt`+`Enter`	선택한 셀을 실행하고 선택한 셀 뒤에 새로운 셀 삽입
`Enter`	선택한 셀 편집
`Ctrl`+`Shift`+`-`	커서 위치에서 셀 분할

모든 가능한 단축키 조합은 왼편 사이드바에 위치한 돋보기 아이콘을 눌러 확인하거나 검색할 수 있다. 주피터랩의 단축키 설정 및 주요 단축키에 대한 자세한 설명은 주피터랩 인터페이스를 참조할 수 있다.

3.1 유형(Types)¶

하스켈은 견고한 유형 체계를 가진다. 모든 표현식의 유형은 컴파일 과정에서 결정되며, 이로 인해 작성된 코드의 안전성이 높아진다. 예를 들어, 부울 유형을 어떤 숫자로 나누려하는 프로그램을 작성하면, 이 프로그램은 컴파일조차 되지 않는다. 즉, 프로그램이 실행중에 중단될 수도 있는 오류를 일을 컴파일 과정에서 막아낸다. 하스켈에서 다뤄지는 모든 대상은 유형을 갖기에, 프로그램이 컴파일 되기 전에 프로그램에 대한 많은 정보를 알아낼 수 있다. 따라서 하스켈의 유형 체계를 이해하는 일이 매우 중요하다.

유형 추론(type inference)¶

정적 유형 언어인 C, 자바 등과는 하스켈은 주어진 대상의 유형을 추론할 수 있다. 만약 숫자를 작성하면 하슷켈 스스로 그것이 숫자라는 것을 추론(infer) 할 수 있다. 따라서 함수와 표현식의 유형을 일반적으로 명시하지 않아도 된다.

주의사항: 예외가 있다. 나중에 살펴볼 것이다.

유형은 모든 표현식이 갖는 일종의 라벨(label)이다. 유형은 주어진 표현식이 어떤 부류에 속하는가에 대한 정보를 알려준다. 예를 들어 True는 부울(Bool) 유형을, "hello"는 문자열 유형을 갖는다.

GHCi를 사용해 일부 식의 유형을 살펴보자. :t 명령문을 이용하여 주어진 표현식의 유형을 알아볼 수 있다.

더블 콜론(::)의 의미
- 왼편: (주어진) 표현식
- 오른편: (주어진) 표현식의 유형
- (주어진) 표현식은 "~ 유형을 갖는다", "~ 유형에 속한다"로 설명함.
유형은 항상 대문자로 시작함.

:t 'a'

'a'의 유형: Char.
Char는 character 의 약자.

:t True

True의 유형: Bool.

:t "HELLO!"

"HELLO!"의 유형: [Char]
[Char]에서 대괄호는 리스트를 표현함. 즉, [Char]는 문자로 구성된 리스트를 의미함.

:t (True, 'a')

:t ('a','b','c')

(True, 'a')의 유형: (Bool, Char)
('a','b','c')의 유형: (Char, Char, Char)
리스트와는 달리, 튜플의 길이 또한 유형을 결정함.

:t 4 == 5

4 == 5의 유형: Bool
이유: 4 == 5는 False 로 계산되는데, False가 Bool 유형을 가짐.

함수의 유형¶

하스켈의 표현식은 함수를 활용하여 생성한다. 따라서 함수 또한 유형을 갖는다. 함수를 작성할 때, 함수의 유형을 명시적으로 표기할 필요는 없지만 매우 간단한 함수 정의를 작성할 때를 제외하고, 일반적으로는 유형 선언을 해주는 것이 좋다. 따라서 지금부터 선언되는 모든 함수에 유형을 명시할 것이다.

예제

2장에서 조건제시법을 이용하여 문자열에서 대문자만 남기는 함수 removeNonUppercase를 다음과 같이 정의하였다.

removeNonUppercase str = [ c | c <- str, c `elem` ['A'..'Z']]

이제 위 함수의 유형을 확인해보자.

:t removeNonUppercase

removeNonUppercase 함수의 유형은 [Char] -> [Char] 이며, 하나의 문자열을 인자로 받아 다른 문자열을 반환하는 함수라는 의미이다.

이렇듯 removeNonUppercase 함수와 같이 간단한 함수의 유형은 하스켈 컴파일러가 스스로 추론해낼 수 있다. 따라서 애초에 위 함수를 아래와 같이 정의할 수도 있다.

removeNonUppercase :: [Char] -> [Char]
removeNonUppercase str = [ c | c <- str, c `elem` ['A'..'Z']]

[Char]와 String은 동의어이이기에 아래와 같이 정의하는 게 보다 직관적이다.

removeNonUppercase :: String -> String
removeNonUppercase str = [ c | c <- str, c `elem` ['A'..'Z']]

예제

아래에 정의된 addThree 함수는 세 개의 정수를 인자로 받아 세 정수의 합을 계산하여 반환한다. 따라서 함수의 유형은 세 개의 정수 유형(Int)를 사용하고, 반환값 또한 정수 유형(Int) 임을 암시해야 한다.

addThree :: Int -> Int -> Int -> Int
addThree x y z = x + y + z

매개변수들의 유형은 ->로 구분하며, 반환값의 유형은 맨 마지막에 명시한다.

주의사항

함수의 기능상 유형을 아래와 같이 작성할 수도 있지만 엄밀하게 말하면 다른 유형이다. 이유는 차차 알게될 것이다.
```
(Int, Int, Int) -> Int
```
앞서 살펴 보았듯이 함수를 정의할 때 유형을 정확히 모르겠다면 먼저 유형 선언 없이 함수를 작성한 다음에 :t 명령문을 이용하여 함수의 유형을 확인할 수 있다.

하스켈의 기본 유형¶

`Int` 유형¶

1, 2, 3 등 정수들의 유형이며, 최솟값과 최댓값으로 제한된 구간에 포함된 정수들을 대상으로 한다.

addThree 3 5 7

15

주의사항: 이렇듯 제한된 구간의 값을 갖는 유형의 최솟값과 최댓값은 minBound 와 maxBound 함수를 이용하여 확인할 수 있다. 예를 들어, Int 형의 경우 최솟값과 최댓값은 다음과 같이 확인한다.

(minBound::Int)

-9223372036854775808

(maxBound::Int)

9223372036854775807

`Integer` 유형¶

또다른 정수들의 유형이다. 하지만 Int와 달리 Integer에 속한 정수는 제한되지 않는다. 즉, 엄청 큰 숫자를 다뤄야 하는 경우 사용한다. 예를 들어, 아래 factorial 함수는 계승과 같이 매우 큰 수를 계산하기에 Integer 유형을 사용한다.

factorial :: Integer -> Integer
factorial n = product [1..n]

factorial 50

30414093201713378043612608166064768844377641568960512000000000000

주의사항: Int 유형에 속한 정수를 다루는 일이 보다 빠르고 효율적이기에, 그렇게 큰 정수를 다룰 필요가 없다면 Int 유형이 권장된다.

`Float` 유형¶

단 정밀도(single precision)를 갖는 부동소수점들의 유형이다.

아애 함수는 반지름이 주어졌을 때 원의 둘레를 계산한다.

circumference :: Float -> Float
circumference r = 2 * pi * r

circumference 4.0

25.132742

참고

부동소수점: 실수를 컴퓨터에서 구현하는 일반적인 방식을 따른 수. 실제로는 소숫점 이하가 제한된 유리수임.
단 정밀도(single precision): 하나의 부동소수점을 계산할 때 사용되는 메모리가 32비트로 제한됨.
배 정밀도(double precision): 하나의 부동소수점을 계산할 때 사용되는 메모리가 64비트까지 확장됨.
이외에 부동소수점을 계산할 때 사용하는 메모리의 한계에 따라 다양한 정밀도가 제공됨.

`Double` 유형¶

두 배의 정밀도를 가진 부동소수점들의 유형이다. 아래 예제를 통해 단 정밀도를 사용할 때와 배 정밀도를 사용할 때의 차이를 확인할 수 있다.

circumference' :: Double -> Double
circumference' r = 2 * pi * r

circumference' 4.0

25.132741228718345

`Bool` 유형¶

진리값을 포함하는 부울 유형이며, True 와 False 오직 두 개의 값과 동치인 표현식만 부울 유형에 속한다.

:t True

(1 == 2) 는 False 와 동치인 표현식이다.

:t (1 == 2)

`Char` 유형¶

문자들의 유형이며, 키보드 상에서 보이는 문자 뿐만 아니라 유니코드(Unicode)에 포함된 모든 문자가 이 유형을 갖는다. 문자는 작은 따옴표(')로 감싸져야 한다.

:t 'A'

주의사항

하나의 문자라 하더라도 큰 따옴표(")로 감싸이면 문자열, 즉 문자 리스트로 인식된다.

:t "A"

유형 변수(Type variables)¶

앞서 살펴본 기본 유형들은 사용되는 값들에 의존하지 않는다. 반면에 리스트 유형과 튜플 유형은 항목의 유형에 따라 유형이 달라진다. 즉, 무한히 많은 리스트 유형과 튜플 유형이 존재한다.

:t ['a','b','c']

:t [True, False, 1 == 2, True || 2 == 2]

:t ('a', 'b', True)

:t ('a', 'b')

이와 같이 무수히 많은 유형을 고정된 형식으로 표현하기 위해 유형 변수(type variable) 를 활용한다.

예를 들어, 임의의 리스트와 함께 호출하면 head 는 주어진 리스트의 머리(head)를 반환한다. 따라서 임의의 유형의 리스트를 다룰 수 있어야 한다. head 함수의 유형은 다음과 같다.

:t head

head의 유형을 읽는 방식은 다음과 같다.

임의의 유형 a에 대해, 유형 a의 값으로 이루어진 리스트가 인자로 들어오면 a 유형의 값을 반환한다.

예를 들어, 정수 리스트가 인자로 들어오면 정수를 반환하고, 문자열이 들어오면 문자가 반환된다. 이렇듯 a는 임의의 유형을 대변하는 역할을 수행하는 유형 변수이다.

주의사항

유형 변수는 변수이지 그 자체로 유형은 아니다.
유형 변수의 이름은 한 글자 이상일 수 있지만, 보통 a, b, c, d 등으로 이름을 붙인다.

길이가 2인 튜플에서 첫 번째 항목을 반환하는 함수 fst의 유형도 비슷한 모양을 갖는다.

:t fst

fst의 유형을 읽는 방식은 다음과 같다.

임의의 유형 a와 b에 대해, a 유형의 값과 b 유형의 값으로 이루어진 길이가 2인 튜플 인자로 들어오면 a 유형의 값을 반환한다.

주의사항

a와 b 두 유형 변수 이름이 다른 이유는 각 변수 대신에 서로 다른 유형을 대입해서 사용할 수 있다는 의미이다. 하지만, 두 변수 모두 동일한 유형을 가리켜도 된다.
일반적으로 여러 개의 서로 다른 유형 변수를 사용할 수 있으며, 이는 각 변수에 대해 서로 다른 유형을 사용할 수 있다는 의미이지 반드시 달라야 한다는 의미는 아니다.

fst 함수와 짝을 이루는 snd 함수의 유형은 다음과 같이 반환값의 자료형이 b로 표시된다.

:t snd

snd의 유형을 읽는 방식은 다음과 같다.

임의의 유형 a와 b에 대해, a 유형의 값과 b 유형의 값으로 이루어진 길이가 2인 튜플 인자로 들어오면 b 유형의 값을 반환한다.

다형 함수¶

head, fst, snd 이외에 tail, last, init 등 리스트와 튜플 관련 많은 함수들이 모두 아래 모양의 유형을 갖는다.

forall a b c. ...

위 모양의 유형을 갖는 함수를 다형 함수(polymorphic functions), 위와 같이 다형함수를 지원하는 기능을 다형성(polymorphism) 이라 부른다. 앞서 살펴보았듯이 다형성을 활용하여 여러 유형에 대해 작동하는 보다 일반화된 함수를 정의할 수 있다.

주의사항: C++, 자바, 파이썬 등의 언어에서 지원하는 제네릭(generic) 클래스 개념이 바로 이 다형성을 응용한 것이다.

3.2 유형클래스(Typeclasses)¶

유형클래스(typeclass) 는 유형이 가져야 하는 성질과 기능을 묘사하는 일종의 인터페이스(interface) 이다. 특정 유형이 어떤 유형클래스가 묘사하는 성질과 기능을 모두 가질 때, 해당 유형이 그 유형클래스에 속한다 라고 말한다.

참고

객체 지향 프로그래밍언어(OOP)의 클래스 개념과 유사하지만 사용법이 많이 다르다.
자바의 인터페이스와 가장 비슷하게 작동한다.
- 자바: 인터페이스를 먼저 정의한 후에 해당 인터페이스를 구현하는(implements) 클래스를 정의함.
- 하스켈: 유형과 유형클래스를 상호 독립적으로 정의한 후에, 유형이 특정 유형클래스가 제공하는 인터페이스를 구현할 수 있는지 여부를 검사함.

유형클래스를 이해하기 위해 동치성(equality)을 검사하는 함수 == 의 유형을 이용해보자.

참고: ==, +, *, -, /, 등 일반 알파벳이 아니라 특수한 문자로만 구성된 함수들은 중위 함수이다. 하지만 유형을 확인하기 위해서는 전위 함수 형태로 사용해야 하는데 이를 위해 중위 함수를 소괄호로 감싸면 된다.

:t (==)

head, fst 등과는 다르게, 'Eq a =>' 부분이 추가되었다. 기호 => 왼편에 명시된 부분은 해당 함수의 인자들이 만족시켜야 하는 클래스 제약(class constraint) 을 나타낸다.

예를 들어, 동치성 검사 함수 (==)에 사용되는 두 인자 모두 Eq 유형클래스에 속하는 유형 a의 값이어야 함을 위 유형으로부터 알 수 있다. 실제로 (==)의 유형의 의미는 다음과 같다.

Eq 클래스에 속하는 임의의 유형 a에 대해, a 유형의 값 두 개를 인자로 받으면 부울값을 반환한다.

즉, "Eq 클래스에 포함되는 유형" 이라는 조건이 허용되는 유형을 제약한다. 실제로 두 값의 동치성을 검사하려면 우선적으로 두 값이 동일한 값을 나타내는지 여부를 검사할 수 있어야 한다. 예를 들어, 두 정수의 동치성, 두 문자의 동치성, 두 진리값의 동치성은 검사가 가능하다. 반면에 두 함수의 동치성은 검사가 불가능한데, 이는 튜링의 정지문제(Turing's Halting Problem)를 이용하여 증명할 수 있다는 사실 정도만 기억해 두기 바란다.

참고: 나중에 소개할 IO 라는 입출력 처리 유형과 함수의 유형을 제외한 모든 표준 하스켈 유형은 Eq 유형클래스에 포함된다.

클래스 제약 'Eq a'를 사용하는 또 다른 함수는 예를 들어 리스트의 특정 값 포함여부를 검사하는 elem 함수이다.

:t elem

그런데 elem의 유형은 보다 복잡하고, 모든 내용을 여기서 설명하기에는 무리이다. 단순한 설명을 위해 아래 두 사항을 고려하자.

t a: [a]로 이해할 것.
Foldable t: 여기선 무시.

그러면 elem의 유형은 아래와 같이 이해된다.

elem :: forall a. Eq a => a -> [a] -> Bool

즉, elem 함수 또한 Eq 클래스에 속하는 임의의 유형 a의 값으로 이루어진 리스트에 대해서만 특정 값의 포함여부를 검사한다. 사실 특정 값이 리스트에 포함되었는지를 검사하려면 리스트에 포함되어 있는 모든 항목과의 동치성 검사가 가능해야 함을 쉽게 이해할 수 있다. 위 유형은 이런 내용을 정확하게 반영하고 있다.

하스켈의 기본 유형클래스¶

`Eq` 유형클래스¶

Eq 유형클래스는 동치성을 검사하는 함수 ==와 비동치성을 검사하는 함수 /=의 유형과 특성을 지정하는 인터페이스(interface)를 제공한다. 즉, Eq 유형클래스에 포함되는 유형은 동치성과 비동치성 검사를 모두 허용하며, Eq a 클래스 제약을 사용하는 함수는 정의 부분 어딘가에서 동치성 또는 비동치성 검사를 사용함을 의미한다.

참고: Eq 유형클래스를 포함한 하스켈의 기본 유형클래스의 정확한 정의는 적절할 때에 살펴볼 것이며, 여기서는 일단 유형클래스의 역할만을 조명한다.

앞서 언급한대로 지금까지 살펴본 유형 중에서 함수의 유형을 제외한 모든 유형은 Eq 유형클래스에 속한다.

5 == 5

True

5 /= 5

False

'a' == 'a'

True

"Ho Ho" == "Ho Ho"

True

3.432 == 3.432

True

`Ord` 유형클래스¶

Ord 유형클래스에 속하는 유형의 값들은 서로 크기 비교를 할 수 있다. 함수의 유형을 제외한 지금까지 다룬 모든 유형은 Ord 유형클래스에 속한다.

Ord 는 일반적으로 사용되는 모든 비교 함수를 인터페이스로 제공한다.

>, <, >=, <=
compare: Ord 유형클래스에 속한 유형의 두 값을 비교하여 Ordering 유형의 값을 반환함.
- Ordering: 아래 세 개의 값으로 구성된 유형
  - GT (greater than, 크다)
  - LT (less than, 작다)
  - EQ (equal, 같다)
min, max

예를 들어, < 함수의 유형은 다음과 같다.

:t (>)

위 유형은 > 함수는 Ord 유형클래스에 속한 유형에 대해서만 작동한다는 것을 의미한다. 이것을 다르게 표현하면, 특정 유형 a가 Ord 유형클래스에 포함되려면 아래 유형을 갖는 함수를 정의할 수 있어야 한다는 것을 나타낸다.

a -> a -> Bool

유형클래스에 포함된 함수의 유형이 해당 유형클래스를 클래스 제약으로 갖는 것의 자세한 의미는 이후에 보다 자세히 설명한다.

<=, >=, compare 함수를 통해 알 수 있듯이 Ord의 멤버가 되기 위해서는 먼저 Eq에 포함되어 있어야 한다. compare 함수는 크기 비교가 가능한 두 값을 인자로 받으면 첫째 인자가 둘째 인자보다 큰지(GT), 작은지(LT), 아니면 같은지(EQ)를 검사하여 판단한 결과를 반환한다.

"Abrakadabra" < "Zebra"

True

5 >= 2

True

"Abrakadabra" `compare` "Zebra"

LT

compare 5 3

GT

compare (2, 3) (1+1, 5-2)

EQ

`Show` 유형클래스¶

Show 유형클래스에 속하는 유형의 값은 (터미널) 화면에 문자열로 표시할 수 있으며, 함수를 제외한 모든 유형은 Show에 포함된다. Show 유형클래스가 제공하는 인터페이스에 속하는 함수는 show이며, Show 에 속하는 유형의 값을 문자열로 변환시킨다.

show 3

"3"

show 5.334

"5.334"

show True

"True"

참고: show 함수를 구현한다는 것은 파이썬 클래스의 __str__() 또는 __repr()__ 메서드와 유사한 기능을 수행한다. 자바 클래스의 toString() 메서드의 기능도 크게 다르지 않다.

`Read` 유형클래스¶

Show에 대응되는 클래스이며, read 함수를 인터페이스로 제공한다. 지금까지 다뤄진 모든 유형은 Show 유형클래스에 속한다. read 함수는 문자열을 Read 클래스에 속하는 적절한 유형의 값으로 변환시켜야 한다.

read "True"는 부울 자료형의 True로 계산된다.

read "True" || False

True

read "8.2"는, 예를 들어, Float 유형의 8.2로 계산된다.
- Float, Double 등 여러 종류의 부동소수점 유형이 존재하기에 '예를 들어' 표현을 사용하였음에 주의하라.

read "8.2" + 3.8

12.0

read "5"는, 예를 들어, Int 유형의 5로 계산된다.
- Int, Integer 등 여러 종류의 정수 유형이 존재하기에 '예를 들어' 표현을 사용하였음에 주의하라.

read "5" - 2

3

read "[1,2,3,4]"는, 예를 들어, [Int] 유형의 [1,2,3,4]로 계산된다.

read "[1,2,3,4]" ++ [3]

[1,2,3,4,3]

주의!

read "True" 또는 read "5"를 실행하면 오류가 발생한다.

read "True"

Prelude.read: no parse

read "5"

Prelude.read: no parse

no parse 표현은 GHC가 문자열 "5"를 어느 유형의 값으로 파싱(문장분석, parsing)해야할지 명확하지 않다는 의미이다. 반면에, 예를 들어, read "5" - 2의 경우는 - 2가 함께 사용되기에 뺄셈을 지원하는 정수 또는 부동소수점 유형으로 판단하는 것이 가능했다.

물론 정확히 어떤 유형인지 하나를 정할 수는 없다. 하지만 뺄셈을 지정하는 유형은 모두 Num 이라는 유형클래스에 속한다. 따라서 아래의 결과를 얻게 된다.

:t (read "5" - 2)

즉, (read "5" - 2)는 다형 유형을 가지며, 해당 다형 유형의 의미는 다음과 같다.

Num 유형클래스와 Read 유형클래스 모두에 속하는 임의의 유형 a는 (read "5" - 2)를 값으로 갖는다.

read 함수 단독으로 반환값의 유형을 추론할 수 없는 이유는 유형으로도 확인할 수 있다.

:t read

즉, read 함수가 유형 변수 a 에 어떤 유형을 대입할지 read 함수 자체만으로는 알 수 없다. 하지만 유형을 일명 유형 주석(type annotations) 형태로 명시하면 유형 추론이 가능해진다.

유형 주석을 추가하는 방식은 아래와 같다.

read "5" :: Int

5

read "5" :: Float

5.0

(read "5" :: Float) * 4

20.0

read "[1,2,3,4]" :: [Int]

[1,2,3,4]

read "(3, 'a')" :: (Int, Char)

(3,'a')

참고: 표현식 유형은 대부분 하스켈 컴파일러 스스로 추론할 수 있다고 이전에 언급하였다. 하지만 Read "5" 와 같은 표현식의 경우처럼 유형을 결정할 수 없는 경우가 발생하며, 그런 경우에는 오류 발생을 대비해 유형 주석을 활용해야 한다.

`Enum` 유형클래스¶

Enum 유형클래스에 속하는 유형의 값들은 크기 순서대로 열거(enumeration)될 수 있어야 한다. 값을 열거할 수 있다의 의미는 하나의 값이 주어졌을 때 그 값의 이전값(predecessor)과 다음값(successor)을 지정할 수 있다는 의미이다.

다음값과 이전값은 각각 succ 함수와 pred 함수를 사용해 얻을 수 있다. 예를 들어, 양의 정수 1의 이전값은 0이고, 다음값은 2이며, 문자 c의 이전값은 b, 다음값은 d이다. 반면에 문자열 "cde"의 이전값과 다음값은 알 수 없다. 즉, 문자열 유형 String은 Enum 유형클래스에 포함되지 않는다. 실제로 임의의 유형 a에 대해, [a]는 Enum 유형클래스에 포함되지 않는다.

succ 1

2

pred 1

0

succ 'c'

'd'

pred 'c'

'b'

유형에 따라 특정 값은 이전값 또는 다음값이 존재하지 않는다. 예를 들어, Ordering 유형의 LT는 이전값이, GT는 이후 값을 갖지 않는다.

pred LT

Prelude.Enum.Ordering.pred: bad argument

pred EQ

LT

succ EQ

GT

succ GT

Prelude.Enum.Ordering.succ: bad argument

놀롭게도 Float와 Double 또한 Enum 유형클래스에 속한다. 사실 수학적으로 유리수는 열거될 수 없다. 예를 들어, 0.1 바로 다음의 유리수는 수학적으로 존재하지 않는다. 하지면 하스켈은 1을 빼거나 더한 값을 이전값과 다음값으로 사용한다.

succ 0.1

1.1

pred 0.1

-0.9

Enum 유형클래스의 가장 큰 활용성은 레인지(range)이다. 이전값과 다음값이 지정되어 있을 때 어디에서 어디까지 라는 표현이 의미하는 바를 레인지가 정확하게 반영한다.

['a'..'e']

"abcde"

[LT .. GT]

[LT,EQ,GT]

[3 .. 5]

[3,4,5]

succ 'B'

'C'

`Bounded` 유형클래스¶

유형의 값이 가질 수 있는 최솟값(minBound)과 최댓값(maxBound)이 존재하는 경우 그 유형은 Bounded 유형클래스에 속한다.

주의사항: 유형별 minBound와 maxBound를 확인할 때 원래 소괄호를 사용할 필요가 없지만, 주피터 노트북 셀에서 작성하는 경우 소괄호를 함께 사용하지 않으면 오류가 발생한다.

관련 이슈: IHaskell Issue #509 The type signature for ‘minBound’ lacks an accompanying binding 참고

자신의 컴퓨터에서 지원하는 최소의/최대의 Int유형 정수는 다음과 같다.

(minBound :: Int)

-9223372036854775808

(maxBound :: Int)

9223372036854775807

문자의 최솟값과 최댓값은 아래와 같다.

(minBound :: Char)

'\NUL'

(maxBound :: Char)

'\1114111'

진리값의 최솟값과 최댓값은 아래와 같다.

(maxBound :: Bool)

True

(minBound :: Bool)

False

Bounded에 속하는 유형으로만 이루어진 튜플 유형 또한 Bounded 유형클래스에 속한다.

(maxBound :: (Bool, Int, Char))

(True,9223372036854775807,'\1114111')

`Num` 유형클래스¶

수(number)로 취급될 수 있는 값들의 유형이 속하는 유형클래스이다. 우리가 일상적으로 사용하는 수는 Num 유형클래스에 속하는 다양한 유형의 값이다. 예를 들어, 20은 Num 유형클래스에 속하는 임의의 유형에 속한다.

:t 20

따라서 Num 유형클래스에 속하는 모든 유형의 값으로 취급될 수 있다. 예를 들어 다음과 같다.

20 :: Int

20

20 :: Integer

20

20 :: Float

20.0

20 :: Double

20.0

수의 연산과 관련된 함수는 기본적으로 Num 유형클래스에 속하는 유형만을 대상으로 한다. 예를 들어, *의 유형을 확인해보자.

:t (*)

즉, 곱셈 연산자(*)는 Num 유형클래스에 속하는 유형에 대해서만 작동하며, 사용되는 두 인자의 유형이 동일해야 한다.

예를 들어 아래 표현식의 계산은 오류를 발생시키는데, 이유는 두 값의 유형이 다르게 지정되었기 때문이다.

(5 :: Int) * (6 :: Integer)

<interactive>:1:15: error:
    • Couldn't match expected type ‘Int’ with actual type ‘Integer’
    • In the second argument of ‘(*)’, namely ‘(6 :: Integer)’
      In the expression: (5 :: Int) * (6 :: Integer)
      In an equation for ‘it’: it = (5 :: Int) * (6 :: Integer)

반면에 아래 표현식의 계산은 잘 작동한다. 이유는 5의 유형이 문맥상 Integer로 지정될 수 있기 때문이다.

5 * (6 :: Integer)

30

`Fractional` 유형클래스¶

나눗셈과 곱셈의 역원함수에 대해 닫혀 있는 유형의 클래스이다. Float와 Double이 여기에 속한다.

`Integral` 유형클래스¶

정수와 관련된 유형인 Int와 Integer가 여기에 포함된다. 보다 엄밀하게는 몫과 나머지 연산을 지원하는 유형들이어야 한다.

`Floating` 유형클래스¶

log, exp, sin, cos 등 정수 범위를 넘어서는 연산을 다룰 수 있는 유형들이 속한다. 대표적으로 Float, Double이 있다.

수치 함수의 유형¶

수와 관련된 유형클래스를 살펴보았으니 이제 수를 다루는 함수들을 좀 더 구체적으로 이해할 수 있다. 사실 수치 함수들은 꽤 복잡한 유형을 갖는다. 여기서는 설명을 위해 fromIntegral 함수를 이용한다.

먼저 유형을 확인해보자.

:t fromIntegral

먼저, 유형에 사용되는 클래스 제약이 두 개임이며, 소괄호 안에서 쉼표로 구분되어 있음에 주목해야 한다.

인자: Integral 유형클래스에 속하는 유형 a의 값
반환값: Num 유형클래스에 속하는 유형 b의 값

즉, fromIntegral 함수는 정수형 수를 임의의 유형의 수로 변환시켜주며, 아래 예제와 같은 경우에 유용하게 활용된다.

예제

리스트의 길이를 반환하는 length 함수의 유형은 다음과 같다.

:t length

이전에 elem 함수의 유형에서 언급한 대로 아래 두 사항을 적용해보자.

t a: [a]로 이해할 것.
Foldable t: 여기선 무시.

그러면 length의 유형은 아래와 같이 이해될 수 있다.

forall a. [a] -> Int

여기서 주목해야할 사항은 반환값의 유형이 Int 라는 것이다. 아마도 아래와 같이 하면 더 좋았을텐데 어떤 역사적인 이유에서 Int 로 정해졌다.

forall a. Num b => [a] -> b

이런 이유로 해서 아래와 같은 경우 문제가 발생한다.

length [1,2,3,4] + 3.2

<interactive>:1:20: error:
    • No instance for (Fractional Int) arising from the literal ‘3.2’
    • In the second argument of ‘(+)’, namely ‘3.2’
      In the expression: length [1, 2, 3, 4] + 3.2
      In an equation for ‘it’: it = length [1, 2, 3, ....] + 3.2

이유는 4 :: Int 와 부동소수점 3.2가 서로 유형이 다르기 때문이다. 이런 경우 fromIntegral 함수를 활용하면 문제를 해결할 수 있다.

fromIntegral (length [1,2,3,4]) + 3.2

7.2

이유는 fromIntegral 함수에 의해 4 :: Int가 임의의 Num 유형클래스에 속하는 유형으로 변환될 수 있기 때문이다.

3장 유형과 유형클래스¶

3.1 유형(Types)¶

유형 추론(type inference)¶

함수의 유형¶

하스켈의 기본 유형¶

Int 유형¶

Integer 유형¶

Float 유형¶

Double 유형¶

Bool 유형¶

Char 유형¶

유형 변수(Type variables)¶

다형 함수¶

3.2 유형클래스(Typeclasses)¶

하스켈의 기본 유형클래스¶

Eq 유형클래스¶

Ord 유형클래스¶

Show 유형클래스¶

Read 유형클래스¶

Enum 유형클래스¶

Bounded 유형클래스¶

Num 유형클래스¶

Fractional 유형클래스¶

Integral 유형클래스¶

Floating 유형클래스¶

수치 함수의 유형¶

`Int` 유형¶

`Integer` 유형¶

`Float` 유형¶

`Double` 유형¶

`Bool` 유형¶

`Char` 유형¶

`Eq` 유형클래스¶

`Ord` 유형클래스¶

`Show` 유형클래스¶

`Read` 유형클래스¶

`Enum` 유형클래스¶

`Bounded` 유형클래스¶

`Num` 유형클래스¶

`Fractional` 유형클래스¶

`Integral` 유형클래스¶

`Floating` 유형클래스¶