Functions

> map (^2) [1..10]
[1,4,9,16,25,36,49,64,81,100]

> map (`div` 3) [1..20]
[0,0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6]

{- Map With Anonymous Functions -}
>  map (\x -> x*x - 10*x) [1..10]
[-9,-16,-21,-24,-25,-24,-21,-16,-9,0]


> map reverse ["hey", "there", "world"]
["yeh","ereht","dlrow"]

> reverse ["hey", "there", "world"]
["world","there","hey"]

>  let f x = 4*(-1)^(x+1)/(2*k - 1) where k = fromIntegral x
>  let piGuess n = sum $ map f [1..n]
>  
>  map piGuess [1, 10, 20, 30, 50, 100]
[4.0,3.0418396189294032,3.09162380666784,3.108268566698947,3.121594652591011,3.1315929035585537]
>
>  {- Approximation Error -}
>  
>  map (pi -) $ map piGuess [1, 10, 20, 30, 50, 100]
[-0.8584073464102069,9.975303466038987e-2,4.996884692195325e-2,3.332408689084598e-2,1.999800099878213e-2,9.99975003123943e-3]

> filter even [1..10]
[2,4,6,8,10]
> 
> filter (>6) [1..20]
[7,8,9,10,11,12,13,14,15,16,17,18,19,20]
>

> data Gender = Male | Female deriving(Show, Eq, Read)
> 
> let people = [(Male, "Tesla"), (Male, "Alber"), (Female, "Zoe"), (Male, "Tom"), (Female, "Olga"), (Female, "Mia"), (Male, "Abdulah")]

> filter (\(a, b) -> a==Female) people
[(Female,"Zoe"),(Female,"Olga"),(Female,"Mia")]
> 
> filter (\(a, b) -> a==Male) people
[(Male,"Tesla"),(Male,"Alber"),(Male,"Tom"),(Male,"Abdulah")]
>

> map even [1..5]
[False,True,False,True,False]

> all even (map (2*) [1..5])
True

> any odd [ x^2 | x<-[1..5] ]
True

-- Summation from 1 to 10
> foldr (+) 0 [1..10]
55

{- Product from 1 to 10 -}
> foldr (*) 1 [1..10]
3628800
> 

{- Maximum Number in a list -}

> foldr (\x y -> if x >= y then x else y ) 0 [ -10, 100, 1000, 20, 34.23, 10]
1000.0
>

{- Cumulative Sum -}
> scanl (+) 0 [1..5]
[0,1,3,6,10,15]

{- Cumulative Product -}

> scanl (*) 1 [1..5]
[1,1,2,6,24,120]

> let f x y = 10*x - y
>
> :t f
f :: Num a => a -> a -> a
> 
> 
> f 2 4

> map f [(1, 2), (4, 5), (9, 10)]

<interactive>:122:5:
    No instance for (Num (t0, t1)) arising from a use of `f'
    Possible fix: add an instance declaration for (Num (t0, t1))
    In the first argument of `map', namely `f'

> let f' = uncurry f
>
> :t f'
f' :: (Integer, Integer) -> Integer
>
> 
> map f' [(1, 2), (4, 5), (9, 10)]
[8,35,80]
> 
> map (uncurry f) [(1, 2), (4, 5), (9, 10)]
[8,35,80]
>

> let g (x, y) = 10*x - y
> 
> :t g
g :: Num a => (a, a) -> a
> 
> g (2, 4)
16
> 
> g 2 4
<interactive>:138:1:
    No instance for (Num (a0 -> t0)) arising from a use of `g'
    Possible fix: add an instance declaration for (Num (a0 -> t0))
    In the expression: g 2 4
    In an equation for `it': it = g 2 4
    ...
> 
> let g' = curry g
> :t g'
g' :: Integer -> Integer -> Integer
> 
> g' 2 4
16
> 
> (curry g) 2 4
16
>

> let uncurry3 f (a, b, c) = f a b c
> let uncurry4 f (a, b, c, d) = f a b c d
> 
> :t uncurry3
uncurry3 :: (t1 -> t2 -> t3 -> t) -> (t1, t2, t3) -> t
> 
> :t uncurry4
uncurry4 :: (t1 -> t2 -> t3 -> t4 -> t) -> (t1, t2, t3, t4) -> t
> 
> 
> let f a b c = 10*a -2*(a+c) + 5*c
> 
> 
> map (uncurry3 f) [(2, 3, 5), (4, 9, 2), (3, 7, 9)]
[31,38,51]
> 
> 

