smoltutor

scope1::warmup_defvar

SMoL JavaScript Python 
(defvar x 1)
(defvar y (+ x 2))
x
y
 
let x = 1;
let y = x + 2;
console.log(x);
console.log(y);
 
x = 1
y = x + 2
print(x)
print(y)

scope1::warmup_error

SMoL JavaScript Python 
(defvar xyz 173)
abc
 
let xyz = 173;
console.log(abc);
 
xyz = 173
print(abc)

scope1::warmup_fun

SMoL JavaScript Python 
(deffun (sum x y z)
  (+ x (+ y z)))
(sum 2 1 3)
 
function sum(x, y, z) {
  return x + (y + z);
}
console.log(sum(2, 1, 3));
 
def sum(x, y, z):
    return x + (y + z)
print(sum(2, 1, 3))

scope1::local_def_is_possible

SMoL JavaScript Python 
(deffun (addy x)
  (defvar y 1)
  (+ x y))
(addy 2)
 
function addy(x) {
  let y = 1;
  return x + y;
}
console.log(addy(2));
 
def addy(x):
    y = 1
    return x + y
print(addy(2))

scope1::refer_global_is_possible

SMoL JavaScript Python 
(defvar y 1)
(deffun (addy x)
  (+ x y))
(addy 2)
 
let y = 1;
function addy(x) {
  return x + y;
}
console.log(addy(2));
 
y = 1
def addy(x):
    return x + y
print(addy(2))

scope1::defs_are_recursive

SMoL JavaScript Python 
(deffun (addy x)
  (+ x y))
(defvar y 1)
(addy 2)
 
function addy(x) {
  return x + y;
}
let y = 1;
console.log(addy(2));
 
def addy(x):
    return x + y
y = 1
print(addy(2))

scope1::shadow_or_overwrite

SMoL JavaScript Python 
(defvar y 100)
(deffun (addy x)
  (defvar y 200)
  (+ x y))
(addy 2)
 
let y = 100;
function addy(x) {
  let y = 200;
  return x + y;
}
console.log(addy(2));
 
y = 100
def addy(x):
    y = 200
    return x + y
print(addy(2))

scope1::shadow_rather_than_overwrite

SMoL JavaScript Python 
(defvar y 100)
(deffun (addy x)
  (defvar y 200)
  (+ x y))
(+ (addy 2) y)
 
let y = 100;
function addy(x) {
  let y = 200;
  return x + y;
}
console.log(addy(2) + y);
 
y = 100
def addy(x):
    y = 200
    return x + y
print(addy(2) + y)

scope1::error_when_refer_to_undefined

SMoL JavaScript Python 
(deffun (addy x)
  (defvar y 200)
  (+ x y))
(+ (addy 2) y)
 
function addy(x) {
  let y = 200;
  return x + y;
}
console.log(addy(2) + y);
 
def addy(x):
    y = 200
    return x + y
print(addy(2) + y)

scope1::what_is_x_1

SMoL JavaScript Python 
(defvar x 1)
(deffun (main)
  (defvar x 2)
  (deffun (get-x) x)
  (get-x))

(main)
 
let x = 1;
function main() {
  let x = 2;
  function getX() {
    return x;
  }
  return getX();
}
console.log(main());
 
x = 1
def main():
    x = 2
    def get_x():
        return x
    return get_x()
print(main())

scope1::what_is_x_2

SMoL JavaScript Python 
(defvar x 1)
(deffun (get-x) x)

(deffun (main)
  (defvar x 2)
  (get-x))
(main)
 
let x = 1;
function getX() {
  return x;
}
function main() {
  let x = 2;
  return getX();
}
console.log(main());
 
x = 1
def get_x():
    return x
def main():
    x = 2
    return get_x()
print(main())

scope1::what_is_x_3

SMoL JavaScript Python 
(defvar x 1)
(deffun (main)
  (defvar x 2)
  (get-x))
(deffun (get-x) x)

(main)
 
let x = 1;
function main() {
  let x = 2;
  return getX();
}
function getX() {
  return x;
}
console.log(main());
 
x = 1
def main():
    x = 2
    return get_x()
def get_x():
    return x
print(main())

scope1::what_is_x_4

