Haskell

A primer

@xpktro - Functional Programming Perú

Original Version:

Por qué deberías aprender programación funcional ya mismo. - Andrés Marzal

Background: Constraint Based Design

    Mario Lavista
    La vida (a) leve
            Para Ulalume
    Y
    se
    oía
    Berg
    Dufai
    Mozart
    Debussy
    Schumann
    Beethoven
    Stravinski
    Lutoslavski:
    orquestarías
    estudiándolos
    brillantísimas
    extraordinarias
    transformaciones
    entremezclándoles
    pluridimensionales
    pseudododecafónicas
    sobreornamentaciones
    hipermeldessonhnianas.

OuLiPo ('60)

Literature based on very aggressive constraints

Palindromes
Absence of letters
Fixed or varying size of words
Specific order of rhymes
Timespan restrictions (e.g. the time you take when using the bus)

Proposal: OuProgPo

No loops (for, while, do, ...)
All functions must be declared with only one argument
Each function must consist of only one expression
No side-effects (don't change anything outside an expression)
All functions must produce the same result when given the same parameter
Once an identifier is given a value, it can't be changed
Data structure operations doesn't alter the original data structure
Execution order of expressions doesn't matter

Introducing Functional Programming

No loops (for, while, do, ...)
All functions must be declared with only one argument
Each function must consist of only one expression
No side-effects (don't change anything outside an expression)
All functions must produce the same result when given the same parameter
Once an identifier is given a value, it can't be changed
Data structure operations doesn't alter the original data structure
Execution order of expressions doesn't matter

Sales Pitch

More and more functional programming features are being included in common programming languages.

Lambda functions
List comprehension
Higher order functions
Lazy evaluation
Pattern matching
Immutability
Map/Filter/Reduce

2 years of real world FP at REA, by Ken Scambler

How to sell excellence, by Michael O. Church.

Mathematic Foundation

Functional programming is based on two mathematical principles:

Lambda Calculus

Category Theory

$$ \lambda x.x^{2} $$

$$ (\lambda x.x^{2}) \; 2 = 4 $$

Lambda Calculus

A formal system for representing and operating functions

$$ \lambda x.x^{2} $$

$$ (\lambda x.x^{2}) \; 2 = 4 $$

$$ \lambda (x, y).x^{2}+y^{2} $$

$$ \lambda x. \lambda y.x^{2}+y^{2} $$

$$ \lambda x.(\lambda y.x^{2}+y^{2}) $$

$$ (\lambda x.(\lambda y.x^{2}+y^{2})) \; 4 = \lambda y.16 + y^{2} $$

$$ (\lambda y.16+y^{2}) \; 3 = 25 $$

$$ (\lambda x.\lambda y.x^{2}+y^{2}) \; 4 \; 5= 25 $$

Pure functional features in Haskell

Haskell is the most usable language that includes pure functional features:

Referential transparency
No side effects, syntax support for monads
Lazy evaluation
Currying, first class functions
Static type system and type inference
Tail call optimization
Algebraic data types
Pattern matching
Immutable data structures

Practical Approach: FizzBuzz

A classic programming exercise: write a program which prints the numbers from 1 to 100. When a multiple of 3 is reached, print "fizz!" instead, and for multiples of 5 print "buzz!"; for multiples of 5 and 3 print "fizzbuzz!".

one!
two!
fizz!
four!
buzz!
fizz!
seven!
eight!
fizz!
buzz!
eleven!
fizz!
thirteen!
fourteen!
fizzbuzz!
sixteen!
seventeen!
fizz!
nineteen!
buzz!
fizz!
twenty two!

Practical Approach: FizzBuzz

fizzbuzz :: Int -> String
fizzbuzz n = undefined

"undefined" is a value that derives from every type

fizzbuzz :: Int -> String
fizzbuzz n = "one!"

main = print (fizzbuzz 1)

"main" is a special function that is called when your program is executed (the entry point)

Practical Approach: FizzBuzz

fizzbuzz n = if n == 1 then "one!" else "two!"

main = print (fizzbuzz 2)

"if" is an expression, it must return a value. We can also define our own if function:

ifThenElse :: Bool -> a -> a -> a
ifThenElse cond thenVal elseVal =
  case cond of
    True -> thenVal
    False -> elseVal

fizzbuzz n = ifThenElse (n==1) ("one"++"!") ("two"++"!")

Practical Approach: FizzBuzz

fizzbuzz :: Int -> String
fizzbuzz n | n == 1 = "one!"
fizzbuzz n | n /= 1 = "two!"

Refactoring time! introducing guards:

Being that the second condition will always succeed for n != 1, we can write it like this:

fizzbuzz n | n == 1 = "one!"
           | True = "two!"

-- Or: 

fizzbuzz n | n == 1 = "one!"
           | otherwise = "two!"

Practical Approach: FizzBuzz

fizzbuzz :: Int -> String
fizzbuzz 1 = "one!"
fizzbuzz n = "two!"

When guards are of the form "n == something", they can be written in a cleaner way:

And if a parameter is not important in a guard, we can replace it with _

fizzbuzz :: Int -> String
fizzbuzz 1 = "one!"
fizzbuzz _ = "two!"

Practical Approach: FizzBuzz

lessThan20 :: Int -> String
lessThan20 n
  | n > 0 && n < 20 =
    let answers = words ("one two three four five six seven eight nine ten " ++
                         "eleven twelve thirteen fourteen fifteen sixteen " ++
                         "seventeen eighteen nineteen")
    in answers !! (n-1)

In english, numbers that are less than 20 have proper names, let's make a function for representing those:

words :: String -> [String]

Practical Approach: FizzBuzz

tens :: Int -> String
tens n
  | n >= 2 && n <= 9 =
    answers !! (n-2)
  where
    answers = words "twenty thirty forty fifty sixty seventy eighty ninety"

We also need a function for getting names for tens:

"let in" and "where" are interchangeable and used depending on code legibility

Practical Approach: FizzBuzz

number :: Int -> String
number n
  | 1 <= n && n < 20           = lessThan20 n
  | n `mod` 10 == 0 && n < 100 = tens (n `div` 10)
  | n < 100                    = tens (n `div` 10) ++ " " ++ lessThan20 (n `mod` 10)
  | n == 100                   = "one hundred"

Combining our two functions into one:

Guards become an instant useful and elegant construct for grouping a complex set of conditions

Practical Approach: FizzBuzz

main = putStr (unlines (map number [1..30]))

Checking what we have so far by printing it:

unlines :: [String] -> String

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

-- For example:
map (\x -> x * 2) [1,2,3]
-- [2,4,6]

"unlines" joins a string using the newline character

"map" takes a function and applies it to every element of a list

Practical Approach: FizzBuzz

fizzbuzz :: Int -> String
fizzbuzz n
  | n `mod` 3 == 0 && n `mod` 5 == 0 = "fizzbuzz!"
  | n `mod` 3 == 0                   = "fizz!"
  | n `mod` 5 == 0                   = "buzz!"
  | otherwise                        = number n ++ "!"

main = putStr (unlines (map fizzbuzz [1..100]))

Final refactor, showing fizz! and buzz! and fizzbuzz!

one!
two!
fizz!
four!
buzz!
fizz!
seven!
eight!
fizz!
buzz!
eleven!
fizz!
thirteen!
fourteen!
fizzbuzz!
sixteen!
seventeen!
fizz!
nineteen!
buzz!
fizz!
twenty two!
twenty three!
fizz!
buzz!
twenty six!
fizz!
twenty eight!
twenty nine!
fizzbuzz!
thirty one!
thirty two!
fizz!
thirty four!
buzz!
fizz!
thirty seven!
thirty eight!
fizz!
buzz!
forty one!
fizz!
forty three!
forty four!
fizzbuzz!
forty six!
forty seven!
fizz!
forty nine!
buzz!
fizz!
fifty two!
fifty three!
fizz!
buzz!
fifty six!
fizz!
fifty eight!
fifty nine!
fizzbuzz!
sixty one!
sixty two!
fizz!
sixty four!
buzz!
fizz!
sixty seven!
sixty eight!
fizz!
buzz!
seventy one!
fizz!
seventy three!
seventy four!
fizzbuzz!
seventy six!
seventy seven!
fizz!
seventy nine!
buzz!
fizz!
eighty two!
eighty three!
fizz!
buzz!
eighty six!
fizz!
eighty eight!
eighty nine!
fizzbuzz!
ninety one!
ninety two!
fizz!
ninety four!
buzz!
fizz!
ninety seven!
ninety eight!
fizz!
buzz!