> 
> let f x y z w = 2*x + 4*y + 10*z + w
> 
> map (uncurry4 f) [(2, 3, 5, 3), (4, 9, 2, 8), (3, 7, 9, 1)]
[69,72,125]
>

[x, f x, f (f x), f (f (f x)), ...]

> let f a x = 0.5*(a/x + x)

> let g = f 2 -- a = 2

> g 2
1.5
> g 1.5
1.4166666666666665
> g 1.41666
1.4142156747561165
> g 1.14142156
1.4468112805021982

{- OR -}

> let gen = iterate g 2
>
> take 5 gen
[2.0,1.5,1.4166666666666665,1.4142156862745097,1.4142135623746899]

{-- 
Finally the root algorithm  using the power of lazy evaluation
with the iterate function

--}

> let f a x = 0.5*(a/x + x)
> let root a =  last $ take 10 $ iterate (f a) a 
> 
> root 2
1.414213562373095
> root 2 - sqrt 2
-2.220446049250313e-16
> 
> root 10
3.162277660168379
> sqrt 10
3.1622776601683795
>
> root 10 - sqrt 10
-4.440892098500626e-16
> 
>

> :t takeWhile
takeWhile :: (a -> Bool) -> [a] -> [a]
> 

{- Constant Function that always returns True-}
> :t const True
const True :: b -> Bool
> 
> takeWhile (const True)  [10, 20, 8, 4, 5, 7, 9] 
[10,20,8,4,5,7,9]
> 

> takeWhile (const False)  [10, 20, 8, 4, 5, 7, 9] 
[]
> 

> takeWhile (>5) [10, 20, 8, 4, 5, 7, 9] 
[10,20,8]
> 

> takeWhile (<10) [1, 2, 3, 9, 10, 20, 30]
[1,2,3,9]
> 

> takeWhile (/='a') "testing a function"
"testing "
>

> :t dropWhile
dropWhile :: (a -> Bool) -> [a] -> [a]
> 

> dropWhile (const True) [10, 20, 8, 4, 5, 7, 9] 
[]

> dropWhile (const False) [10, 20, 8, 4, 5, 7, 9] 
[10,20,8,4,5,7,9]

> dropWhile (>5) [10, 20, 8, 4, 5, 7, 9]
[4,5,7,9]

> dropWhile (/='a') "testing a function"
"a function"
>

zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]

unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])

> zip [1, 3, 4, 5, 6] [10, 30, 40, 50, 60]
[(1,10),(3,30),(4,40),(5,50),(6,60)]
> 

> zip [1, 3, 4, 5, 6] [10, 30, 40]
[(1,10),(3,30),(4,40)]
> 

> zip [5, 6] [10, 30, 40, 50, 60]
[(5,10),(6,30)]
> 

> zip [1, 2, 3, 4, 5] ['a', 'b', 'c', 'd', 'e']
[(1,'a'),(2,'b'),(3,'c'),(4,'d'),(5,'e')]
> 

> zip ["haskell", "ocaml", "sml", "scala", "erlang"] ['a', 'b', 'c', 'd', 'e']
[("haskell",'a'),("ocaml",'b'),("sml",'c'),("scala",'d'),("erlang",'e')]
> 

> zip3 [1, 2, 3, 4, 5] ['a', 'b', 'c', 'd', 'e'] ["haskell", "ocaml", "sml", "scala", "erlang"]
[(1,'a',"haskell"),(2,'b',"ocaml"),(3,'c',"sml"),(4,'d',"scala"),(5,'e',"erlang")]
> 

> zip3 [1, 2, 3, 4, 5] ['a', 'b', 'c', 'd', 'e'] ["haskell", "ocaml", "sml", "scala"]
[(1,'a',"haskell"),(2,'b',"ocaml"),(3,'c',"sml"),(4,'d',"scala")]
> 

> zip3 [4, 5] ['a', 'b', 'c', 'd', 'e'] ["haskell", "ocaml", "sml", "scala"]
[(4,'a',"haskell"),(5,'b',"ocaml")]
> 
> 

> import Data.List
> 
> zip4 [1..5] [5..15] ['a'..'z'] (replicate 4 Nothing)
[(1,5,'a',Nothing),(2,6,'b',Nothing),(3,7,'c',Nothing),(4,8,'d',Nothing)]
>

