(defvar x 1)
(defvar y (+ x 2))
x
y
1 31 2error(defvar xyz 173)
abc
error173possibly abc(deffun (sum x y z)
(+ x (+ y z)))
(sum 2 1 3)
65(deffun (addy x)
(defvar y 1)
(+ x y))
(addy 2)
3error(defvar y 1)
(deffun (addy x)
(+ x y))
(addy 2)
3error [IsolatedFun](deffun (addy x)
(+ x y))
(defvar y 1)
(addy 2)
error [DeepClosure, IsolatedFun,
NestedDef]32(defvar y 100)
(deffun (addy x)
(defvar y 200)
(+ x y))
(addy 2)
202102error(defvar y 100)
(deffun (addy x)
(defvar y 200)
(+ x y))
(+ (addy 2) y)
302402 [FlatEnv]error(deffun (addy x)
(defvar y 200)
(+ x y))
(+ (addy 2) y)
error402 [FlatEnv](defvar x 1)
(deffun (main)
(defvar x 2)
(deffun (get-x) x)
(get-x))
(main)
2error [IsolatedFun]13(defvar x 1)
(deffun (get-x) x)
(deffun (main)
(defvar x 2)
(get-x))
(main)
12 [FlatEnv]error [IsolatedFun](defvar x 1)
(deffun (main)
(defvar x 2)
(get-x))
(deffun (get-x) x)
(main)
1error [DeepClosure, IsolatedFun,
NestedDef]2 [FlatEnv](defvar x 1)
(deffun (main)
(deffun (get-x) x)
(defvar x 2)
(get-x))
(main)
21 [NestedDef](defvar x 1)
(defvar x 2)
x
2 [DefOrSet, NestedDef]error1(deffun (f x x)
(+ x x))
(f 1 2)
error32(/ 1 0)
error10(defvar x (/ 1 0))
42
error42 [Lazy](deffun (f x)
42)
(f (/ 1 0))
error42 [Lazy](defvar x 1)
(defvar y (+ x 2))
x
y
1 3error(defvar y (+ x 2))
(defvar x 1)
x
y
1 3 [Lazy]error(deffun (getx)
x)
(defvar x 12)
(defvar y (getx))
y
12error [DeepClosure, IsolatedFun,
NestedDef](deffun (getx)
x)
(defvar y (getx))
(defvar x 12)
y
error12 [Lazy](defvar x 2)
(deffun (main)
(deffun (getx)
x)
(defvar y (getx))
(defvar x 3)
y)
(main)
2 [DefOrSet, NestedDef]error3 [Lazy](defvar x 0)
(defvar y x)
(defvar x 2)
x
y
error2 0 [DefOrSet, NestedDef]2 2(deffun (foo)
y)
(defvar y 1)
(foo)
1error [DeepClosure, IsolatedFun,
NestedDef](defvar x 1)
(deffun (gety)
(defvar y x)
(defvar x 2)
y)
(gety)
error1 [DefOrSet, NestedDef]2 [Lazy](defvar rent 100)
(set! rent (* 100 2))
rent
2002000(set! foobar 2)
foobar
error2 [DefOrSet](defvar x 12)
(defvar y x)
(set! x 0)
x
y
0 120 0 [DefByRef]errordepends on implementation(defvar m 40)
(defvar n m)
(set! n 22)
m
n
40 2240 11(defvar x 1)
(defvar y (+ x 100))
(set! x 2)
x
y
2 1012 102(defvar x 12)
(deffun (f)
(set! x 0))
(f)
x
012 [DeepClosure, DefOrSet]error [IsolatedFun](defvar x 12)
(deffun (f x)
(set! x 0))
(f x)
x
120 [CallByRef, FlatEnv]error(defvar x 1)
(deffun (getx)
x)
(deffun (setx new-val)
(set! x new-val))
(getx)
(setx 2)
(getx)
1 21 1 [DeepClosure, DefOrSet]1 2 1(defvar x 12)
(deffun (set-and-return y)
(set! y 0)
x)
(set-and-return x)
12error [IsolatedFun]0 [CallByRef]23(defvar x 12)
(deffun (set-and-return y)
(set! x 0)
y)
(set-and-return x)
x
12 012 12 [DeepClosure, DefOrSet]error [IsolatedFun]0 0 [CallByRef]12(defvar n 3)
(deffun (f x)
(+ x 1))
(mvec n (f n))
#(3 4)error#(n (f n))(mvec (mvec 1 2) 3)
#(#(1 2) 3)error#(#(1 2) #(3))#(#(3 1) 2)(mvec (mvec 123) (mvec 4 5))
#(#(123) #(4 5))#('#(123) '#(4 5))error#('#(231) '#(4 5))(defvar v (mvec 1 2 3 4))
(vec-len v)
4error(vec-len (mvec 4 (mvec 5 6)))
231error(defvar v (mvec (mvec 10 20) (mvec 30 40)))
(vec-ref (vec-ref v 1) 0)
301020error1(defvar x (mvec 2 3))
(vec-set! x 0 100)
x
#(100 3)100 3(defvar x (mvec 2))
(vec-set! x 0 100)
x
#(100)100(defvar mv (mvec 4 5))
(left mv)
4error(defvar m (mvec 1 2))
(vec-set! m 1 (mvec 3 4))
(vec-ref m 2)
error24#(3 4)3(defvar x (mvec 100))
(defvar y x)
(vec-set! x 0 200)
y
#(100) [DefsCopyStructs]#(200)#(300)errorvectors2::alias_with_funcall
(defvar x (mvec 1 0))
(deffun (f y)
(vec-set! y 0 173))
(f x)
x
#(173 0)#(1 0) [CallsCopyStructs](defvar x 3)
(defvar v (mvec 1 2 x))
(set! x 4)
v
#(1 2 3)#(1 2 4) [StructByRef]error(defvar x (mvec 3))
(defvar v (mvec 1 2 x))
(vec-set! x 0 4)
v
#(1 2 #(4))#(1 2 #(3)) [DefsCopyStructs,
StructsCopyStructs]error(defvar x (mvec 3))
(defvar v (mvec 1 2 x))
(set! x 4)
v
error#(1 2 #(3))#(1 2 #(4))#(1 2 3)(defvar v (mvec 1 2 3))
(defvar vv (mpair v v))
(vec-set! (right vv) 0 100)
(left vv)
#(100 2 3)#(1 2 3) [DefsCopyStructs]error(defvar x (mvec 1 0 2))
(vec-set! x 1 x)
(vec-len x)
3error [NoCircularity]run out of memory or time.+inf(defvar v (mpair 10 7))
(set-left! v v)
(set-right! v 42)
(right (left (left v)))
42error [NoCircularity,
StructsCopyStructs]107(defvar x 12)
(deffun (f x)
(set! x 0))
(f x)
x
120 [CallByRef, FlatEnv](defvar x 5)
(deffun (set1 x y)
(set! x y))
(deffun (set2 a y)
(set! x y))
(set1 x 6)
x
(set2 x 7)
x
5 75 5 [DeepClosure, DefOrSet]6 7 [CallByRef, FlatEnv]error(defvar x (mvec 1 7 3))
(defvar pr (mpair x x))
(vec-set! (right pr) 0 100)
pr
#(#(100 7 3) #(100 7 3))#(#(1 7 3) #(100 7 3))
[DefsCopyStructs](defvar x (mvec 2 3))
(set-right! x x)
(set-left! x x)
x
#0='#(#0# #0#) ;; an mpair whose elements refer back to itself#(#(2 3) #(2 3))#(#(2 #(2 3)) #(2 3))
[StructsCopyStructs]error [NoCircularity](deffun (get) 42)
(defvar f get)
(defvar g f)
(g)
42error [FunNotVal](deffun (twice f x)
(f (f x)))
(deffun (double x)
(+ x x))
(twice double 1)
4error [FunNotVal]28(deffun (add1 x) (+ x 1))
(deffun (g) add1)
(defvar f (g))
(f 100)
101error [FunNotVal, IsolatedFun](deffun (add1 n)
(+ n 1))
(defvar v (mvec add1))
((vec-ref v 0) 2)
3error [FunNotVal]21(deffun (make-getter)
(defvar x 1)
(deffun (get-x) x)
get-x)
(defvar get-x (make-getter))
(get-x)
1error [FunNotVal, IsolatedFun](deffun (make-getter x)
(deffun (get-x) x)
get-x)
(defvar get-a (make-getter 1))
(defvar get-b (make-getter 2))
(get-a)
(get-b)
1 2(deffun (make-addy y)
(deffun (addy x)
(+ x y))
addy)
(defvar f (make-addy 10))
(defvar g (make-addy 50))
(f 2)
(g 2)
12 52error [FunNotVal, IsolatedFun]12 12(defvar x 1)
(deffun (make-f)
(deffun (addx y)
(+ x y))
addx)
(defvar f (make-f))
(set! x 2)
(f x)
43 [DeepClosure]error [FunNotVal, IsolatedFun]2(deffun (make-counter count)
(deffun (counter)
(set! count (+ count 1))
count)
counter)
(defvar f (make-counter 0))
(defvar g (make-counter 0))
(f)
(f)
(g)
1 2 11 2 3 [FlatEnv]1 1 1 [DeepClosure]1 1 22 3 23 1 2error [DefOrSet, FunNotVal,
IsolatedFun](deffun (f a b) a + b)
(f 5 10)
15error [FunNotVal]105 + 10(deffun (f x)
(lambda (y) (+ x y)))
(defvar x 0)
((f 2) 1)
3error [FunNotVal, IsolatedFun]12(defvar x 1)
(defvar f
(lambda (y)
(+ x y)))
(set! x 2)
(f x)
43 [DeepClosure]error [IsolatedFun]lambda(deffun (make-counter count)
(lambda ()
(set! count (+ count 1))
count))
(defvar f (make-counter 0))
(defvar g (make-counter 0))
(f)
(f)
(g)
1 2 11 2 3 [FlatEnv]