Principles of Programming

Languages Practice session 5

מורכבים • טיפוסים•Abstract Data Typesלעבודה • 3הכנה

Pair שהוא טיפוס מכל ערכים של סדור זוג מייצג

:בנאיcons

Type: [T1 * T2 -> PAIR(T1, T2)]

"- ה Pair: ‘(a . b)של" toStringצורת

:סלקטוריםcar,cdr

Type: [PAIR(T1, T2) -> T1]

Type: [PAIR(T1, T2) -> T2]

Pair> (cons 1 2)' (2 . 1)

>(cons 1 (cons 2 (lambda () (+ 1 2))))'(1 2 . #<procedure>) (1 . (2 . #<procedure>))

>(cons (car (cons 1 2)) (cdr (cons 3 4)))'(4 . 1)

>(cons (cons 1 2) (cons 1 3))((3 . 1) 2 . 1)'

Pair>(define c (cons 1 (cons 'cat (cons 3 (cons 4 5))))) > c '(1 cat 3 4 . 5)

> (cdddr c) '(4 . 5)> (cdr (cdr (cdr c))) '(4 . 5)

> (cadr c) 'cat > (car (cdr c)) 'cat

List שהוא טיפוס מכל ערכים של סדורה סדרה מייצגת : ו ראשון איבר של זוג היא רשימה רקורסיבית רשימתהגדרה

. , האחרון האיבר היא הריקה הרשימה כאשר האיברים שאר : בנאים cons, listשני הומוגנית רשימה בין הטרוגנית List(T)מבחינים ורשימה

LISTcons: Type: [T * List(T) -> List(T)]

Type: [T * LIST -> LIST] Type: [T1 * List (T2) -> LIST], T1≠T2

list: Type: [T * T * ... * T -> List(T)] Type: [T1 * T2 * ... * Tn -> LIST]

List :סלקטוריםcar,cdr

car: Type: [LIST(T) -> T] Type: [LIST -> T]

cdr: Type: [LIST(T) -> LIST(T)] Type: [LIST -> LIST]

list? , null? , equal? , append , length

List> (define a (list 3 4 5))> a(5 4 3)'

> (cons 1 a) '(1 3 4 5)

> (list) '()

> (list (list 1 2) 1 2) '((1 2) 1 2)

List> (define L2 (list 1 (list 2 3) 6)) > L2 '(1 (2 3) 6)

> (car L2) 1

> (cdddr L2) '()

> (list? (cons (list 2 3) 4))#f

> (list? (cons 4 (list 2 3)))#t

List

פרוצדורת לכתוב רשימות appendרוצים שתי שמקבלת , ופרוצדורת אחת לרשימה אותן flattenומחברת

. " " אותה משטחת ו רשימה שמקבלת

> (append (list 1 2 3) (list 4 5 6)) '(1 2 3 4 5 6) > (flatten (list 1 2 (list 3 (list) 4) 5 (list 6))) '(1 2 3 4 5 6)

List

Signature: append (list1, list2) Purpose: return a list which appends the

arguments lists, from left to right. Type: [LIST * LIST -> LIST] (define append (lambda (x y)

(if (null? x) y

(cons (car x) (append (cdr x) y)))))

List

Signature: flatten(list) Purpose: return a list of all argument

"leaves". Type: [LIST -> LIST] (define flatten (lambda (x) (cond ((null? x) '()) ((not (pair? x)) (list x)) (else (append (flatten (car x)) (flatten (cdr x)))))))