Lecture 17

On Functional Programming

Logistics and Week Ahead

Today

• Friday - Wrapping up Functional Programming
• Saturday 11:59pm - late deadline for Ex5
• Sunday 11:59pm - Ethics reflections for Module 6 - Impact

For some - Ethics Module 7 - Labor

• Monday - Intro to Imperative Programming
• Wednesday - More Imperatives (Pre-Recorded + MQ13) + Tutorial 7
• Friday - Scope (MQ 14) (Ex 6 Due - Posted this Afternoon)

Announcements

• Quiz 2 grades available by Wednesday at the latest (Median: ~85)
• I'm a little behind on email; if you emailed me I will get back to you by Monday

The story up until now

• Everything in your computer is data
• Including programs
• Data is divided into objects
• Objects can be inside other objects
• An album is made up of a title, artist, and genre
• Colors inside bitmaps
• Objects have types
• Functions (procedures)
• Numbers (1 or -3.5)
• Strings (“this is a string”, “blue”)
• Picture/image objects (ellipses, rectangles, etc.)
• Albums, trees, lists, etc.

The story up until now

• Computation is performed using expressions
• Expressions have (or “return”) values (i.e. outputs)
• Computation is performed by recursively replacing expressions with their values
• A computation's only output is its return value
• It's return value only depends on:
• Its inputs
• The expression's structure
• The other definitions in the program
• It doesn't depend on what was computed before unless it's directly nested/chained/connected to it (i.e. it doesn’t depend on the computer’s state)
• Once we define a variable, it's been impossible to update it

Rules of computation in Racket

Look at the expression

• If it’s a constant (i.e. a number or string), it’s its own value
• If it’s a variable name (i.e. a word, hyphenated phrase, etc.), look its value up in the dictionary
• Parentheses? (Check if it’s one of the special cases from the next slide)
• Otherwise it’s a function call
• (func-expression arg-expression₁ … arg-expression_n)
• Execute all the subexpressions�(func-expression and arg-expression₁ through arg-expression_n)
• Call the value of func-expression, passing it the values of arg-expression₁ through arg-expression_n as inputs
• Use its output as the value of the expression

Special cases: Rules of computation in Racket

If it starts with define

(define name value-expression)

• Run value-expression
• Assign its value to name�in the dictionary

If it starts with λ or lambda:

(λ (name₁ … name_last) result-expression)

• Make a function
• That names its inputs�name₁ … name_last
• And returns the value�of result-expression�(presumably using those names)

If it starts with the the word local

(local [(define name₁ value₁) � …� (define name_last value_last)]� result-expression)

• Run the value expressions
• Substitutes their values for their respective�names in result-expression
• Runs the substituted result-expression
• Returns its value

​

If it starts with if:

(if test consequent alternative)

• Run test
• If it returns true, run consequent and return its value
• Otherwise run alternative and return its value

Special cases: Rules of computation in Racket

If it starts with define-struct

(define-struct typename (properties…))

• Creates a new type of data called typename
• Defines a constructor: make-typename
• Defines accessors: typename-property-1…
• Defines predicate: typename?

If it starts with cond:

(cond [test₁ result₁]

[ … ]

[else result_last])

