Purely functional Language

- Every Haskell funciton is pure

- Function will always yield the same output for the same argument

- No side effects

Haskell

Referential transparency

Haskell

# referentially opaque
g = 0
def f1( x ):
    global g
    g = g + 1
    return g + x


# referentially transparent
def f2( x ):
    return x + 1

Strong static type  & Type inference

Haskell

Type System Comparison

Strong / Weak Typing

if ( true ) { 
    //do something 
}

if ( 'a' ) { 
    //do something 
} 

if ( 42 ) { 
    //do something 
}

JavaScript

Lazy evaluation (non-strict)

A code is executed only if its value is needed

Haskell can evaluate only a specific part of a very large data structure without loading the whole data into memory.

- lower memory footprint

- infinite data structure

Haskell

Primitive Types

Int – bounded integer

Integer – unbounded integer

Float – real floating point with single precision

Double – real floating point with double precision

Bool – boolean type, True of False

Char – a character

Primitive Types

Integer – unbounded integer

factorial :: Integer -> Integer
factorial n = product [1..n]

λ> factorial 40
815915283247897734345611269596115894272000000000

Int– bounded integer

factorial :: Int -> Int
factorial n = product [1..n]

λ> factorial 40
-70609262346240000

Primitive Types

Float – real floating point with single precision

circumference :: Float -> Float
circumference r = 2 * pi * r

λ> circumference 5.0
31.415928

Double – real floating point with double precision

circumference :: Double -> Double
circumference r = 2 * pi * r

λ> circumference 5.0
31.41592653589793

Primitive Types

Bool – boolean type. True of False
 

λ> True && False  
False

λ> False || True  
True

λ> not False  
True

λ> True /= False
True

Boolean infix functions
 

Primitive Types

Char – a character is denoted by a single quotes.
String is a list of characters.

λ> :t ‘x’
‘x’ :: Char

λ> :t “hello”
“hello” :: [Char]

Lists

Lists are a homogeneous data structure which store elements of the same type. Lists are denoted by a square brackets and its value are separate by commas.

λ> let x = [1,2,3,4]
λ> x
[1,2,3,4]

Lists

Functions that operate on lists

λ> [1,2,3,4] !! 1
2

List indexing

List concatenation

λ> let x = [1,2,3]
λ> let y = [4,5,6]
λ> x ++ y
[1,2,3,4,5,6]

Cons operator (prepend)

λ> ‘A’ : “ Dog”
“A Dog”

Lists

Functions that operate on lists

λ> head [1,2,3,4]
1

head

tail

λ> tail [1,2,3,4]
[2,3,4]

length

λ> length [1,2,3,4]
4

null

λ> null []
True
λ> null [1,2,3,4]
False

Functions

Haskell function can be difined in two parts:
1. Optional function declaration
2. Function implementation

Functions

Guards

Guards are similar to if else statement in imperative language. A guard determine a function body using a Boolean expression. If the expression evaluates to True, then the corresponding function body is used.

Functions

absolute x
   | x < 0     = 0 – x
   | otherwise = x

Guards

The keyword otherwise can be use to catches everything. otherwise is simply defines as True.

Functions

collatzSum :: Integer -> Integer
collatzSum n
    | n < 0     = 0
    | n == 1    = 1
    | even n    = n + collatzSum (n `div` 2)
    | otherwise = n + collatzSum (3 * n + 1)

Java

public int collatzSum(int n) {
    if (n < 0) 
        return 0;
    else if (n == 1) 
        return 1;
    else if (n % 2 == 0) 
        return n + collatzSum(n / 2);
    else 
        return n + collatzSum(3 * n + 1);
}

Haskell

Functions

First-class Function

​Haskell function is a first-class function. The language supports passing function as arguments to other functions, returning function as a values, assigning to a variable or storing in a data structures.

Haskell functions process one parameter at a time, using currying to support multiple arguments.

Calling a function with an incomplete argument resulting in a partially applied function.

Functions

map :: (a -> b) -> [a] -> [b]
map f []    = []
map f (h:t) = f h : map f t

Lambdas and Higher order functions

λ> map (\x -> x + 1) [1,2,3]
[2,3,4]

Functions

public <T> T first(T x, T y) {
    return x;
}

Generic functions

first :: a -> a -> a
first x y = x

Java

Haskell

(Parametric polymorphism)