EECS345 Programming Languages Concepts

Author: powcoder

Interpreter, Part 2.pdf

@@ -0,0 +1,9 @@
+# EECS345 Programming Languages Concepts
+# 加微信 powcoder
+
+# QQ 1823890830
+
+# Programming Help Add Wechat powcoder
+
+# Email: powcoder@163.com
+

README.md

@@ -0,0 +1,24 @@
+; A function computing the denotational semantics for the value of an expression.
+;  The function uses abstraction for the operand and operator locations in the expression
+;  The abstraction makes the code easier to read and easier to modify should we need to
+;  change expressions between infix, prefix, or postfix notation
+(define M_value_int
+  (lambda (expression)
+    (cond
+      ((number? expression) expression)
+      ((eq? '+ (operator expression)) (+ (M_value_int (operand1 expression)) (M_value_int (operand2 expression))))
+      ((eq? '- (operator expression)) (- (M_value_int (operand1 expression)) (M_value_int (operand2 expression))))
+      ((eq? '* (operator expression)) (* (M_value_int (operand1 expression)) (M_value_int (operand2 expression))))
+      ((eq? '/ (operator expression)) (quotient (M_value_int (operand1 expression)) (M_value_int (operand2 expression))))
+      ((eq? '% (operator expression)) (remainder (M_value_int (operand1 expression)) (M_value_int (operand2 expression))))
+      (else (error 'badoperator "illegal arithmetic expression")))))
+
+; Here is one way to define the abstraction function
+(define operator 
+  (lambda (expression)
+     (cadr expression)
+
+; And here is another equivalent way
+(define operand1 car)
+(define operand2 caddr)
+      

abstraction.scm

@@ -0,0 +1,95 @@
+; Tail recursion
+
+; Accumulator Passing Style
+; Compute the length of a list
+(define len
+  (lambda (lis)
+    (if (null? lis)
+        0
+        (+ 1 (len (cdr lis))))))
+
+(define len-acc
+  (lambda (lis acc)
+    (if (null? lis)
+        acc
+        (len-acc (cdr lis) (+ 1 acc)))))
+
+; sum the numbers in a list
+(define sumnumbers
+  (lambda (lis)
+    (cond
+      ((null? lis) 0)
+      ((number? (car lis)) (+ (car lis) (sumnumbers (cdr lis))))
+      (else (sumnumbers (cdr lis))))))
+
+(define sumnumbers-acc
+  (lambda (lis acc)
+    (cond
+      ((null? lis) acc)
+      ((number? (car lis)) (sumnumbers-acc (cdr lis) (+ (car lis) acc)))
+      (else (sumnumbers-acc (cdr lis) acc)))))
+
+(define sumnumbers
+  (lambda (lis)
+    (sumnumbers-acc lis 0)))
+
+; an accumulator passing version of append
+(define myappend-acc
+  (lambda (l1 l2 acc)
+    (if (null? l1)
+        acc
+        (myappend-acc (cdr l1) l2 (cons (car l1) acc)))))
+
+(define myappend
+  (lambda (l1 l2)
+    (myappend l1 l2 l2)))
+
+; Continuation passing style
+; sum the numbers in a list
+(define sumnumbers-cps
+  (lambda (lis return)
+    (cond
+      ((null? lis) (return 0))
+      ((number? (car lis)) (sumnumbers-cps (cdr lis) (lambda (v) (return (+ (car lis) v)))))
+      (else (sumnumbers-cps (cdr lis) return)))))
+
+; factorial
+(define factorial
+  (lambda (n)
+    (if (zero? n)
+        1
+        (* n (factorial (- n 1))))))
+
+(define factorial-cps
+  (lambda (n return)
+    (if (zero? n)
+        (return 1)
+        (factorial-cps (- n 1) (lambda (v) (return (* n v)))))))
+
+; append
+(define myappend
+  (lambda (l1 l2)
+    (if (null? l1)
+        l2
+        (cons (car l1) (myappend (cdr l1) l2)))))
+
+(define myappend-cps
+  (lambda (l1 l2 return)
+    (if (null? l1)
+        (return l2)
+        (myappend-cps (cdr l1) l2 (lambda (v) (return (cons (car l1) v)))))))
+
+; removeall
+(define removeall
+  (lambda (x lis)
+    (cond
+      ((null? lis) '())
+      ((eq? x (car lis)) (removeall x (cdr lis)))
+      (else (cons (car lis) (removeall x (cdr lis)))))))
+
+(define removeall-cps
+  (lambda (x lis return)
+    (cond
+      ((null? lis) (return '()))
+      ((eq? x (car lis)) (removeall-cps x (cdr lis) return))
+      (else (removeall-cps x (cdr lis) (lambda (v) (return (cons (car lis) v))))))))

cpslecture1.scm

@@ -0,0 +1,70 @@
+; append
+(define myappend
+  (lambda (l1 l2)
+    (if (null? l1)
+        l2
+        (cons (car l1) (myappend (cdr l1) l2)))))
+
+(define myappend-cps
+  (lambda (l1 l2 return)
+    (if (null? l1)
+        (return l2)
+        (myappend-cps (cdr l1) l2 (lambda (v) (return (cons (car l1) v)))))))
+
+; replaces x with y in the list (no sublists)
+
+; reverse
+(define myreverse
+  (lambda (lis)
+    (if (null? lis)
+        '()
+        (myappend (myreverse (cdr lis)) (cons (car lis) '())))))
+
+(define myreverse-cps
+  (lambda (lis return)
+    (if (null? lis)
+        (return '())
+        (myreverse-cps (cdr lis) (lambda (v) (myappend-cps v (cons (car lis) '()) return))))))
+
+; count all the numbers in a list that contains lists
+(define countnums*
+  (lambda (lis)
+    (cond
+      ((null? lis) 0)
+      ((list? (car lis)) (+ (countnums* (car lis)) (countnums* (cdr lis))))
+      ((number? (car lis)) (+ 1 (countnums* (cdr lis))))
+      (else (countnums* (cdr lis))))))
+
+(define countnums*-cps
+  (lambda (lis return)
+    (cond
+      ((null? lis) (return 0))
+      ((list? (car lis)) (countnums*-cps (car lis) (lambda (v1) (countnum*-cps (cdr lis) (lambda (v2) (return (+ v1 v2)))))))
+      ((number? (car lis)) (countnums*-cps (cdr lis) (lambda (v) (return (+ 1 v)))))
+      (else (countnums*-cps (cdr lis) return)))))
+
+; the cps version of split.  call with the initial continution
+; (lambda (v1 v2) (list v1 v2))
+(define split-cps
+  (lambda (lis return)
+    (cond
+      ((null? lis) (return '() '()))
+      ((null? (cdr lis)) (return lis '()))
+      (else (split-cps (cddr lis) (lambda (v1 v2) (return (cons (car lis) v1) (cons (cadr lis) v2))))))))
+
+; removeall*
+(define removeall*-cps
+  (lambda (x lis return)
+    (cond
+      ((null? lis) (return '()))
+      ((list? (car lis)) (removeall*-cps x (car lis) (lambda (v1) (removeall*-cps x (cdr lis) (lambda (v2) (return (cons v1 v2)))))))
+      ((eq? (car lis) x) (removeall*-cps x (cdr lis) return))
+      (else (removeall*-cps x (cdr lis) (lambda (v) (return (cons (car lis) v))))))))
+
+; (flatten '((a) (((b) (c)) d ((e f)))) g))  => (a b c d e f g)
+(define flatten-cps
+  (lambda (lis return)
+    (cond
+      ((null? lis) (return '()))
+      ((list? (car lis)) (flatten-cps (car lis) (lambda (v1) (flatten-cps (cdr lis) (lambda (v2) (myappend-cps v1 v2 return))))))
+      (else (flatten-cps (cdr lis) (lambda (v) (return (cons (car lis) v))))))))

cpslecture2.scm

@@ -0,0 +1,78 @@
+; This is needed if you do not already have call/cc defined in your Scheme implementation
+(define call/cc call-with-current-continuation)
+
+; A multiply that uses tail recursion so we can immediately break
+(define multiply-cps
+  (lambda (lis return break)
+    (cond
+      ((null? lis) (return 1))
+      ((zero? (car lis)) (break 0))
+      (else (multiply-cps (cdr lis) (lambda (v) (return (* (car lis) v))) break)))))
+
+; a multiply that does not use tail recursion but takes in a break continuation
+(define multiply
+  (lambda (lis break)
+    (cond
+      ((null? lis) 1)
+      ((zero? (car lis)) (break 0))
+      (else (* (car lis) (multiply (cdr lis) break))))))
+
+; creates a break continuation that throws away the call stack to this point, and calls multiply with that continuation
+(define goodmult
+  (lambda (lis)
+    (call/cc
+     (lambda (break)
+       (multiply lis break)))))
+
+;; (indexof 'x '(a b x c d e))  ==> 3
+;; (indexof 'x '(a b c d)) ==> -1
+(define indexof-helper
+  (lambda (x lis break)
+    (cond
+      ((null? lis) (break -1))
+      ((eq? x (car lis)) 0)
+      (else (+ 1 (indexof x (cdr lis)))))))
+
+(define indexof
+  (lambda (x lis)
+    (call/cc
+     (lambda (break)
+       (indexof-helper x lis break)))))
+
+
+
+(define mycont (lambda (v) v))
+
+; a replace all that saves the call stack at the top point into mycont so that we can reaccess that call stack anytime
+;  we call mycont
+(define replaceall
+  (lambda (x y lis)
+    (call/cc 
+     (lambda (k)
+       (cond
+         ((null? lis) (begin (set! mycont k) '()))
+         ((eq? x (car lis)) (cons y (replaceall x y (cdr lis))))
+         (else (cons (car lis) (replaceall x y (cdr lis)))))))))
+
+; a crazy version of append that uses the mycont call stack instead of its own!
+(define myappendit
+  (lambda (l1 l2)
+    (if (null? l1)
+        (mycont l2)
+        (cons (car l1) (myappendit (cdr l1) l2)))))
+             
+
+; An even crazier replaceall from the 2nd lecture.  Saves the point part way through the execution of replaceall*
+;  so that if we call mycont, it embeds the input into the location of the first x in the running of replaceall*
+
+(define mycont2 0)
+
+(define replaceall*
+  (lambda (x y lis)
+    (call/cc
+     (lambda (break)
+       (cond
+         ((null? lis) (begin (if (eq? mycont2 0) (set! mycont2 break)) '()))
+         ((eq? x (car lis)) (cons y (replaceall* x y (cdr lis))))
+         ((list? (car lis)) (cons (replaceall* x y (car lis)) (replaceall* x y (cdr lis))))
+         (else (cons (car lis) (replaceall* x y (cdr lis)))))))))