Commands on GHCIghci: open interative terminal ❯ :r: recompile file ❯ :l File.hs: run the file, add module Module where (it able to run file without extension) ❯ :t Value: checks the data type

**Basic Concepts

Types →** Char: 'H' → [Char] or String: "Hello World!" ****→ Int: 1 → Bool: True/False → creating new data type: data Day = Monday | Sunday **new type is Day and it has value constructors (Monday or Sunday) → Record syntax: data Point = Point {x, y :: Double} → creating new type with only one field: newtype Data = Data Int **lazy evaluation

Data Structure → List: [1, 2, 3, 4] **same element type and dynamic length → Tuples: (1, "Hello", 2, 'j') **several element type and fixed-length

Operators → maths operations: + - * / → conditions operations: True False not && || → equal, not equal: == /= **→ sucessor: succ 8 → min max: min max [1, 2] → div (integral division): div 2 3 → mod (modular division): mod 2 3 → odd | even (check is number is odd | even): odd|even 2

**Conditional Statement if x > 100 then x else x*2

FunctionsnameFunction p1 p2 p3 = expression → call the function: nameFunction p1 p2 p3

Pattern Matching; → Inspect parts of a value constructor → h [] = 0 h (_:[]) = 1 ** _ ignore value h (_:x:[]) = 2 + x **x accepts any value

Typeclasses

Typeclasses Highlights → A typeclass is a sort of interface that defines some behavior → If a type is a part of a typeclass, that means that it supports and implements the behavior the typeclass describes → Eq: used for types that support equality testing, implement == and /= → Show: all types covered so far except for functions are a part of this class, it takes a value whose type is a member of Show and presents it to us as a string → Read: sort of the opposite typeclass of Show, it takes a string and returns a type which is a member of ReadNum: numeric typeclass, its members have the property of being able to act as numbers. It has the functions: *abs* (transform negative values on positives one); signum (indicate if the number is positive, negative or zero); fromInteger (convert the interger number to other type) → Fractional: it provides a way to use the division for your type. It has the function *fromRational* (convert a fraction in another type) → Real: it provides the function *toRational* (convert the type to a Fractional) → Integral: includes only integral (whole) numbers. In this typeclass are Int and Integer. It has the functions *quotRem* (return the quotient and the rest); *toInteger* (convert the type to an Integer) → Enum: members are sequentially ordered types — they can be enumerated. It has the functions: *succ* (get the successors values) and pred (get ht predecessors values). → Ord: for types that have an ordering with >, <, >= and ≤, it has the *compare* that returns GT, LT or EQ; also max and *min* → Bounded: members have an upper and a lower bound. it has the minBound and maxBound

Creating a new class: class SimNao a where simnao :: a -> Bool

Lists

List Highlights

→ to join lists: [1, 2] ++ [3, 4] (++) [1, 2] [3, 4] or "Hello" ++ " World!" to push a new element on the first position: 3 : 4 : 4 : [10, 9, 4] to get list length: length [1, 2, 3] → to get the first element: head "ABCD" or head [1, 2] to get last element: last "ABCD" or last [1, 2] → to get the list without first element: tail "ABCD" or tail [1, 2] ** head, last and tail are not refined to empty lists → to get all elements except the last one: init "ABCD" or init [1, 2] → to reverse a list: reverse "HASKELL" or reverse [1, 2, 3] to extract elements from the beginning: take n [2, 4, 5] to extract elements dropping n of the begin: drop n [1, 2] to get element on index: [1, 2, 3] !! 2 to check if a element exist inside a list: *4elem[3,4,5,6]* to check if a list is empty: null [1, 2] to sum list of numbers: sum [1, 2] to multiply the list of numbers: product [1, 2] to get the max or min of a list of numbers: maximum | minimum [1, 2] get the element and the rest*: x:xs*

Ranges → to produce a value range: *[1..20]* → to cycle into an infinite list: *take 12 (cycle "LOL ")* → to produce an infinite list of just one element: *take 10 (repeat 5)* → to replicate a number into a list: *replicate 3 10*

**List Comprehensions → to build lists using expressions that will be distributed in each element → [EXPRESSION(var) | var←LIST, FILTER_1, FILTER_2...FILTER_n]doubleList xs = [2*x | x←xs]list = [2*x+1 | x←[0 .. 10], x/=5]

Tuples

**Tuples Highlights


→ tuples are immutable, each element is fixed and each index is called a coordinate → get the first coordinate of a tuple: fst ('H', "HELLO") → get the second coordinate of a tuple: snd ('H', "HELLO") → produce a list of pairs: zip [1, 2] [3,4] //[(1, 3) (2, 4)]

Functions

Functions Highlights ** → doc the type on functions: biggerThan :: Int → Int → Bool biggerThan x y = x > y
→ infix function: *biggerThan x y = (>) x y

→* Lambda: anonymous functions, they can be executed as values and without an explicit context *\\p1 p2 → EXP(p1 p2)

→* High Order Function: it can be passed as parameters or return another function ev :: (Int -> Int) -> Int - map: takes a function and a list and applies that function to every element in the list, producing a new list map (+3) [1,5,3,1,6] - filter: takes a predicate and a list and then returns the list of elements that satisfy the predicate filter (>3) [1,5,3,2] - foldr: takes a binary function, a starting value (accumulator) and a list to fold up foldl (\\acc x -> x : acc) [] **foldl: it does the same, but starts by the left side

**→ Currying: it receives multiply arguments and returns a function's sequence evaluation sum x y z = x + y + z **if a parameter was not passed, it returns a function with it

Composition: it's a functions chain (funcA . funcB)

Function application ($): the expression on its right of $ is applied as the parameter to the function on its left sum $ map sqrt [1...5]

Guards (|): a way of testing whether some property of a value (or several of them) are true or false *age | age < underAge = "You're underaged" | otherwise = "You're an adult!" where underAge = 18*

Recursion: a way of defining functions in which the function is applied inside its own definition

Polymorphic Function: it cannot see or operate the type variables