Scribd
Upload
57 views21 pages

Programming Paradigms CSI2120 - Winter 2019: Jochen Lang EECS, University of Ottawa Canada

This document discusses programming paradigms in Scheme, including local binding of variables using let, let*, and letrec. It covers characters, strings, and examples of using local functions and recursion. Some key points are: let binds variables for expressions, let* allows sequential definitions, and letrec permits recursive local function definitions. Character and string predicates and conversions are also presented.

Uploaded by

aziz spam
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
57 views21 pages

Programming Paradigms CSI2120 - Winter 2019: Jochen Lang EECS, University of Ottawa Canada

This document discusses programming paradigms in Scheme, including local binding of variables using let, let*, and letrec. It covers characters, strings, and examples of using local functions and recursion. Some key points are: let binds variables for expressions, let* allows sequential definitions, and letrec permits recursive local function definitions. Character and string predicates and conversions are also presented.

Uploaded by

aziz spam
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 21

Programming

Paradigms CSI2120
– Winter 2019

Jochen Lang
EECS, University of Ottawa
Canada
Scheme: Functional Programming

• Local Binding, let-bound Variables


• Named let-bounds
• Characters
• Strings

CSI2120: Programming Paradigms


Local Binding, let-bound Variables: let

• let
– to define a list of local variables for a list of expressions
– each variable name is bound with a value
– let returns the result of the last expression
• but evaluates all expressions from left to right
(let ((a 2) (b 3)) ; local variables a and b
(+ a b)) ; expression where the
; variables are bound
=> 5
a
=> Unbound variable: a
b
=> Unbound variable: b

CSI2120: Programming Paradigms


Local Function Definitions

• let can be used to define local functions

(let ((a 3)
(b 4)
(square (lambda (x) (* x x)))
(plus +)) ; end of definitions
; applied to
(sqrt (plus (square a) (square b))))
=> 5

CSI2120: Programming Paradigms


Sequential Definitions with let*

(let ((x 1) (y (+ x 1)))


(list x y))
=> Error: variable x is not bound.
• In order to define y in terms of x
– the function let* exists
(let* ((x 1) (y (+ x 1)))
(list x y))
=> (1 2)
• let* is similar to let but allows for sequential definitions.

CSI2120: Programming Paradigms


Example using let vs. let*

(let ((x 2) (y 3))


(let ((x 7) ; x = 7
(z (+ x y))) ; z = 2 + 3
(* z x))) ; 5 * 7
=> 35

(let ((x 2) (y 3))


(let* ((x 7) ; x = 7
(z (+ x y))) ; z = 7 + 3
(* z x))) ; 10 * 7
=> 70

CSI2120: Programming Paradigms


Setting let-bound Variables

• Let-bound variables can be changed with set!


(define seconds-set
(lambda (h m s)
(let ((sh 0) (sm 0) (total 0))
(set! sh (* 60 (* 60 h)))
(set! sm (* 60 m))
(set! total (+ s (+ sh sm)))
total)))
=> seconds-set
(seconds-set 1 5 3)
=> 3903

CSI2120: Programming Paradigms


Same Example in Functional Style

(define seconds
(lambda (h m s)
(let ((sh (* 60 (* 60 h)))
(sm (* 60 m)))
(+ s (+ sh sm)))))
=> seconds
(seconds 1 5 3)
=> 3903

CSI2120: Programming Paradigms


Recursive Definitions with letrec

• letrec
– permits the recursive definitions of functions
– letrec is similar let* but all the bindings are within the
scope of the corresponding variable
• Example: Local definition of factorial
(letrec ((fact (lambda (n)
(if (= n 1)
1
(* n (fact (- n 1)))))))
(fact 5))
=> 120

CSI2120: Programming Paradigms


