CS 61A Discussion 9 Scheme Albert Xu Attendance: - - PowerPoint PPT Presentation

CS 61A Discussion 9

Scheme Albert Xu

Attendance: links.cs61a.org/albert-disc Slides: albertxu.xyz/teaching/cs61a/

Announcements

Major Differences

Scheme has a fundamental philosophical difference from languages like Python.

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. expression statement

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. 2 + 3 expression statement

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. 2 + 3 def f(x): return x expression statement

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. 2 + 3 def f(x): return x expression statement Scheme does not have statements! Everything is evaluated into a value.

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. 2 + 3 def f(x): return x expression statement Scheme does not have statements! Everything is evaluated into a value.

in Scheme…

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. 2 + 3 def f(x): return x expression statement Scheme does not have statements! Everything is evaluated into a value. expression statement

in Scheme…

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. 2 + 3 def f(x): return x expression statement Scheme does not have statements! Everything is evaluated into a value. (+ 2 3) expression statement

in Scheme…

Major Differences

Scheme has a fundamental philosophical difference from languages like Python. 2 + 3 def f(x): return x expression statement Scheme does not have statements! Everything is evaluated into a value. (+ 2 3) expression statement

in Scheme…

Primitives and Expressions

scheme doesn’t have statements!

primitives

Primitives and Expressions

scheme doesn’t have statements!

primitives 1 1.234

Primitives and Expressions

scheme doesn’t have statements!

primitives 1 ‘abc 1.234

Primitives and Expressions

scheme doesn’t have statements!

primitives 1 ‘abc 1.234 x

Primitives and Expressions

scheme doesn’t have statements!

primitives 1 ‘abc #t #f 1.234 x

Primitives and Expressions

scheme doesn’t have statements!

primitives 1 ‘abc #t #f 1.234 a.k.a. atoms x

Primitives and Expressions

scheme doesn’t have statements!

primitives expressions 1 ‘abc #t #f 1.234 a.k.a. atoms x

Primitives and Expressions

scheme doesn’t have statements!

primitives expressions 1 ‘abc #t #f 1.234 a.k.a. atoms (define a 1) x

Primitives and Expressions

scheme doesn’t have statements!

primitives expressions 1 ‘abc #t #f 1.234 a.k.a. atoms (+ 2 3) (define a 1) x

Primitives and Expressions

scheme doesn’t have statements!

primitives expressions 1 ‘abc #t #f 1.234 a.k.a. atoms (+ 2 3) (define a 1) (lambda (x) (+ x 1)) x

Primitives and Expressions

scheme doesn’t have statements!

primitives expressions 1 ‘abc #t #f 1.234 a.k.a. atoms (+ 2 3) (define a 1) (lambda (x) (+ x 1))

notice that all expressions are formed by combining atoms!

x

define expression

Two ways to use define! 1. Defining variables 2. Defining functions

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1)

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc)

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1

(define (<fn> <op-1> … <op-n>) (fn-body) )

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1))

(define (<fn> <op-1> … <op-n>) (fn-body) )

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1)) f

(define (<fn> <op-1> … <op-n>) (fn-body) )

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1)) f >>> f

(define (<fn> <op-1> … <op-n>) (fn-body) )

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1))

(define (<fn> <op-1> … <op-n>) (fn-body) )

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1)

(define (<fn> <op-1> … <op-n>) (fn-body) )

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1) 2

(define (<fn> <op-1> … <op-n>) (fn-body) )

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

(define (<fn> <op-1> … <op-n>) (fn-body) )

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1) 2 >>> (eval ‘(f 1))

define expression

Two ways to use define!

(define <symbol> <value>)

1. Defining variables 2. Defining functions

>>> (define abc 1) abc >>> abc 1 >>> ‘abc abc >>> (eval ‘abc) 1 >>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1) 2 >>> (eval ‘(f 1)) 2

(define (<fn> <op-1> … <op-n>) (fn-body) )

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions? 1) Evaluate the operator 2) Evaluate the operands

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions? 1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1))

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1)) f

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1)) f >>> f

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1))

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1)

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1) 2

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1) 2 >>> (f 1 2)

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Call Expressions, again

Syntax: (<operator> <op-1> <op-2> … <op-n>) Reminder: What are the rules of evaluating call expressions?

>>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1)) >>> (f 1) 2 >>> (f 1 2) Error: Too many arguments …

1) Evaluate the operator 2) Evaluate the operands 3) Apply the result of (1) to the result of (2)

Special Forms

unlike call expressions…

What is a Special Form?

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do!

What is a Special Form?

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

What is a Special Form?

