Introduction to Functional Programming · 2019-12-05 · CSE 116: Fall 2019 Introduction to Functional Programming Owen Arden UC Santa Cruz Lambda Calculus Based on course materials

CSE 116: Fall 2019

Introduction to Functional Programming

Owen Arden

UC Santa Cruz

Lambda Calculus

Based on course materials developed by Ranjit Jhala

Your favorite language

• Probably has lots of features: – ︎Assignment (x = x + 1)

– ︎Booleans, integers, characters, strings,... ︎

– Conditionals – ︎Loops, ︎ return, break, continue – ︎Functions

– ︎Recursion

– ︎References / pointers

– ︎Objects and classes – ︎Inheritance

– … and more

!2





– ︎Recursion



– … and more

!3

Which ones can we do without? What is the smallest universal language?

What is computable?

• Prior to 1930s – Informal notion of an effectively calculable

function:

One that can be computed by a human

with pen and paper, following an algorithm!4

What is computable?

• 1936: Formalization

!5

Alan Turing: Turing machines

What is computable?

• 1936: Formalization

!6

Alonzo Church: lambda calculus

e::=x|\x->e|e1e2

The Next 700 Languages

• Big impact on language design!

!7

Whatever the next 700 languages turn out to be, they will surely be variants of lambda calculus.

Peter Landin, 1966





– ︎Recursion



– … and more

!8

The Lambda Calculus

• Features – ︎Functions

– (that’s it)

!9

The Lambda Calculus

• Seriously… – ︎Assignment (x = x + 1)



– ︎Recursion



– … and more

!10

The only thing you can do is: Define a function Call a function

Describing a Programming Language

• Syntax – What do programs look like?

• Semantics – What do programs mean? – Operational semantics:

• How do programs execute step-by-step?

!11

Syntax: What programs look like

• Programs are expressions e (also called λ-terms)

• Variable: x, y, z

• Abstraction (aka nameless function definition): – \x -> e “for any x, compute e” – x is the formal parameter, e is the body

• Application (aka function call):

– e1 e2 “apply e1 to e2” – e1 is the function, e2 is the argument

!12

e::=x|\x->e|e1e2

Examples--Theidentityfunction("foranyxcomputex")\x->x

--Afunctionthatreturnstheidentityfunction\x->(\y->y)

--Afunctionthatappliesitsargumentto

--theidentityfunction\f->f(\x->x)

!13





!14

• How do I define a function with two arguments? • e.g. a function that takes x and y and returns y





!15

• How do I define a function with two arguments? • e.g. a function that takes x and y and returns y

OR: a function that takes two arguments and returns the second one!

Examples

• How do I apply a function to two arguments? – e.g. apply \x -> (\y -> y) to apple and banana?

!16

--firstapplytoapple,thenapplytheresulttobanana

(((\x->(\y->y))apple)banana)

Syntactic Sugar

• Convenient notation used as a shorthand for valid syntax

!17

\xy->y--Afunctionthatthattakestwoarguments

--andreturnsthesecondone...(\xy->y)applebanana--...appliedtotwoarguments

instead of we write

\x->(\y->(\z->e)) \x->\y->\z->e

\x->\y->\z->e \xyz->e

(((e1e2)e3)e4) e1e2e3e4

Semantics: What programs mean

• How do I “run” or “execute” a λ-term?

• Think of middle-school algebra:

--Simplifyexpression:

(x+2)*(3*x-1)=???

• Execute = rewrite step-by-step following simple rules until no more rules apply

!18

Rewrite rules of lambda calculus

1. α-step (aka renaming formals)

2. β-step (aka function call)

But first we have to talk about scope

!19

Semantics: Scope of a Variable

!20

• The part of a program where a variable is visible

• In the expression \x -> e

– x is the newly introduced variable

– e is the scope of x

– any occurrence of x in \x -> e is bound (by the binder \x)

Semantics: Scope of a Variable

!21

• For example, x is bound in:

\x->x\x->(\y->x)

• An occurrence of x in e is free if it’s not bound by an enclosing abstraction

• For example, x is free in: xy--nobindersatall!

\y->xy--no\xbinder(\x->\y->y)x--xisoutsidethescope--ofthe\xbinder;--intuition:it'snot"thesame"x

Free Variables

!22

• An variable x is free in e if there exists a free occurrence of x in e

• We can formally define the set of all free variables in a term like so:

FV(x)=???FV(\x->e)=???

FV(e1e2)=???

Free Variables

!23

• An variable x is free in e if there exists a free occurrence of x in e

• We can formally define the set of all free variables in a term like so:

FV(x)={x}FV(\x->e)=FV(e)\{x}

FV(e1e2)=FV(e1)∪FV(e2)

Closed Expressions

!24

