138 lines
2.8 KiB
Plaintext
138 lines
2.8 KiB
Plaintext
Recursion on:
|
|
-List - empty list?
|
|
\ - on cdr of list
|
|
-number - nr. is zero?
|
|
\ - on (n-1)
|
|
|
|
>(load "file.txt")
|
|
>....
|
|
|
|
Local Definitions:
|
|
-Let p has a list of bindings and a body
|
|
(let ( ( a 1) } Bindings
|
|
( b 3) ) }
|
|
(+ a b ) ) } Body
|
|
=> 5
|
|
a => ErrorL var. a is not bound
|
|
b=> 4 -- b -- 4 --
|
|
|
|
-let makes its binding in ||
|
|
(define x 'a)
|
|
(define y 'b)
|
|
(list x y) => (a b)
|
|
(let ( (x y)
|
|
(y x) ) circle on y/x
|
|
(list x y) ) => (b a)
|
|
|
|
(let ((x 1)
|
|
(y ( + x 1))
|
|
(list x y))
|
|
=> Error: var. x is not bound
|
|
|
|
Let n -This is exactly like let, but does the binding sequentially
|
|
(let* ( (x 1))
|
|
(y ( + x 1))
|
|
(list x y))
|
|
|
|
simulate let* :
|
|
(let ((x 1))
|
|
(let ((y (+ x 1)))
|
|
(list x y)))
|
|
=> (1 2)
|
|
|
|
I/O :
|
|
-Read
|
|
-Display
|
|
-Newline
|
|
|
|
-Fct. that asks for a nr.
|
|
(define (ask-nr)
|
|
(display "Enter a nr.: ")
|
|
(let ((n (read)))
|
|
(if (number? n)
|
|
n
|
|
(ask-nr))))
|
|
|
|
Higher-Order Functions:
|
|
-In Scheme fct. is a first-class object - can be passed as an argument, can be returned as a result, can be created dynamically
|
|
-A fct. is a higher-order fct. if it
|
|
- takes another fct. as arg
|
|
\ - returns a fct. as result
|
|
|
|
C:
|
|
|
|
-Map :
|
|
(define (square x ) (* x x))
|
|
(map square '(1 2 3 4))
|
|
=> (1 4 9 16)
|
|
(map + '(1 2 3 '(4 5 6)))
|
|
=> (5 7 9)
|
|
(map (lambda (x) (* 2 x)) '(1 2 3))
|
|
#<procedure>
|
|
=> (2 4 6)
|
|
|
|
-Cong : 0 take f and L, return
|
|
the conj(AND) of applying f on elements in L
|
|
(define (cong f L)
|
|
(cond ((null? L) #t)
|
|
(else (and (f (car L))
|
|
(cong f (cdr L))))))
|
|
|
|
|
|
Ex: (cong number> '(3 | #t 4 '(1 2)))
|
|
=> #f
|
|
|
|
-Filter - take a predicate f and L,
|
|
returns a list with elems. in L
|
|
that satisfy predicate f
|
|
|
|
Ex: (filter number? '(a 4 (1 2) "testing" +))
|
|
(filter (lambada(x) (>= x 0)) '(-2 |3 -1 1 4))
|
|
=> (3 1 4)
|
|
|
|
(define (filter f L)
|
|
(cond ((null? L) '())
|
|
((f (car L)) (cons (car L) (filter f (cdr L))))
|
|
(else (filter f (cdr L)))))
|
|
|
|
Sequencing
|
|
-Begin
|
|
(Login <expa>...<expn>) {expn -> ret.}
|
|
(if (< x 0)
|
|
(begin (display "negative")
|
|
(f x))
|
|
(begin (display "positive")
|
|
(g x)))
|
|
|
|
(define x 1)
|
|
(+ x 1) => 2
|
|
x => 1
|
|
|
|
(define y '(1 2 3))
|
|
(reverse y ) => (3 2 1)
|
|
y => (1 2 3)
|
|
|
|
Functions compute 8 return a result
|
|
They do not alter their input
|
|
|
|
So far, everything is in "pure" functional form (no side-effects)
|
|
|
|
Exceptions:
|
|
-define
|
|
-display
|
|
|
|
Internal Structure of expressions
|
|
-All variables are pointers to values
|
|
-Atom values
|
|
(define x 1) {x->1}
|
|
-List values
|
|
(define y '(1 2 3)) {y->[block(1)] -> [block(2)] -> [block(3)]}
|
|
|
|
Each elem. is cons call
|
|
-pointer to values
|
|
-pointer to next cell
|
|
|
|
(define x '(b c)) {x->[block(b)] -> [block(c)]} -> [block(d)]}
|
|
(define y '(d)) {y->[block(d)]}
|
|
|
|
(define z (append x y)) {z->[block(b)] -> [block(c)] -> [block(d)]} |