Functional Programming with Haskell - Lists basics

하스켈에서 리스트는 같은 타입을 가진 연속된 값을 의미한다. 아래는 리스트는 만드는 간단한 방법으로, 각각의 타입에 주목해서 살펴보자.

 
*Main> [7,3,8]
[7,3,8]
it :: Num t => [t]
 
 
*Main> [1,3,10,4,9.7]
[1.0,3.0,10.0,4.0,9.7]
it :: Fractional t => [t]
 
 
*Main> ['x', 10]
 
<interactive>:79:7:
    No instance for (Num Char) arising from the literal ‘10’
    In the expression: 10
    In the expression: ['x', 10]
    In an equation for ‘it’: it = ['x', 10]
 

length 함수는 그 리스트에 포함된 원소의 갯수를 반환한다.

 
*Main> length [3,4,5]
3
it :: Int
 
*Main> length []
0
it :: Int
 
*Main> :t length
length :: Foldable t => t a -> Int

head 함수는 리스트의 첫 번째 요소를 반환한다.

 
*Main> head [3,4,5]
3
it :: Num a => a
 
*Main> :t head
head :: [a] -> a
 

tail 의 경우는 어떤가?

 
*Main> tail [3,4,5]
[4,5]
it :: Num a => [a]
 
*Main> :t tail
tail :: [a] -> [a]
*Main>
 

++ 연산자는 2개의 리스트를 결합하여 새로운 리스트를 만들어낸다.

 
*Main> [3,4]++[10,20,30]
[3,4,10,20,30]
it :: Num a => [a]
 
*Main> it ++ it
[3,4,10,20,30,3,4,10,20,30]
it :: Num a => [a]
 
*Main> let f = (++) [1,2,3]
f :: Num a => [a] -> [a]
 
*Main> f [4,5]
[1,2,3,4,5]
it :: Num a => [a]
 
*Main> f[4,5] ++ reverse (f[4,5])
[1,2,3,4,5,5,4,3,2,1]
it :: Num a => [a]
 
*Main> :t (++)
(++) :: [a] -> [a] -> [a]
 
*Main> :type reverse
reverse :: [a] -> [a]
 

값의 범위는 .. 을 이용하여 나타낸다.

 
*Main> [1..20]
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
it :: (Enum t, Num t) => [t]
 
*Main> [-5,-3..20]
[-5,-3,-1,1,3,5,7,9,11,13,15,17,19]
it :: (Enum t, Num t) => [t]
 
*Main> length [-1000..1000]
2001
it :: Int
 
*Main> [10..5]
[]
it :: (Enum t, Num t) => [t]
 

!! 연산자는 리스트의 N번째 원소를 반환한다(0에서 출발)

 
*Main> :type (!!)
(!!) :: [a] -> Int -> a
 
*Main> [10,20..100] !! 3
40
it :: (Enum a, Num a) => a
 

안타깝지만, 오른쪽부터 인덱싱하기 위해 음수를 사용할 수는 없다.

 
*Main> [10,20..100] !! (-2)
*** Exception: Prelude.!!: negative index