SMoL JavaScript Python 
(defvar x 1)
(deffun (main)
  (deffun (get-x) x)
  (defvar x 2)
  (get-x))

(main)
 
let x = 1;
function main() {
  function getX() {
    return x;
  }
  let x = 2;
  return getX();
}
console.log(main());
 
x = 1
def main():
    def get_x():
        return x
    x = 2
    return get_x()
print(main())

scope1::define_twice_global

SMoL JavaScript Python 
(defvar x 1)
(defvar x 2)
x
 
let x = 1;
let x = 2;
console.log(x);
 
x = 1
x = 2
print(x)

scope1::define_twice_arg

SMoL JavaScript Python 
(deffun (f x x)
  (+ x x))
(f 1 2)
 
function f(x, x) {
  return x + x;
}
console.log(f(1, 2));
 
def f(x, x):
    return x + x
print(f(1, 2))

scope2::warmup_error

SMoL JavaScript Python 
(/ 1 0)
 
console.log(1 / 0);
 
print(1 / 0)

scope2::defvar_binding_cause_evaluation

SMoL JavaScript Python 
(defvar x (/ 1 0))
42
 
let x = 1 / 0;
console.log(42);
 
x = 1 / 0
print(42)

scope2::funcall_binding_cause_evaluation

SMoL JavaScript Python 
(deffun (f x)
  42)
(f (/ 1 0))
 
function f(x) {
  return 42;
}
console.log(f(1 / 0));
 
def f(x):
    return 42
print(f(1 / 0))

scope2::good_order

SMoL JavaScript Python 
(defvar x 1)
(defvar y (+ x 2))
x
y
 
let x = 1;
let y = x + 2;
console.log(x);
console.log(y);
 
x = 1
y = x + 2
print(x)
print(y)

scope2::bad_order

SMoL JavaScript Python 
(defvar y (+ x 2))
(defvar x 1)
x
y
 
let y = x + 2;
let x = 1;
console.log(x);
console.log(y);
 
y = x + 2
x = 1
print(x)
print(y)

scope2::order_and_funcall_warmup

SMoL JavaScript Python 
(deffun (getx)
  x)
(defvar x 12)
(defvar y (getx))
y
 
function getx() {
  return x;
}
let x = 12;
let y = getx();
console.log(y);
 
def getx():
    return x
x = 12
y = getx()
print(y)

scope2::order_and_funcall_1

SMoL JavaScript Python 
(deffun (getx)
  x)
(defvar y (getx))
(defvar x 12)
y
 
function getx() {
  return x;
}
let y = getx();
let x = 12;
console.log(y);
 
def getx():
    return x
y = getx()
x = 12
print(y)

scope2::order_and_funcall_2

SMoL JavaScript Python 
(defvar x 2)
(deffun (main)
  (deffun (getx)
    x)
  (defvar y (getx))
  (defvar x 3)
  y)

(main)
 
let x = 2;
function main() {
  function getx() {
    return x;
  }
  let y = getx();
  let x = 3;
  return y;
}
console.log(main());
 
x = 2
def main():
    def getx():
        return x
    y = getx()
    x = 3
    return y
print(main())

mut-vars1::scope_review_1

SMoL JavaScript Python 
(defvar x 0)
(defvar y x)
(defvar x 2)
x
y
 
let x = 0;
let y = x;
let x = 2;
console.log(x);
console.log(y);
 
x = 0
y = x
x = 2
print(x)
print(y)

mut-vars1::scope_review_2

SMoL JavaScript Python 
(deffun (foo)
  y)
(defvar y 1)
(foo)
 
function foo() {
  return y;
}
let y = 1;
console.log(foo());
 
def foo():
    return y
y = 1
print(foo())

mut-vars1::scope_review_3

SMoL JavaScript Python 
(defvar x 1)
(deffun (gety)
  (defvar y x)
  (defvar x 2)
  y)
(gety)
 
let x = 1;
function gety() {
  let y = x;
  let x = 2;
  return y;
}
console.log(gety());
 
x = 1
def gety():
    y = x
    x = 2
    return y
print(gety())

mut-vars2::warmup_setbang

SMoL JavaScript Python 
(defvar rent 100)
(set! rent (* 100 2))
rent
 
