On this page:
1.1 Identity
«id-λ»
«id»
«id-result»
1.2 Dummy value
«dummy-λ»
«dummy»
1.3 Example:   identity applied to identity
«id-id-λ»
«id-id»
«id-id-result»
1.4 False
«false-λ»
«false»
«false-result»
1.5 True
«true-λ»
«true»
«true-result»
1.5.1 Boolean usage example:   if true
«if-true-example-λ»
«if-true-example»
«if-false-example-result»1
1.5.2 Boolean usage example:   if false
«if-false-example-λ»
«if-false-example»
«if-false-example-result»2
1.6 Pairs
«pair-λ»
«pair-failed-attempt-1»
«pair-failed-attempt-2»
«pair»
«pair-result»
«pair-example»
«pair-example-result»
1.6.1 Fst
«fst-λ»
«fst»
1.6.2 Snd
«snd-λ»
«snd»
1.7 Either
1.7.1 Left
«left-λ»
«left»
«appfv»
«left-result»
1.7.2 Right
«right-λ»
«right»
«right-result»
1.8 If
«if-λ-long»
«if-λ»
«if»
«if-result»
1.8.1 Match "either"
«match-either-λ-long»
«match-either-λ»
«match-either»
«match-either-result»
«match-left-example-λ»
«match-left-example»
«match-left-example-result»
«match-right-example-λ»
«match-right-example»
«match-right-example-result»
1.9 Null
«null-λ»
«null»
«null-result»
1.10 Cons
«cons-λ»
«cons»
«cons-result»
1.10.1 Match "list"
«match-null-cons-λ»
«match-null-cons»
1.11 null?
«null?-λ»
«null?»
1.12 Car
«car-λ»
«car»
«car-example»
«car-example-result»
«car-example2»
«car-example2-result»
«car-example3»
«car-example3-result»1
1.13 Cdr
«cdr-λ»
«cdr»
«cdr-example»
«cdr-example-result»
«cdr-example2»
«cdr-example2-result»
«cdr-example2-list-false»
«cdr-example2-list-false-result»
«cdr-example3»
«car-example3-result»2
1.14 Zero
«zero-λ»
«zero»
1.15 Not
«not-λ»
«not»
1.16 And
«and-λ»
«and»
«and-example-ff»
«and-example-ft»
«and-example-tf»
«and-example-tt»
1.17 Or
«or-λ»
«or»
«or-example-ff»
«or-example-ft»
«or-example-tf»
«or-example-tt»
1.18 Equal bools
«eqbool-λ»
«eqbool»
«eqbool-example-ff»
«eqbool-example-ft»
«eqbool-example-tf»
«eqbool-example-tt»
1.19 Z combinator
«Z-λ»
«half-Z-λ»
«Z»
«half-Z»
1.20 Equality of lists
«eqlist-λ»
«eqlist-noZ»
«eqlist»
«eqlist-bool»
«eqlist-list-bool»
«eqlist-examples»
1.21 Associative lists
«assoc-λ»
«assoc-noZ»
«assoc»
«assoc-example-letter-a»
«assoc-example-letter-b»
«assoc-example-k»
«assoc-example-other-k»
«assoc-example-kv»
«assoc-example-other-kv»
«assoc-example-env»
«assoc-example»
1.22 environment-manipulation functions
«bit-0»
«bit-1»
«null-bits»
«cons-bits»
«null-bytes»
«cons-bytes»
«cons-k-v»
«env-null»
«env-push»
«env-ref»
1.23 todo
«TODO»
«todo-lam-impl»
«*»

1 Tests and examples for envlang/tiny🔗ℹ

1.1 Identity🔗ℹ

(λ (x) x)

«id» ::=

( env env args args)

