{{ message }}

Instantly share code, notes, and snippets.

Last active Jun 17, 2018

Functions

Is a mapping that takes one or more arguments and produces a single result.

• Is defined using an equation with a name for the function

• Each argument has a name

• The body specifies how would be calculated in terms of the arguments

Ex.

double x = x + x

• The result is obtained by sustituiting these args into the body, in place of the arguments names

• The result will be an expression containing other function application

• which must then be processed in the same way

double 3
= { applying double }
3 + 3
= { applying + }
6
double (double 2)
= { applying the inner double }
double ( 2 + 2 )
= { applying + }
double 4
= { applying double }
4 + 4
= { applying + }
8

Functional programming

• Style of programming

• The basic method of computation is the application of functions to arguments

Functional programming language

Is one that supports and encourages the functional style

Imperative style(for demo purposes)

count := 0
total := 0
repeat
count := count + 1
total := total + count
until
count = n

sum[1..n], where [..] is a function, sum is a function

sum[1..5]
= { applying [..] }
sum[1,2,3,4,5]
= { applying sum }
1+2+3+4+5
= 15

Notes: - Most imperatives languages support some form of functions, for that reason, the last implementation could be translated. - However, most of those languages don’t encourage the functional style.

• Concise programs

• Powerful type system

• List comprenhension

• Recursive functions

• Higher-order functions(DSL)

• Lazy evaluation

Historical background

• 1930 Alonzo Church developed the lambda calculus(theory of functions).

• 1950 John McCarthy developed LISP(LISt Processor)

• 1960 Peter Landin developed ISWIM(If you See What I Mean), the first purely functional language

• 1970 John Backus developed FP(Functional Programming)

• 1970 Robin Milner developed ML(Meta-Language), polymorphic types and type inference

• 1970-1980 David Turner developed Miranda, lazy FPL

• 1987 an intnl committee starts the development of Haskell, a standard lazy functional programming language

• 2003, such committee published th Haskell Report, which defines a stable version, 50 years of work culminated

sum[] = 0
sum(x:xs) = x + sum xs
sum[1,2,3]
= { applying sum }
1 + sum[2,3]
= { applying sum }
1 + (2 + sum)
= { applying sum }
1 + (2 + (3 + sum[]))
= { applying sum }
1 + 2 + 3 + 0
= { applying + }
6

Note: In Haskell, every function has a type that specifies the nature of its arguments and results, which is inferred from the definition.

Num a ⇒ [a] → a

Ex.:

qsort [] = []
qsort(x:xs) = qsort smaller ++ [x] ++ qsort larger
where
smaller = [ a | a <- xs, a <= x]
larger = [ b | b <- xs, b > x]

qsort :: Ord a => [a] -> [a]

First steps

2+3
2-3
2*3
7 / 2
7 `div` 2
2^3

Lists

tail[1,2,3,4]
[1,2,3,4,5,6]!!2
take 3 [1,2,3,4,5,6,7]
drop 3 [1,2,3,4,5,6,7]
length [1,2,3,4,5,6,7]
sum[1,2,3,4,5,6,7]
product[1,2,3,4,5,6,7]
[1,2,3] ++ [4,5]
reverse [1,2,3,4,5,6,7]

1 `div` 0

## Function application

Math: ƒ(a,b) + c d

Haskell: f a b + c * d

In math the multiplication is denoted silently by writing two values next to one another. Function application in Haskell is denoted silently using spacing, and has higher order priority.

f(x) => f x
f(x,y) => f x y
f(g(x)) => f(g x)
f(x,g(y)) => f x (g y)
f(x)g(y) => f x * g y

double x = x + x
factorial n = product[1..n]
average ns = sum ns `div` length ns

:edit name
:edit
:type
:?

Naming

myFun fun1 arg_2 x'

The names of th function and its arguments must begin with a lower-case, but can then be follewd by zero or moere letters(uppercase included), digits, underscores and single quotes.

Keywords

case class data default deriving do else if import in infix infixl infixr instance let module newtype of then type where

Note: By convention, list arguments have the suffix 's' on their name to indicate multiple values.

Layout Rule

In a script, each fefinition must begin in precisely the same column. This layout rule makes it posiible to determine the grouping of definitions from their indentation.

Implicit

a = b + c
where
b = 1
c = 2
d = a * 2

Explicit

a = b + c
where
{b = 1;
c = 2}
d = a * 2

Ordinary

-- This is a comment
-- This comment is single line
Nested
{-
This is a comment
Could be multiline
-}

Exercise: Make the correction of:

N = a `div` length xs
where
a = 10
xs = [1,2,3,4,5]