let rent = 100;
rent = 100 * 2;
console.log(rent);
 
rent = 100
rent = 100 * 2
print(rent)

mut-vars2::update_undefined

SMoL JavaScript Python 
(set! foobar 2)
foobar
 
foobar = 2;
console.log(foobar);
 
foobar = 2
print(foobar)

mut-vars2::not_aliased_by_defvar_1

SMoL JavaScript Python 
(defvar x 12)
(defvar y x)
(set! x 0)
x
y
 
let x = 12;
let y = x;
x = 0;
console.log(x);
console.log(y);
 
x = 12
y = x
x = 0
print(x)
print(y)

mut-vars2::not_aliased_by_defvar_2

SMoL JavaScript Python 
(defvar m 40)
(defvar n m)
(set! n 22)
m
n
 
let m = 40;
let n = m;
n = 22;
console.log(m);
console.log(n);
 
m = 40
n = m
n = 22
print(m)
print(n)

mut-vars2::not_aliased_by_defvar_3

SMoL JavaScript Python 
(defvar x 1)
(defvar y (+ x 100))
(set! x 2)
x
y
 
let x = 1;
let y = x + 100;
x = 2;
console.log(x);
console.log(y);
 
x = 1
y = x + 100
x = 2
print(x)
print(y)

mut-vars2::remote_update_possible

SMoL JavaScript Python 
(defvar x 12)
(deffun (f)
  (set! x 0))
(f)
x
 
let x = 12;
function f() {
  return x = 0;
}
console.log(f());
console.log(x);
 
x = 12
def f():
    global x
    return (x := 0)
print(f())
print(x)

mut-vars2::not_aliased_by_funarg_1

SMoL JavaScript Python 
(defvar x 12)
(deffun (f x)
  (set! x 0))
(f x)
x
 
let x = 12;
function f(x) {
  return x = 0;
}
console.log(f(x));
console.log(x);
 
x = 12
def f(x):
    return (x := 0)
print(f(x))
print(x)

mut-vars2::funs_remember_vars_not_vals

SMoL JavaScript Python 
(defvar x 1)
(deffun (getx)
  x)
(deffun (setx new-val)
  (set! x new-val))
(getx)
(setx 2)
(getx)
 
let x = 1;
function getx() {
  return x;
}
function setx(newVal) {
  return x = newVal;
}
console.log(getx());
console.log(setx(2));
console.log(getx());
 
x = 1
def getx():
    return x
def setx(new_val):
    global x
    return (x := new_val)
print(getx())
print(setx(2))
print(getx())

mut-vars2::not_aliased_by_funarg_2

SMoL JavaScript Python 
(defvar x 12)
(deffun (set-and-return y)
  (set! y 0)
  x)
(set-and-return x)
 
let x = 12;
function setAndReturn(y) {
  y = 0;
  return x;
}
console.log(setAndReturn(x));
 
x = 12
def set_and_return(y):
    y = 0
    return x
print(set_and_return(x))

mut-vars2::not_aliased_by_funarg_3

SMoL JavaScript Python 
(defvar x 12)
(deffun (set-and-return y)
  (set! x 0)
  y)
(set-and-return x)
x
 
let x = 12;
function setAndReturn(y) {
  x = 0;
  return y;
}
console.log(setAndReturn(x));
console.log(x);
 
x = 12
def set_and_return(y):
    global x
    x = 0
    return y
print(set_and_return(x))
print(x)

vectors1::warmup_mvec

SMoL JavaScript Python 
(defvar n 3)
(deffun (f x)
  (+ x 1))
(mvec n (f n))
 
let n = 3;
function f(x) {
  return x + 1;
}
console.log([ n, f(n) ]);
 
n = 3
def f(x):
    return x + 1
print([n, f(n)])

vectors1::vec_hetero

SMoL JavaScript Python 
(mvec (mvec 1 2) 3)
 
console.log([ [ 1, 2 ], 3 ]);
 
print([[1, 2], 3])

vectors1::vec_print

SMoL JavaScript Python 
(mvec (mvec 123) (mvec 4 5))
 
console.log([ [ 123 ], [ 4, 5 ] ]);
 
