FP101x  week 4 List Comprehensions
Set Comprehensions

the comprehension notation can be used to construct new sets from old sets
 x < [1..5] : generator
 Comprehensions can have multiple generators , separated bu commas
 ex)
> [(x,y)  x < [1,2,3] , y < [4,5]]
[(1,4),(1,5),(2,4),(2,5),(3,4),(3,5)]
 changing the order of the generators changes the order of the elements in the final list
> [(x,y)  y < [4,5], x < [1,2,3] ]
[(1,4),(2,4),(3,4),(1,5),(2,5),(3,5)]
dependant Generators
 Later generators can depend on the variables ex)
> [(x,y)  x < [1..3], y <[x..3]]
[(1,1),(1,2),(1,3),(2,2),(2,3),(3,3)]
 concatenates a list of lists
concat :: [[a]] > [a]
concat xss = [xxs < xss, x < xs]
> concat [[1,2,3], [4,5], [6]]
[1,2,3,4,5,6]
Guards
 List comprehensions can use guards to restrict the values
> [ x  x < [1..10], even x]
[2,4,6,8,10]
 factors
 maps a positive integer to its list of factors:
 인자, 인수
factors :: Int > [Int]
factors n = [ x  x < [1..n], n ‘mod’ x == 0]
> factor 15
[1,3,5,15]
 prime
 A positive integer is prime if its only factors are 1 and itself.
 Hence, using factors we can define a function that decides it a number is prime
 소수
prime :: Int > Bool
prime n = factors == [1,n]
> prime 15
false
> prime 7
truer
 primes
 the list of all primes up to a given limit
primes :: Int > [Int]
primes n = [x  x < [2..n], prime x]
> primes 40
[2,3,5,7,11,13,17,19,23,29,31,37]
the Zip Function
 maps two lists to a list of pairs of their corresponding elements
zip :: [a] > [b] > [(a,b)]
> zip [‘a’,’b’,’c’] [1,2,3,4]
[(‘a’,1),(‘b’,2),(‘c’,3)]
 pairs
 Using zip we can define a function returns the list of all pairs of adjacent elements from a list
pairs :: [a] > [(a,a)]
pairs xs = zip xs (tail xs)
> pairs [1,2,3,4]
[(1,2),(2,3),(3,4)]
 sorted
 Using pairs we can define a function that decides if the elements in a list are sorted
sorted :: Ord a => [a] > Bool
sorted xs = and [ x <= y  (x,y) < pairs xs ]
> sorted [1,2,3,4]
True
> sorted [1,3,2,4]
False
 positions
 Using zip, functions that returns the list of all positions of a value in a list
positions :: Ez a => a > [a] > [Int]
positions x xs =
[ i  (x’ ,i) < zip xs [0..n], x == x’]
where n = length xs  1
> positions 0 [1,0,0,1,0,1,1,0]
[1,2,4,7]
String Comprehensions
 A string is a sequence of characters enclosed in double quotes
 Strings are represented as lists of characters
 “abc” :: String
 means [‘a’,’b’,’c’] :: [Char]
> length “abcde"
5
>take 3 “abcde"
“abc"
> zip “abc” [1,2,3,4]
[(‘a’,1),(‘b’,2),(‘c’,3)]
 lowers
 function that counts the lowercase letters in a string
lowers :: String > Int
lowers xs = length [x  x < xs, isLower x]
> lowers “Haskell"
6