Recursive Application of a Function to
a List
• Example:
– The function fct is applied to all elements in a list
(define (apply-f fct L)
(letrec ((app
(lambda (L)
(if (null? L)
()
(cons (fct (car L)) (app (cdr L)))))))
(app L)))
=> apply-f
(define double-ele (lambda(x) (+ x x)))
=> double-ele
(apply-f double-ele '(1 2 3 4))
=> (2 4 6 8)

CSI2120: Programming Paradigms


Named let-bound Variables

• Use of a name in the let expression


(let name ((var val) ...) exp1 exp2 ...)
– Factorial example
(let ft ((k 5))
(if (<= k 0)
1
(* k (ft (- k 1))))) ; call with k=k-1
• is the same as:
(letrec ((name (lambda (var ...) exp1 exp2 ...)) (name val) ...)
(letrec ((ft (lambda (k)
(if (<= k 0)
1
(* k (ft (- k 1))))))) (ft 5))

CSI2120: Programming Paradigms


Examples: Named let-Bound

• Used for recursions and loops


(define divisors
(lambda (n)
(let f ((i 2))
(cond
((>= i n) '())
((integer? (/ n i))
(cons i (f (+ i 1)))) ; call body with i=i+1
(else (f (+ i 1))))))) ; call body with i=i+1
=> divisors
(divisors 32)
=> (2 4 8 16)

CSI2120: Programming Paradigms


A Further Example

(let loop ((numbers '(3 -2 1 6 -5))


(nonneg '())
(neg '()))
(cond ((null? numbers) (list nonneg neg))
((>= (car numbers) 0)
(loop (cdr numbers) ; 3 arg. for loop
(cons (car numbers) nonneg)
neg))
((< (car numbers) 0) ; 3 other arg. for loop
(loop (cdr numbers)
nonneg
(cons (car numbers) neg)))))
=> ((6 1 3) (-5 -2))

CSI2120: Programming Paradigms


Store State in a Global with set!

(define num-calls 0)
=> num-calls
(define kons
(lambda (x y)
(set! num-calls (+ num-calls 1))
(cons x y)))
=> kons
(kons 3 5)
=> (3 . 5)
(display num-calls)
1

CSI2120: Programming Paradigms


Types Characters

• Character constants:
#\a #\A #\( #\space #\newline

• Predicats:
– Mostly obvious
(char? obj) tests whether obj is a character.
(char-alphabetic? char)
(char-numeric? char)
(char-whitespace? char)
(char-upper-case? char)
(char-lower-case? char)

CSI2120: Programming Paradigms


Character Comparisons

• Boolean functions for characters:


(char=? char_1 char_2)
(char<? char_1 char_2)
(char>? char_1 char_2)
(char<=? char_1 char_2)
(char>=? char_1 char_2)
• Corresponding case insensitive functions with the ending
–ci exist.
(char=? #\a #\A)
=> #f
(char-ci=? #\a #\A)
=> #t

CSI2120: Programming Paradigms


Character Conversions

• Character to ascii
(char->integer #\a)
97
• Character to ascii and back
(integer->char (1+ (char->integer #\a)))
#\b

CSI2120: Programming Paradigms


Strings

• String constants are written in double quotation marks


"Hello"
• Boolean comparison functions for strings
(string=? string_1 string_2)
(string<? string_1 string_2)
(string>? string_1 string_2)
(string<=? string_1 string_2)
(string>=? string_1 string_2)
• Examples
(string=? "Foo" "foo")
#f
(string-ci=? "Foo" "foo")
#t

CSI2120: Programming Paradigms


More String Functions

(string-length "Hello")
=> 5
(string->list "Hello")
=> (#\H #\e #\l #\l #\o)
(substring "computer" 3 6)
=> "put"

CSI2120: Programming Paradigms


ABC
(define (abc-count char k)
(if (char-alphabetic? char)
(let ((base (if (char-upper-case? char)
(char->integer #\A)
(char->integer #\a))))
(integer->char
(+ base
(modulo
(+ k
(- (char->integer char) base))
26))))
char)) ; apply let to char
=> abc-count
(abc-count #\b 5)
#\g

CSI2120: Programming Paradigms


Summary

• Local Binding, let-bound Variables


– let for local variable binding
– let* for sequential local varible binding
– letrec for local variable binding allowing recursions
• Named let-bounds
• Characters
• Strings

CSI2120: Programming Paradigms

You might also like