print([[123], [4, 5]])

vectors1::warmup_veclen

SMoL JavaScript Python 
(defvar v (mvec 1 2 3 4))
(vec-len v)
 
let v = [ 1, 2, 3, 4 ];
console.log(v.length);
 
v = [1, 2, 3, 4]
print(len(v))

vectors1::veclen_nested

SMoL JavaScript Python 
(vec-len (mvec 4 (mvec 5 6)))
 
console.log([ 4, [ 5, 6 ] ].length);
 
print(len([4, [5, 6]]))

vectors1::warmup_vecref

SMoL JavaScript Python 
(defvar v (mvec (mvec 10 20) (mvec 30 40)))
(vec-ref (vec-ref v 1) 0)
 
let v = [ [ 10, 20 ], [ 30, 40 ] ];
console.log(v[1][0]);
 
v = [[10, 20], [30, 40]]
print(v[1][0])

vectors1::warmup_vecset_1

SMoL JavaScript Python 
(defvar x (mvec 2 3))
(vec-set! x 0 100)
x
 
let x = [ 2, 3 ];
x[0] = 100;
console.log(x);
 
x = [2, 3]
x[0] = 100
print(x)

vectors1::warmup_vecset_2

SMoL JavaScript Python 
(defvar x (mvec 2))
(vec-set! x 0 100)
x
 
let x = [ 2 ];
x[0] = 100;
console.log(x);
 
x = [2]
x[0] = 100
print(x)

vectors1::mpairs_are_mvec

SMoL JavaScript Python 
(defvar mv (mvec 4 5))
(left mv)
 
let mv = [ 4, 5 ];
console.log(mv[0]);
 
mv = [4, 5]
print(mv[0])

vectors1::vector_not_flatten

SMoL JavaScript Python 
(defvar m (mvec 1 2))
(vec-set! m 1 (mvec 3 4))
(vec-ref m 2)
 
let m = [ 1, 2 ];
m[1] = [ 3, 4 ];
console.log(m[2]);
 
m = [1, 2]
m[1] = [3, 4]
print(m[2])

vectors2::alias_with_defvar

SMoL JavaScript Python 
(defvar x (mvec 100))
(defvar y x)
(vec-set! x 0 200)
y
 
let x = [ 100 ];
let y = x;
x[0] = 200;
console.log(y);
 
x = [100]
y = x
x[0] = 200
print(y)

vectors2::alias_with_funcall

SMoL JavaScript Python 
(defvar x (mvec 1 0))
(deffun (f y)
  (vec-set! y 0 173))
(f x)
x
 
let x = [ 1, 0 ];
function f(y) {
  return y[0] = 173;
}
console.log(f(x));
console.log(x);
 
x = [1, 0]
def f(y):
    return y.__setitem__(0, 173)
print(f(x))
print(x)

vectors2::alias_var_in_mvec

SMoL JavaScript Python 
(defvar x 3)
(defvar v (mvec 1 2 x))
(set! x 4)
v
 
let x = 3;
let v = [ 1, 2, x ];
x = 4;
console.log(v);
 
x = 3
v = [1, 2, x]
x = 4
print(v)

vectors2::alias_mvec_in_mvec

SMoL JavaScript Python 
(defvar x (mvec 3))
(defvar v (mvec 1 2 x))
(vec-set! x 0 4)
v
 
let x = [ 3 ];
let v = [ 1, 2, x ];
x[0] = 4;
console.log(v);
 
x = [3]
v = [1, 2, x]
x[0] = 4
print(v)

vectors2::alias_mvec_in_mvec_trick

SMoL JavaScript Python 
(defvar x (mvec 3))
(defvar v (mvec 1 2 x))
(set! x 4)
v
 
let x = [ 3 ];
let v = [ 1, 2, x ];
x = 4;
console.log(v);
 
x = [3]
v = [1, 2, x]
x = 4
print(v)

vectors2::alias_mvec_in_mpair

SMoL JavaScript Python 
(defvar v (mvec 1 2 3))
(defvar vv (mpair v v))
(vec-set! (right vv) 0 100)
(left vv)
 
let v = [ 1, 2, 3 ];
let vv = [ v, v ];
vv[1][0] = 100;
console.log(vv[0]);
 