> unzip [(1,10),(3,30),(4,40),(5,50),(6,60)]
([1,3,4,5,6],[10,30,40,50,60])
> 

> unzip [(1,'a'),(2,'b'),(3,'c'),(4,'d'),(5,'e')]
([1,2,3,4,5],"abcde")
> 

> import Data.List

> unzip3 [(1,'a',"haskell"),(2,'b',"ocaml"),(3,'c',"sml"),(4,'d',"scala")]
([1,2,3,4],"abcd",["haskell","ocaml","sml","scala"])
> 

> unzip4 [(1,5,'a',Nothing),(2,6,'b',Nothing),(3,7,'c',Nothing),(4,8,'d',Nothing)]
([1,2,3,4],[5,6,7,8],"abcd",[Nothing,Nothing,Nothing,Nothing])
> 

> let (x, y) = unzip [(1,'a'),(2,'b'),(3,'c'),(4,'d'),(5,'e')]
> x
[1,2,3,4,5]
> y
"abcde"
> 

> let (a, b, c) = unzip3 [(1,'a',"haskell"),(2,'b',"ocaml"),(3,'c',"sml"),(4,'d',"scala")]
> a
[1,2,3,4]
> b
"abcd"
> c
["haskell","ocaml","sml","scala"]
>

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]

import Data.List
zipWith4   :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipWith5   :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
zipWith7   :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

{- 

ZipWith takes a function of two arguments and two lists 
returning a new one

    ->  (a -> b -> c)   : Function of two arguments returning type c
    ->  [a]            :  List of type a
    ->  [b]            :  List of type b

    Returns 
    ->  [c]            :  List of type c
-}
> :t zipWith
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
> 

> :t (+)
(+) :: Num a => a -> a -> a
> 


{- Add each element of two lists -}
> zipWith (+) [1, 2, 3, 4] [9, 10, 3, 5]
[10,12,6,9]
> 
> 

{- Multiply each element of two lists-}
> zipWith (*) [1, 2, 3, 4] [9, 10, 3, 5]
[9,20,9,20]
> 

{- Subtract each element of two lists -}
> zipWith (-) [1, 2, 3, 4] [9, 10, 3, 5]
[-8,-8,0,-1]
> 

{- zipWith with anonymous functions -}

> zipWith (\x y -> 10*x + 4*y) [10, 20, 30] [3, 4, 5]
[112,216,320]
> 
> let f = zipWith (\x y -> 10*x + 4*y)
> 
> f [10, 20, 30] [3, 4, 5]
[112,216,320]
> 


{- New functions can be created by curring arguments -}

> let addVectors = zipWith (+)
> let subVectors = zipWith (-)
> let mulVectors = zipWith (*)
> 
> :t addVectors 
addVectors :: [Integer] -> [Integer] -> [Integer]
> :t subVectors 
subVectors :: [Integer] -> [Integer] -> [Integer]
> :t mulVectors 
mulVectors :: [Integer] -> [Integer] -> [Integer]
> 

> addVectors [1, 2, 3, 4] [9, 10, 3, 5]
[10,12,6,9]
> 
> subVectors [1, 2, 3, 4] [9, 10, 3, 5]
[-8,-8,0,-1]
> mulVectors [1, 2, 3, 4] [9, 10, 3, 5]
[9,20,9,20]
> 

{- Using Functions as operators -}

> [1, 2, 3, 4]  `addVectors` [9, 10, 3, 5]
[10,12,6,9]
> 
> 
> [1, 2, 3, 4]  `subVectors` [9, 10, 3, 5]
[-8,-8,0,-1]
> 
> [1, 2, 3, 4]  `mulVectors` [9, 10, 3, 5]
[9,20,9,20]
> 

> let f x y z = x*y*z 

> zipWith3 f [1, 3, 4, 8] [4, 5, 9] [8, 7, 3]
[32,105,108]
> 
> let zf = zipWith3 f
> 
> zf [1, 3, 4, 8] [4, 5, 9] [8, 7, 3]
[32,105,108]
> 

> import Data.List
> 
> zipWith4 g [12, 34, 1, 4] [8, 19, 33, 23] [5, 7, 8, 9] [33, 78, 17, 14]
[337,2371,-1277,-929]
> 