Examples

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

What is a Special Form?

define is a special form!

Examples

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

What is a Special Form?

define is a special form!

Examples

(define x 1)

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

What is a Special Form?

define is a special form! Short-circuiting means that we can’t evaluate an operand until we know the truth value of the previous operand.

Examples

(define x 1)

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

What is a Special Form?

define is a special form! Short-circuiting means that we can’t evaluate an operand until we know the truth value of the previous operand.

Examples

(define x 1) (or 2 (/ 1 0)

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

What is a Special Form?

define is a special form! Short-circuiting means that we can’t evaluate an operand until we know the truth value of the previous operand. if expressions should only evaluate the <if-true> or <if-false> operand

Examples

(define x 1) (or 2 (/ 1 0)

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

What is a Special Form?

define is a special form! Short-circuiting means that we can’t evaluate an operand until we know the truth value of the previous operand. if expressions should only evaluate the <if-true> or <if-false> operand

Examples

(define x 1) (or 2 (/ 1 0) (if #t (+ 1 2) (- 2 1))

There’s an issue with call expressions - it doesn’t work for all of the things we want our Scheme language to do! Special forms don’t follow the evaluation rules we just talked about! Usually this means we evaluate the

• perands in a different order, or don’t evaluate them at all!

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy!

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

• If <condition> is truthy,

eval and return <if-true>. Otherwise eval and return <if-false>.

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

• If <condition> is truthy,

eval and return <if-true>. Otherwise eval and return <if-false>.

>>> (define x #t)

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

• If <condition> is truthy,

eval and return <if-true>. Otherwise eval and return <if-false>.

>>> (define x #t) x

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

• If <condition> is truthy,

eval and return <if-true>. Otherwise eval and return <if-false>.

>>> (define x #t) x >>> (if x (+ 1 1) (/ 1 0))

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

• If <condition> is truthy,

eval and return <if-true>. Otherwise eval and return <if-false>.

>>> (define x #t) x >>> (if x (+ 1 1) (/ 1 0)) 2

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

• If <condition> is truthy,

eval and return <if-true>. Otherwise eval and return <if-false>.

>>> (define x #t) x >>> (if x (+ 1 1) (/ 1 0)) 2 >>> (if 0 (/ 1 0) (+ 1 1))

if, booleans

Remember! The only falsy value in Scheme is #f, everything else is truthy! 1 #t #f nil if special form

• Syntax: (if <condition>

<if-true> <if-false>)

• If <condition> is truthy,

eval and return <if-true>. Otherwise eval and return <if-false>.

>>> (define x #t) x >>> (if x (+ 1 1) (/ 1 0)) 2 >>> (if 0 (/ 1 0) (+ 1 1)) Error: Cannot divide by 0

short circuiting

Syntax: (and/or <args>) Short circuiting works the same in Scheme as it does in Python! >>> (or 1 #f)

short circuiting

Syntax: (and/or <args>) Short circuiting works the same in Scheme as it does in Python! >>> (or 1 #f) 1

short circuiting

Syntax: (and/or <args>) Short circuiting works the same in Scheme as it does in Python! >>> (or 1 #f) 1 >>> (and #f 2 3)

short circuiting

Syntax: (and/or <args>) Short circuiting works the same in Scheme as it does in Python! >>> (or 1 #f) 1 >>> (and #f 2 3) #f

short circuiting

Syntax: (and/or <args>) Short circuiting works the same in Scheme as it does in Python! >>> (or 1 #f) 1 >>> (and #f 2 3) #f >>> (and 2 3)

short circuiting

Syntax: (and/or <args>) Short circuiting works the same in Scheme as it does in Python! >>> (or 1 #f) 1 >>> (and #f 2 3) #f >>> (and 2 3) 3

lambdas are here to stay

Convert this Python code to Scheme:

square = lambda x: x**2

lambdas are here to stay

Convert this Python code to Scheme:

square = lambda x: x**2 (define square (lambda (x) (* x x)))

lambdas are here to stay

All functions in Scheme are lambda functions! Convert this Python code to Scheme:

square = lambda x: x**2 (define square (lambda (x) (* x x)))

lambdas are here to stay

>>> (define (f x) (+ x 1)) f >>> f (lambda (x) (+ x 1))

All functions in Scheme are lambda functions! Convert this Python code to Scheme:

square = lambda x: x**2 (define square (lambda (x) (* x x)))

Lists in Scheme

remember linked lists?

List Basics

• Scheme lists are like Python’s Pair. Both are linked lists.
• Attributes
• first - the current list element
• rest - the rest of the elements

List Basics

• Scheme lists are like Python’s Pair. Both are linked lists.
• Attributes
• first - the current list element
• rest - the rest of the elements
• Accessing List Values
• car - get the first element of a list
• cdr - get the rest of a list

List Basics

• Scheme lists are like Python’s Pair. Both are linked lists.
• Attributes
• first - the current list element
• rest - the rest of the elements
• Accessing List Values
• car - get the first element of a list
• cdr - get the rest of a list

1 4 9

first rest

Pair(1, Pair(4, Pair(9, nil)))

List Basics

• Scheme lists are like Python’s Pair. Both are linked lists.
• Attributes
• first - the current list element
• rest - the rest of the elements
• Accessing List Values
• car - get the first element of a list
• cdr - get the rest of a list

1 4 9

first rest

(cons 1 (cons 4 (cons 9 nil))) Pair(1, Pair(4, Pair(9, nil)))

Equality

in scheme = can only be used for comparing numbers.

eq? behaves like == in Python for comparing two non-pairs (numbers, booleans, etc.). Otherwise, eq? behaves like is in Python (= 2 2) (= ‘(1) ‘(1)) (eq? 2 2) (eq? #t #t) (eq? ‘(1) ‘(1)) (define lst ‘(1)) (eq? lst lst)

Equality

in scheme = can only be used for comparing numbers.

(= 2 2) (= ‘(1) ‘(1))

Equality

in scheme = can only be used for comparing numbers.

eq? behaves like == in Python for comparing two non-pairs (numbers, booleans, etc.). Otherwise, eq? behaves like is in Python (= 2 2) (= ‘(1) ‘(1))

equal? compares pairs by determining if their cars are equal? and their cdrs are equal?(that is, they have the same contents). Otherwise, equal? behaves like eq?

(eq? 2 2) (eq? #t #t) (eq? ‘(1) ‘(1)) (define lst ‘(1)) (eq? lst lst) (equal? ‘(1) ‘(1)) (define lst ‘(1)) (equal? lst lst)

Creating Lists

One of the most important things about solving Scheme problems is knowing what function you should use to create your list! Given: an element and a list 1

(2 3)

Creating Lists

One of the most important things about solving Scheme problems is knowing what function you should use to create your list! Given: an element and a list Use: cons

1 (2 3) (cons 1 (2 3)) (1 2 3)

Creating Lists

One of the most important things about solving Scheme problems is knowing what function you should use to create your list! Given: an element and a list Use: cons

1 (2 3) (cons 1 (2 3))

Given: multiple elements

1 2 3 (1 2 3)

Creating Lists

One of the most important things about solving Scheme problems is knowing what function you should use to create your list! Given: an element and a list Use: cons

1 (2 3) (cons 1 (2 3))

Given: multiple elements Use: list

1 2 3 (list 1 2 3) (1 2 3)

Creating Lists

One of the most important things about solving Scheme problems is knowing what function you should use to create your list! Given: an element and a list Use: cons

1 (2 3) (cons 1 (2 3))

Given: multiple elements Use: list

1 2 3 (list 1 2 3)

Given: two lists

(1 2 3) (2 3) (1)

Creating Lists

One of the most important things about solving Scheme problems is knowing what function you should use to create your list! Given: an element and a list Use: cons

1 (2 3) (cons 1 (2 3))

Given: multiple elements Use: list

1 2 3 (list 1 2 3)

Given: two lists Use: append

(append ‘(1) ‘(2 3)) (1 2 3) (2 3) (1)

Creating Lists

One of the most important things about solving Scheme problems is knowing what function you should use to create your list! Given: an element and a list Use: cons

1 (2 3) (cons 1 (2 3))

Given: multiple elements Use: list

1 2 3 (list 1 2 3)

Given: two lists Use: append

(append ‘(1) ‘(2 3)) (1 2 3) (2 3) (1)

*cons is the most powerful and basic function! use it whenever possible…

Tips for Solving Scheme Questions

• Draw box-and-pointer examples to help visualize the problem when needed.
• Problems will require recursive solutions because Scheme has no iteration
• When writing recursive Scheme functions:
• Think about your base case (use if or cond).
• Think about using recursion on the cdr of the list.
• Think about how you would approach the problem in Python. Both

languages are well suited for functional programming.

• Helpful functions:
• (list args) – takes 1 or more arguments and returns a well-formed list
• (null? arg) – checks if a given element is an empty list
• (append list1 list2) – takes 2 lists and concatenates them into one list

Thanks for coming.

Have a great rest of your week! :)

Attendance: links.cs61a.org/albert-disc Slides: albertxu.xyz/teaching/cs61a/