( #f env args args)

1.2 Dummy value🔗ℹ

1.3 Example: identity applied to identity🔗ℹ

(@ «id» env «id»)

1.4 False🔗ℹ

a.k.a second-of-two

(λ (if-true) (λ (if-false) if-false))

( env env args ( args env args args))

( #f env args ( args env args args))

1.5 True🔗ℹ

a.k.a first-of-two

(λ (if-true) (λ (if-false) if-true))

( env env args ( args env args captured))

( #f env args ( args env args captured))

1.5.1 Boolean usage example: if true🔗ℹ

(@ (@ «true» env «true») env «false»)

1.5.2 Boolean usage example: if false🔗ℹ

(@ (@ «false» env «true») env «false»)

1.6 Pairs🔗ℹ

(λ (a) (λ (b) (λ (f) ((f a) b))))

;           ↑ a      a ↓      ↑ b        a ↓         f ↑       f ↓        a ↓
( env env args ( args env args ( captured env args (@ (@ args env captured) env BBBBBBBB))))
;           ↑ a      a ↓      ↑ b        b ↓         f ↑       f ↓                       b ↓
( env env args ( args env args (   args   env args (@ (@ args env AAAAAAAA) env captured))))

Can’t be done because our capture can only close over a single value. We use a primitive:

×

×

( #f env args (@ (@ args env «true-result») env «false-result»))

1.6.1 Fst🔗ℹ

(λ (p) (p «true-λ»))

( captured env args (@ args env «true»))

1.6.2 Snd🔗ℹ

(λ (p) (p «false-λ»))

( captured env args (@ args env «false»))

1.7 Either🔗ℹ

1.7.1 Left🔗ℹ

(λ (v) (λ (if-left) (λ (if-right) (if-left v))))

;          ↑ v     v ↓     ↑ if-left         ↓ if-left    ↓ v        ↑ if-right    ↓ if-left × v
( env env args ( args env args ( (@ «pair» args      captured) env args       (@ captured      env «appfv»))))
;          ↑ f     f ↓      ↑ v       ↓ f       ↓ v
( env env args ( args env args (@ captured env args)))

( #f env args ( args env args ( (@ × args captured) env args (@ captured env ( env env args ( args env args (@ captured env args)))))))

1.7.2 Right🔗ℹ

(λ (v) (λ (if-left) (λ (if-right) (if-right v))))

;          ↑ v     ↓v↑    if-left    ↓ v ↑       ↑ if-right    ↓ if-right     ↓ v
( env env args ( args env args ( captured env args       (@ args       env captured))))

( #f env args ( args env args ( captured env args (@ args env captured))))

1.8 If🔗ℹ

(λ (c) (λ (if-true) (λ (if-false) ((c if-true) if-false))))

When passed a boolean as the first argument (as should be the case), it is equivalent to:

(λ (c) c)

«if» ::=

1.8.1 Match "either"🔗ℹ

(λ (either) (λ (if-left) (λ (if-right) ((either if-true) if-false))))

When passed a constructor of the "either" variant as the first argument (as should be the case), it is equivalent to:

(@ (@ (@ «match-either» env (@ «left» env «id»)) env «id») env ( captured env args «false»))

(((<match-either-λ («right-λ» «id-λ»)) (λ (v) «false-λ»)) «id-λ»)

(@ (@ (@ «match-either» env (@ «right» env «id»)) env ( captured env args «false»)) env «id»)

1.9 Null🔗ℹ

(@ «left» env «dummy»)

( ( #f env args args) env args ( (@ × args captured) env args (@ captured env ( env env args ( args env args (@ captured env args))))))

1.10 Cons🔗ℹ

(λ (a) (λ (b) («right-λ» («pair-λ» a b))))

( captured env args ( args env args (@ «right» env (@ «pair» captured args))))

( #f env args ( args env args (@ ( env env args ( args env args ( captured env args (@ args env captured)))) env (@ × captured args))))

1.10.1 Match "list"🔗ℹ

1.11 null?🔗ℹ

(λ (l) (((«match-null-cons-λ» l) (λ (v) «true»)) (λ (v) «false-λ»)))

( captured env args (@ (@ (@ «match-null-cons» env args) env ( captured env args «true»)) env ( captured env args «false»)))

1.12 Car🔗ℹ

Since we don’t have an error reporting mechanism, we make (car null) = null and (cdr null) = null

( captured env args (@ (@ (@ «match-null-cons» env args) env ( captured env args «null»)) env «fst»))

(@ «car» env (@ (@ «cons» env «true») env «null»))

(@ «car» env (@ (@ «cons» env «false») env «null»))

(@ «car» env «null»)

1.13 Cdr🔗ℹ

Since we don’t have an error reporting mechanism, we make (car null) = null and (cdr null) = null

( captured env args (@ (@ (@ «match-null-cons» env args) env ( captured env args «null»)) env «snd»))

(@ «cdr» env (@ (@ «cons» env «true») env «null»))

(@ «cdr» env (@ (@ «cons» env «true») env (@ (@ «cons» env «false») env «null»)))

(@ (@ «cons» env «false») env «null»)

( ( #f env args (@ (@ args env «false-result») env «null-result»))
   env
   args
   ( captured env args (@ args env captured)))

(@ «car» env (@ «cdr» env (@ (@ «cons» env «true») env (@ (@ «cons» env «false») env «null»))))

1.14 Zero🔗ℹ

1.15 Not🔗ℹ

(λ (a) (((«if-λ» a) «false») «true»))

( captured env args (@ (@ (@ «if» env args) env «false») env «true»))

1.16 And🔗ℹ

(λ (a) (λ (b) (((«if-λ» a) b) «false-λ»)))

;                a       a       b                         a           b
( captured env args ( args env args (@ (@ (@ «if» env captured) env args) env «false»)))

(@ (@ «and» env «false») env «false»)

(@ (@ «and» env «false») env «true»)

(@ (@ «and» env «true») env «false»)

(@ (@ «and» env «true») env «true»)

1.17 Or🔗ℹ

(λ (a) (λ (b) (((«if-λ» a) «true») b)))

«or» ::=
;                a       a       b                         a                      b
( captured env args ( args env args (@ (@ (@ «if» env captured) env «true») env args)))

(@ (@ «or» env «false») env «false»)

(@ (@ «or» env «false») env «true»)

(@ (@ «or» env «true») env «false»)

(@ (@ «or» env «true») env «true»)

1.18 Equal bools🔗ℹ

(λ (a) (λ (b) (((«if-λ» a) b) («not-λ» b))))

( captured env args ( args env args (@ (@ (@ «if» env captured) env args) env (@ «not» env args))))

(@ (@ «eqbool» env «false») env «false»)

(@ (@ «eqbool» env «false») env «true»)

(@ (@ «eqbool» env «true») env «false»)

(@ (@ «eqbool» env «true») env «true»)

1.19 Z combinator🔗ℹ

(λ (x) (f (λ (v) ((x x) v))))

«Z» ::=
;               ↑ f
( captured env args (@ «half-Z» env «half-Z»))

;  ↓f↑      ↑ x       ↓ f           ↓x↑      ↑v           ↓ x          ↓ x         ↓ v
( args env args (@ captured env ( args env args (@ (@ captured env captured) env args))))

1.20 Equality of lists🔗ℹ

(λ (recur)
  (λ (cmp)
    (λ (a)
      (λ (b)
        ((«if-λ» ((«or-λ» («null?-λ» a)) («null?-λ» b))
                 (λ (_) ((«and-λ» («null?-λ» a)) («null?-λ» b)))
                 (λ (_) ((«if-λ» ((cmp («car-λ» a)) («car-λ» b))
                                 (λ (_) (((recur cmp) («cdr-λ» a)) («cdr-λ» b)))
                                 (λ (_) «false-λ»))
                         «dummy-λ»)))
         «dummy-λ»)))))

;   recur
( captured env args
   ;  recur    cmp
   ( args env args
      ;            recur    cmp       a
      ( (@ «pair» captured args) env args
         ;            recur+cmp  a        b
         ( (@ «pair» captured args) env args
            ;                                                  a                                           b
            (@ (@ (@ (@ «if» env (@ (@ «or» env (@ «null?» env (@ «snd» env captured))) env (@ «null?» env args)))
                     ;                                                               a                                           b
                     env         ( captured env args (@ (@ «and» env (@ «null?» env (@ «snd» env captured))) env (@ «null?» env args))))
                  ;                                                                cmp                                                   a
                  env            ( captured env args (@ (@ (@ (@ «if» env (@ (@ (@ «snd» env (@ «fst» env captured)) env (@ «car» env (@ «snd» env captured)))
                                                                              ;                                                        b
                                                                              env                                         (@ «car» env args)))
                                                               env         ( captured env args
                                                                              ;        recur
                                                                              (@ (@ (@ (@ «fst» env (@ «fst» env captured))
                                                                                       ;                      cmp
                                                                                       env                    (@ «snd» env (@ «fst» env captured)))
                                                                                    ;                         a
                                                                                    env          (@ «cdr» env (@ «snd» env captured)))
                                                                                 ;                            b
                                                                                 env             (@ «cdr» env args))))
                                                            env            ( captured env args
                                                                              «false»))
                                                         env
                                                         args)))
               env
               args)))))

(@ «eqlist» env (@ «eqlist» env «eqbool»))

;; These return true
(@ (@ «eqlist-bool» env «null») env «null»)
(@ (@ «eqlist-bool» env (@ (@ «cons» env «true») env «null»)) env (@ (@ «cons» env «true») env «null»))
(@ (@ «eqlist-bool» env (@ (@ «cons» env «false») env «null»)) env (@ (@ «cons» env «false») env «null»))
(@ (@ «eqlist-bool» env (@ (@ «cons» env «false») env (@ (@ «cons» env «true») env «null»))) env (@ (@ «cons» env «false») env (@ (@ «cons» env «true») env «null»)))
;; These return false
(@ (@ «eqlist-bool» env «null») env (@ (@ «cons» env «true») env «null»))
(@ (@ «eqlist-bool» env (@ (@ «cons» env «true») env «null»)) env «null»)
(@ (@ «eqlist-bool» env (@ (@ «cons» env «true») env (@ (@ «cons» env «true») env «null»))) env «null»)
(@ (@ «eqlist-bool» env «null») env (@ (@ «cons» env «true») env (@ (@ «cons» env «true») env «null»)))
(@ (@ «eqlist-bool» env (@ (@ «cons» env «true») env «null»)) env (@ (@ «cons» env «false») env «null»))
(@ (@ «eqlist-bool» env (@ (@ «cons» env «false») env (@ (@ «cons» env «true») env «null»))) env (@ (@ «cons» env «false») env (@ (@ «cons» env «false») env «null»)))

1.21 Associative lists🔗ℹ

(λ (recur)
  (λ (k)
    (λ (l)
      ((if («null?-λ» l)
           (λ (_) «false-λ»)
           ((«if-λ» (<eqlist-list-bool-λ> («fst-λ» («car-λ» l)) k)
                    (λ (_) («snd-λ» («car-λ» l)))
                    (λ (_) (recur k («cdr-λ» l))))
            «dummy-λ»))
       «dummy-λ»))))

;               ↑recur
( captured env args
   ;  ↓recur↑     ↓k↑
   ( args    env args
      ;            ↓recur   ↓k        ↓l
      ( (@ «pair» captured args) env args
         (@ ;                                ↓l
          (@ (@ (@ «if» env (@ «null?» env args))
                env         ( captured env args «false»))
             env            ( captured env args
                               ;                                                                                             ↓l          ↓k
                               (@ (@ (@ (@ «if» env (@ (@ «eqlist-list-bool» env (@ «car» env (@ «car» env args))) env (@ «snd» env captured)))
                                        ;                                                         ↓l
                                        env         ( captured env args(@ «cdr» env (@ «car» env args))))
                                     ;                                        ↓recur                     ↓k                                       ↓l
                                     env            ( captured env args(@ (@ (@ «fst» env captured) env (@ «snd» env captured)) env (@ «cdr» env args))))
                                  env args)))
          env args))))

(@ «Z» env «assoc-noZ»)

(@ (@ «cons-bits» env «bit-1») env (@ (@ «cons-bits» env «bit-1») env «null-bits»))

(@ (@ «cons-bits» env «bit-1») env (@ (@ «cons-bits» env «bit-0») env «null-bits»))

(@ (@ «env-push» env «assoc-example-other-kv»)
   env (@ (@ «env-push» env «assoc-example-kv»)
          env «env-null»))

1.22 environment-manipulation functions🔗ℹ

1.23 todo🔗ℹ

(@ ( #hash() env args
      (list (((λλ x (λλ x 1)) 1) 2)
            (((λλ x (λλ x x)) 1) 2)
            (((λλ x (λλ y y)) 1) 2)
            (((λλ x (λλ y x)) 1) 2)))
   (hash-set env "λλ" «todo-lam-impl»)
   (list))

( #hash() env args
   ( (hash "arg-name" (symbol->string (@ inspect-promise-root env (car (@ force env args))))
            "body" (car (cdr (@ force env args)))
            "saved-env" env)
      env
      args
      (@ (hash-ref closure "body")
         (hash-set (hash-ref closure "saved-env")
                   (hash-ref closure "arg-name")
                   (map (make-racket-proc ( #hash() env args
                                             (@ force env (car args)))
                                          env)
                        (@ force env args)))
         args)))

«*» ::=