Functional programming with haskell

Functional Programming with Haskell
Ali Faradjpour

Agenda
● Functional Programming
● Haskell
● Haskell Types
● Haskell Functions
● Way to Monad

Imperative Vs. Declarative
int[] src = {1,2,3,4,5};
int result = 0;
for(int i = 0; i<src.length; i++){
int temp = src[i] * 2;
result += temp;
}
foldl (+) 0 . map (*2) $[1,2,3,4,5]
Vs.

Functional Programming
● central concept:
– result of a function is determined by its input, and
only by its input. There are no side-effects!
● This determinism removes a whole class of bugs found in
imperative programs:
– most bugs in large systems can be traced back to
side-effects - if not directly caused by them

Functional Programming
● Common pattern in functional programming:
– take a starting set of solutions and then you
apply transformations to those solutions and
filter them until you get the right ones.
● You need to think in terms of describing the overall
result that you want
● You do have to rethink your overall strategy for
solving the problem.

Haskell
● Haskell requires learning a new way to think,
not just new syntax for old concepts.
● This can be incredibly frustrating, as simple
tasks seem impossibly difficult.

Haskell
● Writing Haskell you want to learn to think in
terms of operations on aggregates:
– “do this to that collection.”
● Haskell doesn’t have any looping constructs
● Haskell data structures are immutable.

Haskell
● Pure Functional
● Lazy
● Strong typed
● Statically typed
● Immutable Data
● Higher-Order Functions

