Functional Programming (TDA 452/DIT 142)

• Find up-to-date information relevant for the course
• Visit the course homepage. Shortcut: bit.ly/tda452-home
  • Schedule
  • Lab assignments (first deadline is in week 1!)
  • Self-study exercises
  • Last-minute changes
  • Sign up for the google group!

Functional Programming 2017

Thomas Hallgren

(adapted slides from David Sands, Koen Lindström Claessen & John Hughes)

Why learn Functional Programming?

• It will make you think differently about programming.
  • Mainstream programming is all about state and how to transform state.
  • Functional programming is all about values and how to construct values using functions.
• It will make you a better programmer
  • whatever programming language you use in the future.

Why Haskell?

• It's a very high-level language
• It's expressive and concise
• It's good at handling complex data
• It's makes it easy to write modular and reusable code
• It's good for programmer productivity and software quality
• It provides the most "uncompromising" approach to functional programming.

How to run Haskell code

GHC (The Glasgow Haskell Compiler)

• The most mature and widely used implementation of Haskell.
• It's an advanced optimizing compiler.
• It also includes GHCi, an interpreter (REPL) for easy testing.
• Installing the Haskell Platform should be easy and gives you what you need.

A Haskell Demo

Start GHCi in a terminal window

ghci GHCi, version 8.0.2: http://www.haskell.org/ghc/ :? for help

Live Demo

• Source code: Intro.hs

Currency converter

• Write this in a Haskell file, e.g. Intro.hs.

• exchangeRate = 9.7365
  
  toEUR sek = sek / echangeRate
  
  toSEK eur = eur * exchangeRate

• Illustrates definitions of constants and functions.
• Haskell is a layout sensitive language.
  • The definitions should start in the same column.
  • It is possible to use braces and semicolons instead...

Testing it in GHCi

• :load Intro.hs [1 of 1] Compiling Main ( Intro.hs, interpreted ) Ok, modules loaded: Main. toEur 85 8.730036460740513 toSEK 9 87.6285 toSEK (toEUR 85) 85.0
• You can use :reload to reload the file(s) after changes.
• You can use :l and :r as abbreviations for :load and :reload.

Writing down properties

• prop_exchange s = toSEK (toEUR s) == s

• By convention, functions whose names start with prop_ are properties we expect to hold.
• Writing down properties
  • documents how functions should behave.
  • tells us what to test / what has been tested.
  • makes it easy to repeat tests after changes.

Automated random testing

• Import the testing library:

  • import Test.QuickCheck

  • Imports go before any other definitions in the file
• Reload and run a test:
  • :r [1 of 1] Compiling Main ( Intro.hs, interpreted ) Ok, modules loaded: Main. quickCheck prop_exchange *** Failed! Falsifiable (after 5 tests and 1078 shrinks): 5.0e-324

The problem

It's not the function that is wrong, it's the test!

• Floating point calculations are not exact, so you can not expect exact equality test to succeed.
• We need an approximate equality test!

Defining a new equality operator

• x ~== y = x-y < 1e-10

• Defining a new operator is just like defining a new function.
  • Operators have symbolic names, normal functions have alphanumeric names.
• Using it:

• prop_exchange s = toSEK (toEUR s) ~== s

Testing again

• :r [1 of 1] Compiling Main ( Intro.hs, interpreted ) Ok, modules loaded: Main. quickCheck prop_exchange +++ OK, passed 100 tests.
• But is everything OK now?

There is still a problem

• 4 ~== 3 False 3 ~== 4 True
• Fixing the new equality test:

• x ~== y = abs (x-y) < 1e-10

• After this, everything is OK!

Function definition by cases and recursion

Example: Absolute Value

Compute the absolute value of a number

• If x is positive, the result is x
• If x is negative, the result is -x

•  -- | Compute the absolute value of x
  absolute x | x >= 0 = 0
  absolute x | x <  0 = -x

Notation

• Equations with guards
• Repeated left hand sides can be abbreviated:

  • absolute x | x >= 0 = 0
    absolute x | x <  0 = -x

  • absolute x | x >= 0 = 0
               | x <  0 = -x

• Haskell also has if-then-else:

  • absolute x = if x < 0 then -x else x

Recursion

• First example of a recursive function
  • Compute xⁿ (without using built-in

    x^n

    )

  • power x 0         = 1
    power x n | n > 0 = x * power x (n-1)
    

