Post on 24-Feb-2016
description
Functional Programing
Referencing material fromProgramming Language Pragmatics – Third Edition – by Michael L.
ScottAndy Balaam (Youtube.com/user/ajbalaam)
History
• From the work of Alan Turing, Alonzo Church, Stephen Kleene, Emil Post, and others• Each worked on their own• Each made a formalized notion of an algorithm• Church’s Thesis:Any intuitively appealing model of computing would be equally powerfull
Two ParadigmsTuring Machine(Imperative Languages)
• Based on pushdown automaton• A pushdown automata uses a stack• Uses an unbounded storage “tape”• Computation is done by reading and writing
values from cells on the tape
• Example: Google Doodle for Alan Turing’s 100th Birthday
• All of the languages you have learned in 201 and 202
Lambda Calculus(Functional Languages)
• Based on parameterized expressions, each parameter is introduced with a
• One substitutes parameters into expression to compute each expression
• Example: Scheme (later)• Lisp (scheme, rocket), Haskell, Miranda,
pH, Sisal, Single Assignment C, Erlang
No side effects
• Based on function• A function takes parameters and returns something• Functions can not modify values
First Class values
• Everything is a first class value, including functions• This allows for higher order functions, which operate on
functions.
Polymorphism
• Most functional languages are polymorphic• Lisp (Scheme, Rocket, etc.) is dynamically typed• Functions can take many different types and conditionally deal with
them based on type
Lists
• A list is an item followed by a list• This leads to natural recursion• Provides the only way to repeatedly do something
• Operate on the first element, do the same with the rest (hint: recursion)
Scheme is a dialect of Lisp
• Lisp stands for LISt Processing• It is usually interpreted, although can be compiled• Scheme uses prefix (Caimbrige Polish Notation) – although
this makes sense
Scheme Interpreters
• Dr. Scheme – deprecated• Rocket – for the Rocket dialect
• MIT Scheme – its own implementation
My Chosen best:SISC - Second Interpreter of Scheme Code• In java – portable• Uses standard Scheme in a simple command-line environment
A Scheme program
(operation operation operation operation)Operation: (operator operand operand operand)
How to do things
• Addition, subtraction, multiplication, and division are predefined and referred to with +,-,*,/.• Other operations, like modulus are referred to with words• In order to trigger evaluation you must wrap an operation in parenthasys
• (+ 1 2) evaluates to 3• 7 is already evaluated, it results in 7• (7) tries to run the function 7. 7 is not a function• Similarly ((+ 1 2)) tries to run the function 3
How to not do things
• A single quote defines a list• Because an operation is a list, this means that we can use the
single quote to do operations on a operation or return the operation
‘(+ 1 2) results in the list (+ 1 2)
Control flow
IfIf [Boolean] [expr if true] [expr if false]
CondCond
([boolean] [expr])([boolean] [expr])(else [expr if else])
Defining items – lambda expressions
• From lambda calculus• Lambda takes two arguments, a list of identifiers, and an
expression to compute using them• Lambda (x) (* x x) is a function that takes a value and returns
its square
Defining – function ‘Define’As the Book does it
• Define takes two parameters, an identifier, and a function• (Define pow (lambda (x) (* x x)) allows us to use the function
pow that takes a parameter and returns its square
Defining – function ‘Define’Another way
• Define takes two parameters, a list matching how it should be called, and an expression using the identifiers given in the first part• This merges lambda expressions and definition• (define (pow x) (* x x)) defines the same thing as before
Defining – local bindings
• Defining is just global binding• You can create local bindings using let• Let takes a list of defines parameters and an expression, and
runs the expression using that set of defines
Lists
• Everything is a list• Recall: a single quote makes a set of parenthesis not evaluate and
stay as a list• ‘(1 2 3) is a list• Recall: a list is an item followed by a list• What about the last item?• Null? [list]
Higher-Order FunctionsI heard you like functions, so we made your functions return
functions, so you can compute what you compute.
Metaprogramming is just programming
• Metaprogramming is writing code about code• Lisp doesn’t care
• Lisp is homoiconic – a lisp program is a list.• A function can be an argument to a function, or it can be
returned from a function
Example – Folding
(define fold (lambda (f I l)(if (null? L) I
(f (car l) (fold f I (cdr l))))))
This takes a function f to fold the list l using the identity i
Evaluation orderApplicative-order
• You evaluate each argument before you pass it to a function
Normal-order• You pass each argument as an
unevaluated expression
Example (Right from the book)
Applicative-order(double (* 3 4))(double 12)(+ 12 12)24
What kind of cases could applicative order be wasteful?
Normal-order(double (* 3 4))(+ (* 3 4) (* 3 4))(+ 12 (* 3 4))(+ 12 12)24This is much longerWe calculate the same value twice
(Define double (lambda (x) (+ x x)))(double (* 3 4))
Scheme
The book claims that scheme evaluates in applicative-order.
But what about this line? (We just saw this in dynamic typing)(if (> a 0) (+ 2 3) (+ 2 “foo”))
In reality: Lazy evaluation
• We evaluate any evaluable expressions and store their value for later use• We can forget about this, it is behind the scenes
Side-effect free
• Its simple• Not much advanced computer science
needed• Perfect for math• No required evaluation order (other
than common sense)• Parallelism doesn’t matter (the only
way to “talk” is to pass variables)
• Some general programming ideas require assignment (we can’t do that)
• I/O is difficult (technically impossible without side effects)
• Any small update requires an entire new copy of the data