Lists in haskell

let a = [4,8,15]
print(a)

print([1,2,3,4] ++ [5,6,7,8])

print (['j', 'e', 'l', 'l', 'o'])
print ("jello")

• Nil and Cons
  

  [] is called nil and denotes an empty list : is called cons that is a constructor for a value and another list of the same type They are enums. One thing to note here is that the constructor cons is also a binary operator so it can be applied partially like other binary operators. This is true for any data operator that starts with :.

  print ([])
  print (1 : [])
  print (1: 2 : 3 : []) -- eval'd from right to left
  

• Concat (++)
  

  print ([1] ++ [2, 3])
  print (1 : [2, 3]) -- better time complexity wise
  

  The concat or ++ operator is linear in the size of the list on the left side.

• Indexing
  

  You can get the n'th element of the list by using the !! operator on the list. However, check for bounds else there's a runtime error.

  print("Its a me mario" !! 4)
  -- print([1] !! 3) -- error
  

• Other basic functions
  
  • head gives the first element of the list
  • tail removes the first element and returns a new list
  • last gives the last element of the list
  • init returns the list with everything except for the last element
  • length returns the length
  • null checks if the list is empty
  • reverse reverses a list
  • take takes the first k elements of the list and returns that as the new list. If it is larger than the list's length then the entire list is returned.
  • drop drops the first k elements of the list. If larger than the list's size, return an empty list.
  • maximum, minimum, sum and product do what you think they do.
  • elem takes a list and an element and returns if it was there or not. Usually written infix

  All of them fail on an empty list

  print(head [1, 2, 3, 4])
  print(tail [1, 2])
  print(last [1, 3])
  print(init [1, 3, 4])
  print(take 1 [6, 6, 6])
  print(if 4 `elem` [1, 2, 3] then "present" else "Lol")
  

• Ranges and infinite lists
  

  print([1..20])
  

  -- define a step here
  print([1, 3..20])
  

  However, be wary of using it on floating point numbers because of precision. Preferably don't use them at all.

  print([0.1, 0.3 .. 1])
  

  To make an infinite list, do not specify an upper limit. Haskell won't complain unless you try to evaluate all of it.

  print(take 10 [1, 3..])
  

  cycle repeats a list forever, so you can use it to repeat something in a loop

  print(take 10 (cycle [1, 2, 3]))
  

  repeat takes an element and repeats it to give an infinite list

  print(take 10 (repeat 1))
  

  replicate takes a number and an element and creates a finite list of that argument that many times

  print(replicate 3 'a')
  

• List Comprehensions in haskell
  

  Basically a method to build a list from another range/list/whatever

  print([x * 2| x <- [1..10]])
  

  Apart from this we can also specify a predicate to filter out values

  print([x | x<- [50..100], x `mod` 7 == 3])
  

  We can also use any expression in the final result that depends on the list value, such as

  print([if x < 10 then "Foo" else "bar" | x<- [1..20], odd x])
  

  We can also specify several predicates and the value has to satisfy all of them.

  We can also specify multiple lists and the comprehension will combine them in all manners.

  [x*y | x <- [2,3,5], y<- [5,7,8]]
  

Tuples in haskell

let x = (1, 3)
print(x)

defining functions

doubleMe x = x * 2

print(doubleMe 8.3, doubleMe 10)

:{
  doubleUs x y = doubleMe x + doubleMe y

  doubleMe x = x + x
:}
  print(doubleUs 10 11.1)

Function types

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

Pattern matching on multiple functions

:{
    myLength :: (Num b) => [a] -> b
    myLength [] = 0
    myLength (_:xs) = 1 + myLength xs

:}

    print(myLength [1])

:{
    capital "" = "Empty string, Whoops!"
    capital all@(x:xs) = "The first letter of " ++ all ++ " is " ++ [x]
:}

  print(capital "foo")

:{
  bmiTell bmi  
    | bmi <= 18.5 = "You're underweight, you emo, you!"  
    | bmi <= 25.0 = "You're supposedly normal. Pffft, I bet you're ugly!"  
    | bmi <= 30.0 = "You're fat! Lose some weight, fatty!"  
    | otherwise   = "You're a whale, congratulations!"  -- same as catch all

:}

  print(bmiTell 21)

:{
  bmiTell weight height  
    | bmi <= 18.5 = "You're underweight, you emo, you!"  
    | bmi <= 25.0 = "You're supposedly normal. Pffft, I bet you're ugly!"  
    | bmi <= 30.0 = "You're fat! Lose some weight, fatty!"  
    | otherwise   = "You're a whale, congratulations!"  
    where bmi = weight / height ^ 2  
:}

  print(bmiTell 70 1.8)

:{
  bmiTell weight height  
      | bmi <= skinny = "You're underweight, you emo, you!"  
      | bmi <= normal = "You're supposedly normal. Pffft, I bet you're ugly!"  
      | bmi <= fat    = "You're fat! Lose some weight, fatty!"  
      | otherwise     = "You're a whale, congratulations!"  
      where bmi = weight / height ^ 2  
            skinny = 18.5  
            normal = 25.0  
            fat = 30.0  
:}

  print(bmiTell 60 1.34)

Typeclasses

(==) :: (Eq a) => a -> a -> Bool