Basic of Haskell 101. Chapter 2.

1. Function Definition:

Functions are defined using equations: 

double x  = x + x

2. Function Application:

means apply function f to arguments x & y

f x y 

3. List Basics

numbers = [1, 2, 3]

4. The cons operator (:)

adds an element to the front of a list:

1. Expects
2. a single element on the left
3. & a list on the right
4. 
   

newList = 0 : numbers // [0, 1, 2, 3]

5. Pattern Matching:

Uses pattern matching for function definitions:

head (x:xs) = x
tail (x:xs) = xs

6. Guards:

Guards are ways to define functions based on conditions. They allow you to test properties of the function's arguments and choose the appropriate function body based on those tests.

abs n
  | n >= 0    = n
  | otherwise = -n

How this works?

1. function is named abs which takes 1 argument n
2. The symbol | introduces guard.
3. After each |, there's a boolean expression like n >= 0
4. If the boolean is true, corresponding expression after the = is used
5. Guards are evaluated from top to bottom.
6. The first True guard is chosen.
7. Typically last guard is used to catch all remaining cases.

classify :: Int -> String
classify n
 | n < 0   = "Negative"
 | n == 0  = "Zero"
 | n < 10  = "Small positive"
 | n < 100  = "Medium positive"
 | otherwise = "Large positive"

7. Where & Let

These are used for local definitions. These allows us to create intermediate values or helper functions that are only used within a specific function.

f x y = result
  where result = x * y + 150

f 5 10  -- returns 150

These where definitions are visible throughout the entire function body, even before they're defined.

the let...in expression in Haskell is a way to define local variables or functions that are only used in specific part of the code.

let <definitions> in <expression>
let x = 5
    y = 10
in x + y

1. wherever there is let, follow ins
2. The let introduces local bindings, and the in specifies where these bindings are used.

8. Higher Order Functions:

Functions that takes other functions as arguments.

map double [1, 2, 3]  -- results in [2, 4, 6]

foldr:

1. Fundamental higher-order function used list recursion.
2. Powerful tool for processing list from right to left.
3. type signature

foldr :: (a -> b -> b) -> b -> [a] -> b

• (a -> b ->b), a function that takes an element of the list type a & the accumulated result type b, returns a new result type b.
• b: initial value for the accumulator.
• [a]: the input list
• b: the final result

foldr works by applying the given function to each elements of the list, starting from the right to left.

The accumulator is a value that's carried along as foldr process the list. It stores intermediate result of the computation.

foldr f z [a, b, c]

f a (f b (f c z))

1. z is the intial accumulator value
2. f is applied to c(the rightmost element) & z
3. the result becomes the new accumulator
4. f is applied to b, & new accumulator
5. this process continues until all element are processed.

sumList = foldr (+) 0 [1, 2, 3, 4]
1 + (2 + (3 + (4 + 0)))

9. Lambda functions:

Anonymous functions, that are defined without being bound to an identifier. Called lamba functions because of their origins in lambda calculus.

• \ symbol is used to start lambda function, which means to resemble the greek letter λ (lambda).

(\x -> x + 1) 5 -- results in 6

• x is parameter to the function.
• -> separates the parameters from the function body.
• x + 1 , is the body of the function
• The entire (\x -> x + 1) is a function that takes a number & return that number + 1
• 5 at the end is also the argument being passed to this lambda function.
• so this function is equivalent to :
• f (x) = x + 1, then calling f(5)

More examples of lambda fucntions:

(\x y -> x *y) 3 4 -- result is 12

using lambda in higher order functions

map (\x -> x *2) [1, 2, 3]  -- result is [2, 4, 6]
filter(\x -> x > 5) [1..10].  --  [6, 7, 8, 9, 10] 

Lambda function that uses pattern matching:

(\(x,y) -> x + y) (3, 4) -- result is 7

10. Type Declarations:

You can explicitly declare types

double :: Int -> Int
double x = x + x 

11. List Comprehension:

[x*2 | x <- [1..5]] -- results in [2,4,6,8,10]

1. The part before the pipe | is the output of the function: x * 2
2. This defines what will be included in the resulting list
3. After | , we have x <- [1..5]
4. [1..5] is shorthand for the list [1, 2, 3, 4, 5]
5. x <-[1..5], means x is drawn from the list [1,2,3,4,5]
6. So the comprehension takes each number from 1 to 5, doubles it and puts the results in a new list

Some more examples of list comprehension:

• Filtering elements:

[x | x <-[1..10], x 'mod' 2 == 0] -- [2, 4, 6, 8, 10]

• Multiple generators:

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

12. Currying

All function in Haskell are curried by default.

add x y = x + y
add5 = add 5  
-- add5 is now a function that adds 5 to its argument

13. keywords

1. Maybe: Explicitly represents the possibility of having no result.
2. Forces a programmer to handle both the case where
3. a value is present
4. a value is absent
5. Clearly communicates in the type signature that a function might not always produce a value.
6. No null pointer exceptions, Haskell does not have null & Maybe is the idiomatic way to represent optional values.

how to use Maybe?

For example of finding 2nd element in the list.

1. We might have a value i.e 2nd index
2. or we might not so:

safesecondElement :: [a] -> Maybe a
safesecondElement (_:x:_) = Just x
safeSecondElement _ = Nothing

1. Just is one of Maybe constructor.
2. To return a successful result you need just to wrap the value.
3. The line safeSecondElement _ = Nothing is a catch-all pattern
4. which handles all cases not covered by the first pattern
5. Haskell requires it's function definition cover all possible input cases
6. without this catch-all pattern, the function would be incomplete
7. This line handles two important cases:
8. Empty list: [ ]
9. List with only one element [x]
10. We are saying there is no second element rather than causing an error

--a function to return second element in the list
safesecondElement (_:x:_) = Just x
safeSecondElement _ = Nothing

14. List Indexing Operator:

!!, is used for list indexing.

1. Allows us to retrieve an element from a list at a specific position.
2. list !! index
3. purpose is to return the element at the specified index in the list.
4. Indexing

let myList = [10, 20, 30, 40, 50]
myList !! 0 -- Returns 10 (first element) 
myList !! 2 -- Returns 30 (third element)
myList !! 4 -- Returns 50 (fifth element)

#haskell #basicSyntax #programmingLanguage #functionalProgramming