• If e has no free variables it is said to be closed

• Closed expressions are also called combinators

– Q: What is the shortest closed expression?

Closed Expressions

!25

• If e has no free variables it is said to be closed

• Closed expressions are also called combinators

– Q: What is the shortest closed expression?

– A: \x -> x




!26

Semantics: β-Reduction

(\x->e1)e2=b>e1[x:=e2]

where e1[x := e2] means “e1 with all free occurrences of x replaced with e2”

!27

• Computation by search-and-replace:

• If you see an abstraction applied to an argument, take the body of the abstraction and replace all free occurrences of the formal by that argument

• We say that (\x->e1)e2 β-steps to e1[x:=e2]

Examples(\x->x)apple=b>apple

Is this right? Ask Elsa!

(\f->f(\x->x))(giveapple)=b>???

!28

Examples(\x->x)apple=b>apple

Is this right? Ask Elsa!

(\f->f(\x->x))(giveapple)=b>giveapple(\x->x)

!29

A Tricky One(\x->(\y->x))y=b>\y->y

Is this right?

Problem: the free y in the argument has been captured by \y!

Solution: make sure that all free variables of the argument are different from the binders in the body.

!30

Capture-Avoiding Substitution

!31

• We have to fix our definition of β-reduction:

(\x->e1)e2=b>e1[x:=e2]

where e1[x := e2] means “e1 with all free occurrences of x replaced with e2”

– e1 with all free occurrences of x replaced with e2, as long as no free variables of e2 get captured

– undefined otherwise

Capture-Avoiding Substitution

!32

Formally:

x[x:=e]=ey[x:=e]=y--assumingx/=y(e1e2)[x:=e]=(e1[x:=e])(e2[x:=e])