v = [1, 2, 3]
vv = [ v, v ]
vv[1][0] = 100
print(vv[0])

vectors2::warmup_circularity

SMoL JavaScript Python 
(defvar x (mvec 1 0 2))
(vec-set! x 1 x)
(vec-len x)
 
let x = [ 1, 0, 2 ];
x[1] = x;
console.log(x.length);
 
x = [1, 0, 2]
x[1] = x
print(len(x))

vectors2::circularity_and_alias

SMoL JavaScript Python 
(defvar v (mpair 10 7))
(set-left! v v)
(set-right! v 42)
(right (left (left v)))
 
let v = [ 10, 7 ];
console.log(v[0]=v);
console.log(v[1]=42);
console.log(v[0][0][1]);
 
v = [ 10, 7 ]
v[0] = v
v[1] = 42
print(((v[0])[0])[1])

lambda1::smol_quiz_var_as_arg

SMoL JavaScript Python 
(defvar x 12)
(deffun (f x)
  (set! x 0))
(f x)
x
 
let x = 12;
function f(x) {
  return x = 0;
}
console.log(f(x));
console.log(x);
 
x = 12
def f(x):
    return (x := 0)
print(f(x))
print(x)

lambda1::smol_quiz_seemingly_alias_a_var

SMoL JavaScript Python 
(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
 
let x = 5;
function set1(x, y) {
  return x = y;
}
function set2(a, y) {
  return x = y;
}
console.log(set1(x, 6));
console.log(x);
console.log(set2(x, 7));
console.log(x);
 
x = 5
def set1(x, y):
    return (x := y)
def set2(a, y):
    global x
    return (x := y)
print(set1(x, 6))
print(x)
print(set2(x, 7))
print(x)

lambda1::smol_quiz_aliasing_mvec_in_mvec

SMoL JavaScript Python 
(defvar x (mvec 1 7 3))
(defvar pr (mpair x x))
(vec-set! (right pr) 0 100)
pr
 
let x = [ 1, 7, 3 ];
let pr = [ x, x ];
pr[1][0] = 100;
console.log(pr);
 
x = [1, 7, 3]
pr = [ x, x ]
pr[1][0] = 100
print(pr)

lambda1::smol_quiz_circularity

SMoL JavaScript Python 
(defvar x (mvec 2 3))
(set-right! x x)
(set-left! x x)
x
 
let x = [ 2, 3 ];
console.log(x[1]=x);
console.log(x[0]=x);
console.log(x);
 
x = [2, 3]
x[1] = x
x[0] = x
print(x)

lambda1::warmup_hof

SMoL JavaScript Python 
(deffun (get) 42)
(defvar f get)
(defvar g f)
(g)
 
function get() {
  return 42;
}
let f = get;
let g = f;
console.log(g());
 
def get():
    return 42
f = get
g = f
print(g())

lambda1::fun_as_parameter

SMoL JavaScript Python 
(deffun (twice f x)
  (f (f x)))
(deffun (double x)
  (+ x x))
(twice double 1)
 
function twice(f, x) {
  return f(f(x));
}
function double(x) {
  return x + x;
}
console.log(twice(double, 1));
 
def twice(f, x):
    return f(f(x))
def double(x):
    return x + x
print(twice(double, 1))

lambda1::fun_as_output

SMoL JavaScript Python 
(deffun (add1 x) (+ x 1))
(deffun (g) add1)
(defvar f (g))
(f 100)
 
function add1(x) {
  return x + 1;
}
function g() {
  return add1;
}
let f = g();
console.log(f(100));
 
def add1(x):
    return x + 1
def g():
    return add1
f = g()
print(f(100))

lambda1::fun_in_vectors

SMoL JavaScript Python 
(deffun (add1 n)
  (+ n 1))
(defvar v (mvec add1))
((vec-ref v 0) 2)
 
function add1(n) {
  return n + 1;
}
let v = [ add1 ];
console.log(v[0](2));
 
def add1(n):
    return n + 1
v = [add1]
print(v[0](2))

lambda2::read_local1

SMoL JavaScript Python 
(deffun (make-getter)
  (defvar x 1)
  (deffun (get-x) x)
  get-x)
(defvar get-x (make-getter))
(get-x)
 
function makeGetter() {
  let x = 1;
  function getX() {
    return x;
  }
  return getX;
}
let getX = makeGetter();
console.log(getX());
 
def make_getter():
    x = 1
    def get_x():
        return x
    return get_x
get_x = make_getter()
print(get_x())

lambda2::read_local2

SMoL JavaScript Python 
(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)
 
function makeGetter(x) {
  function getX() {
    return x;
  }
  return getX;
}
let getA = makeGetter(1);
let getB = makeGetter(2);
console.log(getA());
console.log(getB());
 
def make_getter(x):
    def get_x():
        return x
    return get_x
get_a = make_getter(1)
get_b = make_getter(2)
print(get_a())
print(get_b())

lambda2::fun_ref_env

SMoL JavaScript Python 
(deffun (make-addy y)
  (deffun (addy x)
    (+ x y))
  addy)
(defvar f (make-addy 10))
(defvar g (make-addy 50))
(f 2)
(g 2)
 
function makeAddy(y) {
  function addy(x) {
    return x + y;
  }
  return addy;
}
let f = makeAddy(10);
let g = makeAddy(50);
console.log(f(2));
console.log(g(2));
 
def make_addy(y):
    def addy(x):
        return x + y
    return addy
f = make_addy(10)
g = make_addy(50)
print(f(2))
print(g(2))

lambda2::state

SMoL JavaScript Python 
(defvar x 1)
(deffun (make-f)
  (deffun (addx y)
    (+ x y))
  addx)
(defvar f (make-f))
(set! x 2)
(f x)
 
let x = 1;
function makeF() {
  function addx(y) {
    return x + y;
  }
  return addx;
}
let f = makeF();
x = 2;
console.log(f(x));
 
x = 1
def make_f():
    def addx(y):
        return x + y
    return addx
f = make_f()
x = 2
print(f(x))

lambda2::counter

SMoL JavaScript Python 
(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)
 
function makeCounter(count) {
  function counter() {
    count = count + 1;
    return count;
  }
  return counter;
}
let f = makeCounter(0);
let g = makeCounter(0);
console.log(f());
console.log(f());
console.log(g());
 
def make_counter(count):
    def counter():
        nonlocal count
        count = count + 1
        return count
    return counter
f = make_counter(0)
g = make_counter(0)
print(f())
print(f())
print(g())

lambda2::syntax_pitfall

SMoL JavaScript Python 
(deffun (f a b) a + b)
(f 5 10)
 
function f(a, b) {
  a;
  (function(x, y) { return x + y; });
  return b;
}
console.log(f(5, 10));
 
def f(a, b):
    a
    +
    return b
print(f(5, 10))

lambda3::curry_lambda

SMoL JavaScript Python 
(deffun (f x)
  (lambda (y) (+ x y)))
(defvar x 0)
((f 2) 1)
 
function f(x) {
  return function (y) {
    return x + y;
  };
}
let x = 0;
console.log(f(2)(1));
 
def f(x):
    return lambda y: x + y
x = 0
print(f(2)(1))

lambda3::lambda_remembers_env

SMoL JavaScript Python 
(defvar x 1)
(defvar f
  (lambda (y)
    (+ x y)))
(set! x 2)
(f x)
 
let x = 1;
let f = function (y) {
  return x + y;
};
x = 2;
console.log(f(x));
 
x = 1
f = lambda y: x + y
x = 2
print(f(x))

lambda3::counter_lambda

SMoL JavaScript Python 
(deffun (make-counter count)
  (lambda ()
    (set! count (+ count 1))
    count))
(defvar f (make-counter 0))
(defvar g (make-counter 0))

(f)
(f)
(g)
 
function makeCounter(count) {
  return function () {
    count = count + 1;
    return count;
  };
}
let f = makeCounter(0);
let g = makeCounter(0);
console.log(f());
console.log(f());
console.log(g());
 
def make_counter(count):
    return lambda: ("WARNING: the translation might be inaccurate", (count := count + 1, count)[-1])[-1]
f = make_counter(0)
g = make_counter(0)
print(f())
print(f())
print(g())
This site is open source. Improve this page.