• How the result is computed:

  • power 3 2

    
    =

    3 * power 3 (2-1)

    
    =

    3 * power 3 1

    
    =

    3 * (3 * power 3 (1-1))

    
    =

    3 * (3 * power 3 0)

    
    =

    3 * (3 * 1)

    
    =

    3 * 3

    
    =

    9

About Recursion

• Reduce a problem (e.g.

  power x n

  ) to a smaller problem of the same kind,
• so that we eventually reach a "smallest" base case.
• Solve the base case separately.
• Build up complete solutions from smaller solutions.
• You should have seen this before...

Example: Counting intersections

n non-parellel lines. How many intersections (at most)?

The solution

• intersect 0         = 0
  intersect n | n > 0 = intersect (n-1) + n - 1

• Always pick the base case as simple as possible!

Types in Haskell

• Haskell is a strongly typed language
  • Every value/expression/function has a type.
  • If there is a type mismatch somewhere in a program, it will be rejected by the compiler.
• Haskell supports automatic type inference
  • You can omit the types most of the time, Haskell will figure it out anyway.
  • It is considered good practice to always write down the types of functions anyway!
• In GHCi
  • Use :type to ask for the type of an expression.
  • Use :browse to see the type of everything in the current module.

Types in GHCi

• You can ask for the type of an function (or a bigger expression):
• :t toEUR toEUR :: Double -> Double
• You can see the types of everything in the current module:
• :browse exchangeRate :: Double toEUR :: Double -> Double toSEK :: Double -> Double prop_exchange :: Double -> Bool (~==) :: (Ord a, Fractional a) => a -> a -> Bool power :: (Ord t1, Num t1, Num t) => t -> t1 -> t

The type of the power function

• The type is more general than we intended, it allows any numeric type e.g.

  Double

  .
• What is

  power 2 1.5

  ?
• We'd better add a type signature to restrict the type:

• power :: Integer -> Integer -> Integer
  power n 0 = 1
  power n k | k>0 = n * power n (k-1)
  

Specifying type signatures is a good idea!

• It makes the code easier to understand.
  • Both for you and other people who read your code.
• It can make type errors easier to understand.
• Sometimes the automatically inferred type is not the one you want.

Some notes on Haskell Syntax

Designed to be light-weight and uncluttered

• Function definitions and function applications without parentheses and commas
  • Just space between functions and arguments
  • Function application has higher precedence than other operators

    • abs 3-5
      abs (3-5)
      

• Sequences of definitions without semicolons and braces { ... ; ... ; }
  • The syntax is layout sensitive
    • All definitions in a sequence have to start in the same column!
    • It is possible to use semicolons and braces instead.

      • a = 3; b = 4; c = 5

A brief history of Haskell

Before Haskell

• 1930s: Lambda Calculus (Alonzo Church)
• 1950s: Lisp (John McCarthy), FORTRAN (John Backus, and others)
• 1966: ISWIM (Peter Landin: The next 700 programming languages)
• 1970s: ML, Hope, SASL, ...
• 1977: FP (John Backus: Can programming be liberated from the von-Neumann Style?)
  • Turing award lecture
• 1980s: FPCA (a conference), Standard ML, Lazy ML, Miranda, ...
• 1990: Haskell 1.0
• 1990s: ICFP (a conference)

A brief history of Haskell

Haskell

• April 1990: Haskell 1.0 report
• August 1990: HBC 0.99 (Haskell compiler from Chalmers). 1 2
• 1991: Haskell 1.1 report
• 1992: Haskell 1.2, GHC 0.10
  1996: Haskell 1.3
  1997: Haskell 1.4
• Februari 1999: Haskell 98
• December 2002: Haskell 98 Language and Libraries, The Revised Report
• July 2010: Haskell 2010 (PDF)

A brief history of Haskell

After Haskell 2010

• 2010: Haskell 2010 Language Report (latest official definition)
• 2010: GHC 7.0.1 compiler
• 2012: GHC 7.6.1
• 2014: GHC 7.8.1
• 2016: GHC 8.0.1
• 2017: GHC 8.2.1
• 2020: Haskell 2020 report (?)

A brief history of Haskell

More info

For the curious

• A History of Haskell: Being Lazy With Class [PDF] (July 2007)
• Keynote: Why Functional Programming Matters - John Hughes, Mary Sheeran [video] (Code Mesh, London 2015)