> let g1 = zipWith4 g [12, 34, 1, 4] 
> g1 [8, 19, 33, 23] [5, 7, 8, 9] [33, 78, 17, 14]
[337,2371,-1277,-929]

> let g2 = g1 [8, 19, 33, 23]
> g2 [5, 7, 8, 9] [33, 78, 17, 14]
[337,2371,-1277,-929]

> let g3 = g2 [5, 7, 8, 9]
> g3  [33, 78, 17, 14]
[337,2371,-1277,-929]

> let g4 = g3 [33, 78, 17, 14]
> g4
[337,2371,-1277,-929]
>

> :t replicate 
replicate :: Int -> a -> [a]
> 

> replicate 4 'a'
"aaaa"
> replicate 6 2.345
[2.345,2.345,2.345,2.345,2.345,2.345]
> 

{- You can also replicate functions -}
> let f = replicate 3 (+1)
> :t f
f :: [Integer -> Integer]
> 
> map ($ 5) f
[6,6,6]
> 

> replicate 3 (Just 5)
[Just 5,Just 5,Just 5]
> 
> replicate 3 Nothing
[Nothing,Nothing,Nothing]
>

> zipWith (*) [1..10] [1..10]
[1,4,9,16,25,36,49,64,81,100]

> :t replicate
replicate :: Int -> a -> [a]

> zipWith replicate [1..6] ['a'..'z']
["a","bb","ccc","dddd","eeeee","ffffff"]

> takeWhile (<100) [ 2^n | n<-[1..] ]
[2,4,8,16,32,64]

> :t takeWhile
takeWhile :: (a -> Bool) -> [a] -> [a]

> ['a'..'z']
"abcdefghijklmnopqrstuvwxyz"

> ['A'..'Z']
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"

> ['0'..'9']
"0123456789"
> 

> ['0'..'z']
"0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz"

> "adding " ++ "three" ++ " strings"
"adding three strings"
> 

> "Hello world " ++ ['1']
"Hello world 1"
> 

> 'x' : "Hello World"
"xHello World"
> 
> 'y' : 'x' : "Hello World"
"yxHello World"
>

> let text = "Hello World\nHaskell\n Is very Cool"
> text
"Hello World\nHaskell\n Is very Cool"


> putStrLn text
Hello World
Haskell
 Is very Cool
> 
> 

> lines text
["Hello World","Haskell"," Is very Cool"]
>

> unlines ["Hello World","Haskell"," Is very Cool"]
"Hello World\nHaskell\n Is very Cool\n"
> 
> putStrLn $ unlines ["Hello World","Haskell"," Is very Cool"]
Hello World
Haskell
 Is very Cool

>

> words "Hello world haskell 123 2312 --- "
["Hello","world","haskell","123","2312","---"]
>

> unwords ["Hello","world","haskell","123","2312","---"]
"Hello world haskell 123 2312 ---"
>

> reverse "lleksaH dlroW olleH"
"Hello World Haskell"
>

import Data.Char

> ['0'..'z']
"0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz"
> 

> filter isDigit  ['0'..'z']
"0123456789"
> 

> filter isAlpha ['0'..'z']
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
> 

> filter isLower ['0'..'z']
"abcdefghijklmnopqrstuvwxyz"
> 
> filter isUpper ['0'..'z']
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
> 
> 

> filter isHexDigit ['0'..'z']
"0123456789ABCDEFabcdef"
> 

> filter isAlphaNum ['0'..'z']
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
> 

> map toUpper ['a'..'z']
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
>

> map toLower ['A'..'Z']
"abcdefghijklmnopqrstuvwxyz"
> 

{- Convert to ascii decimal number -}
> map ord ['a'..'f']
[97,98,99,100,101,102]
> 


{- Convert ascii to char -}
> map chr [97,98,99,100,101,102]
"abcdef"
>

> import Data.List.Split
> 

> splitOn "," "1232,2323.232,323.434"
["1232","2323.232","323.434"]
> 
> 

> map (\s -> read s :: Double) $ splitOn "," "1232,2323.232,323.434"
[1232.0,2323.232,323.434]
> 
> 

> endBy "," "1232,2323.232,323.434,"
["1232","2323.232","323.434"]
> 
> 

>  splitOneOf ";.," "foo,bar;baz.glurk"
["foo","bar","baz","glurk"]
> 

> chunksOf  3 ['a'..'z']
["abc","def","ghi","jkl","mno","pqr","stu","vwx","yz"]
> 
>