Strictness vs Non-Strictness
● A language is strict if it evaluates the arguments to a
function before it evaluates the function, A non-strict
language doesn’t.
Int taxTotal = getTotalTax();
Int baseFareTotal = getTotalBaseFare();
doSomeThing (taxTotal, baseFareTotal) ;
.
.
public void doSomeThing (….){
body Parameters' values
are available

Laziness vs Strictness
● evaluate as little as possible and delay evaluation as
long as possible
● Haskell is lazy, it is aggressively non-strict:
– it never evaluates anything before it absolutely
needs to.
● Lazy evaluation refers to implementation non-strictness
using thunks -- pointers to code which are replaced with a
value the first time they are executed.
lazyExmp param1 param2 = if someCondition then param1
else param2
lazyExmp func1 func2

Variables
● a variable is a name for some valid expression.
● given variable's value never varies during a
program's runtime

Haskell Variables
● A variable in Haskell is a name that is bound to
some value, rather than an abstraction of some
low-level concept of a memory cell.
Imperative Languages Haskell
a = 10 
.
.
a = 11 
Multiple declarations of ‘a’
Int height = 175;

Types
● Basic Types: Bool, Char, Int, Float, Integer,
String, Double
● type keyword: type synonyms
● :: shows type of expression
'a' :: Char
head :: [Int] -> Int
type Ratio = Double
type Point = (Int,Int)

Types
● Tuple is a sequence of values of different types
(False,True) :: (Bool,Bool)
(12,’a’,True) :: (Int,Char,Bool)

Types
● lists are a homogenous data structure
[1,2,3,4,5] “Haskell”
[(1,2),(3,4)] [[1,2],[5,6] ]
● Ranges [1..20] [2,4..20] [11,22..]
● list comprehension
[x*2 | x [1..10]] [2,4,6,8,10,12,14,16,18,20]
[x*2 | x [1..10], x*2 >= 12] [12,14,16,18,20]
[(x,y) | x [1..3], y [x..3]] 

Types
● Type Variables
func1 :: [Int] Int→
func2 :: [a] a (polymorphic function)→

Types
● Typeclass: a sort of interface that defines some
behavior.
● Eq, Ord, Show, Read, Enum, Bounded, Num,
Integral, Floating
func1 :: (Num a) => a → a → a
func1 x y = (x + y) / (x - y)
palindrome :: Eq a => [a] -> Bool
palindrome xs = reverse xs == xs

Types
● data keyword
data Answer = Yes | No | Unknown
data Shape = Circle Float Float Float
| Rectangle Float Float Float Float
Circle 10.0 20.0 5.0, Rectangle 10.0 20.0 10.0 20.0
data Point = Point Float Float deriving (Show)

Types
● data keyword
data Vector a = Vector a a a deriving (Show)
data Tree a = EmptyTree
| Node a (Tree a) (Tree a) deriving (Show, Read, Eq)
exp: numsTree = Node 3 (Node 1 EmptyTree EmptyTree)
(Node 4 EmptyTree EmptyTree)

Types Cont.
● data keyword
data Maybe a = Just a | Nothing
data Either a b = Right a | Left b

Types Cont.
● class keyword
class Eq a where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
x == y = not (x /= y)
x /= y = not (x == y)

Types Cont.
data TrafficLight = Red | Yellow | Green
instance Show TrafficLight where
show Red = "Red light"
show Yellow = "Yellow light"
show Green = "Green light"
data TrafficLight = Red | Yellow | Green
deriving (Show)

If & Case
if condition then expr1
Else expr2
if n ≥ 0 then n
else -n
case expression of pattern -> result
pattern -> result
pattern -> result
...
describeList xs = case xs of [] ->"empty."
[x] -> "a singleton list."
xs -> "a longer list."

Functions
● every expression and function must return
something
● Syntax: functions can't begin with uppercase
letters
functionName param1 ... paramN = expression
add :: a → a → a → a
add x y z = x + y + z
abs :: Int Int
abs n = if n 0 then n else -n≥

Functions Contd.
● Pattern Matching
factorial :: (Integral a) => a -> a
factorial 0 = 1
factorial n = n * factorial (n - 1)
sum' :: (Num a) => [a] -> a
sum' [] = 0
sum' (x:xs) = x + sum' xs

Lambas
● Anonymous functions that are used because we
need some functions only once.
map (x -> x + 3) [1,6,3,2]

Curried functions
● Every function in Haskell officially only takes
one parameter, All the functions that accepted
several parameters have been curried functions.
multTwoWithNine = multThree 9
multTwoWithNine 2 3
> 54
multThree :: (Num a) => (a -> (a -> (a -> a)))
multThree x y z = x * y * z

Polymorphic Functions
●
A function is called polymorphic (“of many
forms”) if its type contains one or more type
variables
length :: [a]  Int
> length [False,True]
2
> length [1,2,3,4]
4

Higher order function
● Functions that can have functions as input or output
applyTwise:: (a → b) → a → b
applyTwise f x = f (f x)
(.) :: (b c) (a b) (a c)    
f . g = x f (g x)
● example: (.) returns the composition of two functions
as a single function
map (negate . sum . tail) [[1..5],[3..6],[1..7]]

Higher order function Cont.
● map
● filter
● foldl or foldr
map :: (a b) [a] [b]  
Map (+1) [1,3,5,7] [2,4,6,8]
filter :: (a Bool) [a] [a]  
filter even [1..10] [2,4,6,8,10]
fold :: (b -> a -> b) -> b -> a -> b
foldl (acc x -> acc + x) 0 [1,2,3] 6

Way to Monads
Real Values` Fancy Values
526
“This is a Window”
True
A
Just 5
Left “Error Msg”
IO String

Way to Monads
● Functor typeclass is basically for things that
can be mapped over.
class Functor f where
fmap :: (a -> b) -> f a -> f b
instance Functor [] where
fmap = map
instance Functor Tree where
fmap f EmptyTree = EmptyTree
fmap f (Node x leftsub rightsub) =
Node (f x) (fmap f leftsub) (fmap f rightsub)

Way to Monads
● Applicative
● we can't map a function that's inside a functor
over another functor with what fmap offers us
class (Functor f) => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
fmap :: (a -> b) -> f a -> f b
(<*>) :: f (a -> b) -> f a -> f b
[(+2),(*3)] <*> [5,7] [7,9,15,21]

Monad
●
have a value with a context, How to apply it to a
function that takes a normal a and returns a value
with a context?
fancyInput = Just 5
compFancyValue a = if a > 2 then Just (2 * a)
else Nothing
(apply) :: m a -> (a -> m b) -> m b

Monad
●
func1 :: Int → Maybe Int
func1 x = if x 'mod' 2 == 0 then Nothing else Just (2 * x)
●
●
● We'd like to compose them to get function:
funcComp :: Int → Maybe Int
● Multiplies input number by 30 unless is a multiple of 2,3,5
(in which case return Nothing)

Monad
● Defining k:
funcComp x = case func1 x of
Nothing → Nothing
Just y → case func2 y of
Nothing → Nothing
Just z → func3 z

Monad
apply :: Maybe a -> (a -> Maybe b) -> Maybe b
apply Nothing f = Nothing
apply (Just x) f = f x
funcComp x = func1 x `apply` func2 `apply` func3

Monad
class Monad m where
return :: a -> m a
(>>=) :: m a -> (a -> m b) -> m b
(>>) :: m a -> m b -> m b
x >> y = x >>= _ -> y
fail :: String -> m a
fail msg = error msg
instance Monad Maybe where
return x = Just x
Nothing >>= f = Nothing
Just x >>= f = f x
fail _ = Nothing

Monad
● Defining k without using monadic composition:
funcComp x = case func1 x of
Nothing → Nothing
Just y → case func2 y of
Nothing → Nothing
Just z → func3 z
● Defining k using Monadic composition:
funcComp x = func1 x >>= func2 >>= func3

Monad
● compose a bunch of monadic functions in the
Maybe monad easily.
● why the Maybe monad is important:
– it drastically cuts down on the boilerplate code
we have to write to chain Maybe-producing
functions together.
f7 x = f1 x >>= f2 >>= f3 >>= f4 >>= f5 >>= f6

Monad
func1 = Just 3>>= (x -> return (x+2))>>= (y -> return (y+3))
Just 5 Just 8
func1 = Just 3 >>= (x ->
return (x+2))>>= (y ->
return (y+3))
func1 = do
x <- Just 3
y <- return (x + 2)
return (y + 3)

Monad
● A Monad is a way to structure computations in
terms of values and sequences of computations
using those values.
● Sepration of composition and computation

Monad
● Why Do Monads Matter?
– Failure
– Dependence
– Uncertainty
– Destruction
Maybe a values represent computations that might have failed,
[a] values represent computations that have several results
(non-deterministic computations),
IO a values represent values that have side-effects

Functional programming with haskell

Haskell IDEs
● Leksah: It is written in Haskell, uses Gtk, and
runs on Linux, Windows and Mac OS X.
● EclipseFP: The Haskell plug-in for Eclipse
● Haskell-idea-plugin: IntelliJ IDEA plugin for
Haskell, based on idea.
● Integrate any favourite text editor (Vim, emacs,
Atom, …) with compiler and maker

Web Programming
● Web frameworks:
– Snap, Scotty, Sckop, Yesod, Happstack,
Mflow, …
● GUI:
– gtk2hs, hsqml, Threepenny-gui, …
● Database:
– HaskellDB, HSQL, HDBC

Performance
● Generally C has better performance
● Important functions could be written in C (using the excellent
foreign function interface in Haskell)
● C is often faster than Haskell. But in the real world
development times do matter, this isn't the case.

● Learn You a Haskell For Great Good
● Real World Haskell
● https://en.wikibooks.org/wiki/Haskell/
● wiki.haskell.org

Functional programming with haskell

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Functional programming with haskell (20)

Recently uploaded (20)

Functional programming with haskell