• Runs tests in order, first one to pass (#true) return corresponding result

If it starts with require:

(require some-library)

• Loads function definitions for later use from some-library

If it starts with check-expect:

(check-expect thing-1 thing-2)

• Compares two things and "passes" if the two things are equivalent.

Simple Execution Examples

2

​

"Friday"

​

#true

​

​

Simple Execution Examples

(define a "FRIDAY!")

a

​

map

​

​

What are these?

(λ (x)

(+ x 2))

​

(define pizza "connor")

Compound Examples

(define pizza "connor")

(cond [(string=? pizza "pizza") #false ]

[(string=? pizza "pineapple") #true ]

[(= pizza 5) "wait" ]

[else "uh oh"])

​

​

((λ (x)

(+ x 2))

5)

(define (map-helper func in out)

(if (empty? in)

out

(loop func

(rest in)

(cons (func (first in))

out))))

​

(define (map lst)

(map-helper - lst '())

​

map

Pernicious Examples

(foldl or #false '(#false #true #false #false))

​

; my-filter/iter-helper : (any -> bool) (listof any) (listof any) -> (listof any)

; helper function for my-filter/iter

(define (my-filter/iter-helper pred l accum)

(cond [(empty? l) accum]

[(pred (first l)) (my-filter/iter-helper pred

(rest l)

accum)]

[else (my-filter/iter-helper pred

(rest l)

accum)]))

​

; my-filter/iter : (any -> bool) (listof any) -> (listof any)

; Works identically to filter, but uses iterative recursion

(define (my-filter/iter pred lst)

(reverse (my-filter/iter-helper pred lst '())))

​

(my-filter/iter even? '(1 2 3 4))

; my-filter/iter-helper : (any -> bool) (listof any) (listof any) -> (listof any)

; helper function for my-filter/iter

(define (my-filter/iter-helper pred l accum)

(cond [(empty? l) accum]

[(pred (first l)) (my-filter/iter-helper pred

(rest l)

accum)]

[else (my-filter/iter-helper pred

(rest l)

accum)]))

; my-filter/iter-helper : (any -> bool) (listof any) (listof any) -> (listof any)

; helper function for my-filter/iter

(define (my-filter/iter-helper pred l accum)

(cond [(empty? l) accum]

[(pred (first l)) (my-filter/iter-helper pred

(rest l)

(cons (first l) accum))]

[else (my-filter/iter-helper pred

(rest l)

accum)]))

; my-iterated-overlay/iter : (num -> img) num -> img

; Works the same was as iterated-overlay using iterative recursion.

(define (my-iterated-overlay/iter gen num)

(local [(define (helper mygen n acc)

(local [(define recursive-step n)]

(cond [(= n 0) acc]

[else (helper mygen

recursive-step

(overlay (mygen recursive-step)

acc))])))]

(helper gen num empty-image)))

​

(my-iterated-overlay/iter (lambda (x) (square (* x 50) "outline" "red")) 5)

​

; my-iterated-overlay/iter : (num -> img) num -> img

; Works the same was as iterated-overlay using iterative recursion.

(define (my-iterated-overlay/iter gen num)

(local [(define (helper mygen n acc)

(local [(define recursive-step (- n 1))]

(cond [(= n 0) acc]

[else (helper mygen

recursive-step

(overlay (mygen recursive-step)

acc))])))]

(helper gen num empty-image)))

​

(my-iterated-overlay/iter (lambda (x) (square (* x 50) "outline" "red")) 5)

​

;; A binary-tree is one of:

;; - A string (a name), e.g. "Connor"

;; - A (make-branch string[s] binary-tree binary-tree)

(define-struct branch (name left right))

​

;; Valid Trees given this definition!

“Connor”

(make-branch “Rex” “Buzz” “Stinky Pete”)

​

;; Invalid Trees given this definition!

(make-branch “Rex” #false #false)

(make-branch “Rex”)

Why though?

• Flexibility. More tools means more solutions.
• Very few circumstances where you program in a purely functional language
• Examples in Industry
• OCAML at Jane Street (Finance)
• Big Data Analytics at Spotify (Audio and Music)
• Erlang at Klarna (FinTech) and at WhatsApp (Communications)
• AWS Lambda (Serverless Architectures)
• Examples in other Languages
• In Python
• In C++
• In Scala
• What you want is to be able to use functional aspects within modern languages
• "You should do it whenever it is convenient, and you should think hard about the decision when it isn’t convenient." - John Carmack (Video Game Dev, Doom / Oculus)

Functional vs Imperative Programming

• Functional programming is programming without effects and sequencing
• The only effects (output) of an expression is its return value
• Value of a function call is determined entirely by the inputs to a function which might include nested function calls
• Result doesn't depend on order of execution of subexpressions; the substitution model perfectly emulates execution.
• Imperative programming
• Expressions can have many different effects: return value, changing variables, deleting files, etc.
• Those side effects can influence the behavior of other expressions (even if they seem unrelated).
• Computation is achieved by sequencing changes
• Forces us to think about execution as changes and causality

A Little Game Design

Believe it or not, we have all the tools necessary to implement a real game!

And that's what we're going to do in Exercise 6!

Basics of Game Design: Model View Controller

A way of abstracting game design into three interconnected parts:

Model

• Takes care of representing and updating game data objects

View

• Renders the contents of the model

Controller

• Takes inputs from the user

From Design Patterns in Game Engine Dev

Snake!

​

https://www.mikusa.com/snake/snake.html

Let's focus on the DATA behind the game

What sorts of data do we need to represent the game?

What objects exist?

What properties do they have?

​

​

How might we make these in Racket?

Let's focus on the REPRESENTATION of the game

How is each object represented visually?

​

​

​

​

​

How might we make these in Racket?

Let's focus on the LOGIC of the game

How does the game work?

How are objects manipulated?

​

​

​

​

​

How might we write this in Racket?

Basics of Game Design: Model View Controller

A way of abstracting game design into three interconnected parts:

Model

• Takes care of representing and updating game data objects

View

• Renders the contents of the model

Controller

• Takes inputs from the user

From Design Patterns in Game Engine Dev