(\x->e1)[x:=e]=\x->e1--whyjustè1`?

(\y->e1)[x:=e]|not(yinFV(e))=\y->e1[x:=e]

|otherwise=undefined--butwhatthen???




!33

Semantics: α-Reduction

\x->e=a>\y->e[x:=y]wherenot(yinFV(e))

!34

• We can rename a formal parameter and replace all its occurrences in the body

• We say that (\x->e) α-steps to (\y->e[x:=y])

Semantics: α-Reduction

\x->e=a>\y->e[x:=y]wherenot(yinFV(e))

!35

• Example:

\x->x=a>\y->y=a>\z->z

• All these expressions are α-equivalent

Example

What’s wrong with these? --(A)\f->fx=a>\x->xx

--(B)

(\x->\y->y)y=a>(\x->\z->z)z

--(C)\x->\y->xy=a>\apple->\orange->appleorange

!36

The Tricky One(\x->(\y->x))y=a>???

To avoid getting confused, you can always rename formals, so that different variables have different names!

!37

The Tricky One(\x->(\y->x))y=a>(\x->(\z->x))y=b>\z->y

To avoid getting confused, you can always rename formals, so that different variables have different names!

!38

Normal Forms

A redex is a λ-term of the form

(\x->e1)e2

A λ-term is in normal form if it contains no redexes.

!39

Semantics: Evaluation

!40

• A λ-term e evaluates to e' if

1. There is a sequence of stops

e=?>e_1=?>...=?>e_N=?>e’ where each =?> is either =a> or =b> and N >= 0

2. e’ is in normal form

Example of evaluation(\x->x)apple=b>apple

(\f->f(\x->x))(\x->x)=?>???

(\x->xx)(\x->x)=?>???

!41


(\f->f(\x->x))(\x->x)=b>(\x->x)(\x->x)=b>\x->x

(\x->xx)(\x->x)=?>???

!42


(\f->f(\x->x))(\x->x)=b>(\x->x)(\x->x)=b>\x->x

(\x->xx)(\x->x)=b>(\x->x)(\x->x)

=b>\x->x

!43

Elsa shortcuts

!44

• Named λ-terms letID=\x->x--abbreviationfor\x->x

• To substitute a name with its definition, use a =d> step:

IDapple

=d>(\x->x)apple--expanddefinition=b>apple--beta-reduce

Elsa shortcuts

!45

• Evaluation

– e1 =*> e2: e1 reduces to e2 in 0 or more steps

• where each step is =a>, =b>, or =d>

– e1 =~> e2: e1 evaluates to e2

• What is the difference?

Non-Terminating Evaluation

!46

(\x->xx)(\x->xx)=b>(\x->xx)(\x->xx)

• Oh no… we can write programs that loop back to themselves

• And never reduce to normal form!

• This combinator is called Ω

Non-Terminating Evaluation

!47

• What if we pass Ω as an argument to another function?

letOMEGA=(\x->xx)(\x->xx)

(\x->\y->y)OMEGA

• Does this reduce to a normal form? Try it at home!

Programming in λ-calculus

!48

• Real languages have lots of features

– Booleans

– Records (structs, tuples)

– Numbers

– Functions [we got those]

– Recursion

• Let’s see how to encode all of these features with the λ-calculus.

λ-calculus: Booleans

!49

• How can we encode Boolean values (TRUE and FALSE) as functions?

• Well, what do we do with a Boolean b?

– We make a binary choice

ifbthene1elsee2

Booleans: API

!50

• We need to define three functions

letTRUE=???letFALSE=???letITE=\bxy->???--ifbthenxelsey

such that

ITETRUEapplebanana=~>appleITEFALSEapplebanana=~>banana

(Here, letNAME=e means NAME is an abbreviation for e)

Booleans: Implementation

!51

letTRUE=\xy->x--ReturnsfirstargumentletFALSE=\xy->y--ReturnssecondargumentletITE=\bxy->bxy--Appliescond.tobranches

--(redundant,but--improvesreadability)

Example: Branches step-by-step

!52

evalite_true:ITETRUEe1e2=d>(\bxy->bxy)TRUEe1e2--expanddefITE

=b>(\xy->TRUExy)e1e2--beta-step=b>(\y->TRUEe1y)e2--beta-step=b>TRUEe1e2--expanddefTRUE=d>(\xy->x)e1e2--beta-step

=b>(\y->e1)e2--beta-step=b>e1


!53

• Now you try it!

• Can you fill in the blanks to make it happen?

– http://goto.ucsd.edu:8095/index.html#?demo=ite.lc

evalite_false:ITEFALSEe1e2

--fillthestepsin!

=b>e2


!54

evalite_false:ITEFALSEe1e2=d>(\bxy->bxy)FALSEe1e2--expanddefITE

=b>(\xy->FALSExy)e1e2--beta-step=b>(\y->FALSEe1y)e2--beta-step=b>FALSEe1e2--expanddefTRUE=d>(\xy->y)e1e2--beta-step

=b>(\y->y)e2--beta-step=b>e2

Boolean operators

!55

• Now that we have ITE it’s easy to define other Boolean operators:

letNOT=\b->???

letAND=\b1b2->???

letOR=\b1b2->???

Boolean operators

!56


letNOT=\b->ITEbFALSETRUE

letAND=\b1b2->ITEb1b2FALSE

letOR=\b1b2->ITEb1TRUEb2

Boolean operators

!57


letNOT=\b->bFALSETRUE

letAND=\b1b2->b1b2FALSE

letOR=\b1b2->b1TRUEb2

– (since ITE is redundant)

– Which definition to do you prefer and why?


!58


– Booleans [done]

– Records (structs, tuples)

– Numbers


– Recursion

λ-calculus: Records

!59

• Let’s start with records with two fields (aka pairs)?

• Well, what do we do with a pair?

1.Pack two items into a pair, then

2.Get first item, or

3.Get second item.

Pairs: API

!60

• We need to define three functions

letPAIR=\xy->???--Makeapairwithxandy--{fst:x,snd:y}letFST=\p->???--Returnfirstelement--p.fstletSND=\p->???--Returnsecondelement

--p.snd

such that

FST(PAIRapplebanana)=~>appleSND(PAIRapplebanana)=~>banana

Pairs: Implementation

!61

• A pair of x and y is just something that lets you pick between x and y! (I.e. a function that takes a boolean and returns either x or y)

letPAIR=\xy->(\b->ITEbxy)letFST=\p->pTRUE--callw/TRUE,get1stvalueletSND=\p->pFALSE--callw/FALSE,get2ndvalue

Exercise: Triples?

!62

• How can we implement a record that contains three values?

letTRIPLE=\xyz->???letFST3=\t->???letSND3=\t->???letTRD3=\t->???

Exercise: Triples?

!63

• How can we implement a record that contains three values?

letTRIPLE=\xyz->PAIRx(PAIRyz)letFST3=\t->FSTtletSND3=\t->FST(SNDt)letTRD3=\t->SND(SNDt)


!64


– Booleans [done]

– Records (structs, tuples) [done]

– Numbers


– Recursion

λ-calculus: Numbers

!65

• Let’s start with natural numbers (0, 1, 2, …)

• What do we do with natural numbers?

1. Count: 0, inc

2. Arithmetic: dec, +, -, *

3. Comparisons: ==, <=, etc

Natural Numbers: API

!66

• We need to define:

– A family of numerals: ZERO, ONE, TWO, THREE, …– Arithmetic functions: INC, DEC, ADD, SUB, MULT– Comparisons: IS_ZERO, EQ

Such that they respect all regular laws of arithmetic, e.g.

IS_ZEROZERO=~>TRUEIS_ZERO(INCZERO)=~>FALSEINCONE=~>TWO

...

Pairs: Implementation

!67

• Church numerals: a number N is encoded as a combinator that calls a function on an argument N times

letONE=\fx->fxletTWO=\fx->f(fx)letTHREE=\fx->f(f(fx))

letFOUR=\fx->f(f(f(fx)))letFIVE=\fx->f(f(f(f(fx))))letSIX=\fx->f(f(f(f(f(fx)))))...

λ-calculus: Increment

!68

--Call`fòn`xònemoretimethan`n`doesletINC=\n->(\fx->???)

• Example

evalinc_zero:

INCZERO=d>(\nfx->f(nfx))ZERO=b>\fx->f(ZEROfx)=*>\fx->fx

=d>ONE

λ-calculus: Addition

!69

--Call`fòn`xèxactly`n+m`timesletADD=\nm->nINCm

• Example

evaladd_one_zero:

ADDONEZERO=~>ONE

λ-calculus: Multiplication

!70

--Call`fòn`xèxactly`n*m`timesletMULT=\nm->n(ADDm)ZERO

• Example

evaltwo_times_one:

MULTTWOONE=~>TWO


!71


– Booleans [done]


– Numbers [done]


– Recursion

λ-calculus: Recursion

!72

• I want to write a function that sums up natural numbers up to n:

\n->...--1+2+...+n


!73

• No! Named terms in Elsa are just syntactic sugar

• To translate an Elsa term to λ-calculus: replace each name with its definition

\n->ITE(ISZn)ZERO(ADDn(SUM(DECn)))--ButSUMis--notathing!

• Recursion: Inside this function I want to call the same function on DEC n

• Looks like we can’t do recursion, because it requires being able to refer to functions by name, but in λ-calculus functions are anonymous.

• Right?


!74

• Think again!

• Recursion: Inside this function I want to call the same function on DEC n – Inside this function I want to call a function on DEC n – And BTW, I want it to be the same function

• Step 1: Pass in the function to call “recursively”

letSTEP=\rec->\n->ITE(ISZn)

ZERO(ADDn(rec(DECn)))--Callsomerec


!75

• Step 1: Pass in the function to call “recursively”

letSTEP=\rec->

\n->ITE(ISZn)ZERO(ADDn(rec(DECn)))--Callsomerec

• Step 2: Do something clever to STEP, so that the function passed as rec itself becomes

\n->ITE(ISZn)ZERO(ADDn(rec(DECn)))

λ-calculus: Fixpoint Combinator

!76

• Wanted: a combinator FIX such that FIXSTEP calls STEP with itself as the first argument:

FIXSTEP=*>STEP(FIXSTEP)

(In math: a fixpoint of a function f(x) is a point x, such that f(x) = x)

• Once we have it, we can define: letSUM=FIXSTEP

• Then by property of FIX we have: SUM=*>STEPSUM--(1)


!77

evalsum_one:SUMONE=*>STEPSUMONE--(1)=d>(\recn->ITE(ISZn)ZERO(ADDn(rec(DECn))))SUMONE=b>(\n->ITE(ISZn)ZERO(ADDn(SUM(DECn))))ONE--^^^themagichappened!=b>ITE(ISZONE)ZERO(ADDONE(SUM(DECONE)))=*>ADDONE(SUMZERO)--defofISZ,ITE,DEC,...=*>ADDONE(STEPSUMZERO)--(1)=d>ADDONE((\recn->ITE(ISZn)ZERO(ADDn(rec(DECn))))SUMZERO)=b>ADDONE((\n->ITE(ISZn)ZERO(ADDn(SUM(DECn))))ZERO)=b>ADDONE(ITE(ISZZERO)ZERO(ADDZERO(SUM(DECZERO))))=b>ADDONEZERO=~>ONE


!78

• So how do we define FIX?

• Remember Ω? It replicates itself! (\x->xx)(\x->xx)=b>(\x->xx)(\x->xx)

• We need something similar but more involved.


!79

• The Y combinator discovered by Haskell Curry:

letFIX=\stp->(\x->stp(xx))(\x->stp(xx))

• How does it work?

evalfix_step:FIXSTEP=d>(\stp->(\x->stp(xx))(\x->stp(xx)))STEP

=b>(\x->STEP(xx))(\x->STEP(xx))=b>STEP((\x->STEP(xx))(\x->STEP(xx)))--^^^^^^^^^^thisisFIXSTEP^^^^^^^^^^^


!80


– Booleans [done]


– Numbers [done]


– Recursion [done]

Next time: Intro to Haskell

!81

Documents

Introduction to Functional Programming · 2019-12-05 · CSE 116: Fall 2019 Introduction to Functional Programming Owen Arden UC Santa Cruz Lambda Calculus Based on course materials