Haskell Language
목록 이해력

기본 목록 이해력

Haskell은 리스트 comprehension 을 가지고 있습니다. 그것은 수학과 파이썬과 자바 스크립트와 같은 명령형 언어에서의 유사한 구현에서의 set comprehensions와 매우 흡사합니다. 가장 기본적인 목록 작성 방법은 다음과 같습니다.

[ x | x <- someList ]

예를 들어

[ x | x <- [1..4] ]    -- [1,2,3,4]

함수는 x에도 직접 적용될 수 있습니다.

[ f x | x <- someList ]

이것은 다음과 같습니다.

map f someList

예:

[ x+1 | x <- [1..4]]    -- [2,3,4,5]

생성자 표현식의 패턴

그러나 생성자 표현식의 x 는 변수 일뿐만 아니라 임의의 패턴이 될 수 있습니다. 패턴이 일치하지 않는 경우 생성 된 요소는 건너 뛰고 목록의 처리는 다음 요소와 함께 계속되므로 필터처럼 작동합니다.

[x | Just x <- [Just 1, Nothing, Just 3]]     -- [1, 3]

패턴에 변수 x 가있는 생성자는 오른쪽에있는 모든 표현식을 포함하는 새 범위를 만듭니다. 여기서 x 는 생성 된 요소로 정의됩니다.

즉, 경비원은 다음과 같이 코딩 될 수 있습니다.

[ x | x <- [1..4], even x] ==
[ x | x <- [1..4], () <- [() | even x]] ==
[ x | x <- [1..4], () <- if even x then [()] else []]

근위 연대

list comprehension의 또 다른 특징은 필터 역할을하는 guard입니다. 가드는 부 울린 표현식으로 바의 오른쪽에 목록으로 표시됩니다.

그들의 가장 기본적인 사용은

[x    | p x]   ===   if p x then [x] else []

가드에서 사용되는 변수는 왼쪽에 표시하거나 범위에 있어야합니다. 그래서,

[ f x | x <- list, pred1 x y, pred2 x]     -- `y` must be defined in outer scope

이는

map f (filter pred2 (filter (\x -> pred1 x y) list))          -- or,

-- ($ list) (filter (`pred1` y) >>> filter pred2 >>> map f)     

-- list >>= (\x-> [x | pred1 x y]) >>= (\x-> [x | pred2 x]) >>= (\x -> [f x])

( >>= 연산자는 infixl 1 , 즉 왼쪽에 괄호로 묶음). 예 :

[ x       | x <- [1..4], even x]           -- [2,4]

[ x^2 + 1 | x <- [1..100], even x ]        -- map (\x -> x^2 + 1) (filter even [1..100])

중첩 된 생성기

목록 내포 는 여러 목록에서 요소를 가져올 수도 있습니다.이 경우 결과는 두 목록이 중첩 된 방식으로 처리 된 것처럼 두 요소의 가능한 모든 조합의 목록이됩니다. 예를 들어,

[ (a,b) | a <- [1,2,3], b <- ['a','b'] ]

-- [(1,'a'), (1,'b'), (2,'a'), (2,'b'), (3,'a'), (3,'b')]

평행 이해력

Parallel List Comprehensions 언어 확장을 사용하면,

[(x,y) | x <- xs | y <- ys]

~에 해당합니다.

zip xs ys

예:

[(x,y) | x <- [1,2,3] | y <- [10,20]] 

-- [(1,10),(2,20)]

로컬 바인딩

List comprehensions은 중간 값을 유지하기 위해 변수에 대한 로컬 바인딩을 도입 할 수 있습니다.

[(x,y) | x <- [1..4], let y=x*x+1, even y]    -- [(1,2),(3,10)]

트릭으로 같은 효과를 얻을 수 있습니다.

[(x,y) | x <- [1..4], y <- [x*x+1], even y]   -- [(1,2),(3,10)]

let 지능형리스트에 평소처럼, 재귀입니다. 그러나 생성자 바인딩은 섀도 잉 을 가능하게합니다.

[x | x <- [1..4], x <- [x*x+1], even x]       -- [2,10]

표기법 사용

모든 지능형리스트는 대응 코딩 할 수 의 목록 모나드 do 표기법을 .

[f x | x <- xs]                 f  <$> xs         do { x <- xs ; return (f x) }

[f x | f <- fs, x <- xs]        fs <*> xs         do { f <- fs ; x <- xs ; return (f x) }

[y   | x <- xs, y <- f x]       f  =<< xs         do { x <- xs ; y <- f x ; return y }

가드 사용하여 처리 할 수 있습니다 Control.Monad.guard :

[x   | x <- xs, even x]                           do { x <- xs ; guard (even x) ; return x }