Closes #108.

langs/loot/test/interp-defun.rkt

@@ -4,5 +4,21 @@
          "../interp-defun.rkt"
          "../interp-io.rkt")
 
-(test-runner    (λ p (interp (parse p))))
-(test-runner-io (λ (s . p) (interp/io (parse p) s)))
+(define (closure->proc xs e r)
+  ;; Could make this better by calling the interpreter,
+  ;; but it's only used in tests where all we care about
+  ;; is that you get a procedure.
+  (lambda _
+    (error "This function is not callable.")))
+
+(test-runner
+ (λ p
+  (match (interp (parse p))
+    [(Closure xs e r) (closure->proc xs e r)]
+    [v v])))
+(test-runner-io
+ (λ (s . p)
+  (match (interp/io (parse p) s)
+    [(cons (Closure xs e r) o)
+     (cons (closure->proc xs e r) o)]
+    [r r])))

langs/loot/test/test-runner.rkt

@@ -248,7 +248,8 @@
   (check-equal? (run '(match (box 1) [(box x) x] [_ 2]))
                 1)
 
-  ;; Loot examples 
+  ;; Loot examples
+  (check-true (procedure? (run '(λ (x) x))))
   (check-equal? (run '((λ (x) x) 5))
                 5)
 

langs/loot/unload-bits-asm.rkt

@@ -30,7 +30,10 @@
          (string)
          (build-string (heap-ref i)
                        (lambda (j)
-                         (char-ref (+ i 8) j))))]))
+                         (char-ref (+ i 8) j))))]
+    [(? proc-bits? i)
+     (lambda _
+       (error "This function is not callable."))]))
 
 (define (untag i)
   (arithmetic-shift (arithmetic-shift i (- (integer-length ptr-mask)))

langs/mountebank/test/interp-defun.rkt

@@ -4,5 +4,21 @@
          "../interp-defun.rkt"
          "../interp-io.rkt")
 
-(test-runner    (λ p (interp (parse p))))
-(test-runner-io (λ (s . p) (interp/io (parse p) s)))
+(define (closure->proc xs e r)
+  ;; Could make this better by calling the interpreter,
+  ;; but it's only used in tests where all we care about
+  ;; is that you get a procedure.
+  (lambda _
+    (error "This function is not callable.")))
+
+(test-runner
+ (λ p
+  (match (interp (parse p))
+    [(Closure xs e r) (closure->proc xs e r)]
+    [v v])))
+(test-runner-io
+ (λ (s . p)
+  (match (interp/io (parse p) s)
+    [(cons (Closure xs e r) o)
+     (cons (closure->proc xs e r) o)]
+    [r r])))

langs/mountebank/test/test-runner.rkt

@@ -248,7 +248,8 @@
   (check-equal? (run '(match (box 1) [(box x) x] [_ 2]))
                 1)
 
-  ;; Loot examples 
+  ;; Loot examples
+  (check-true (procedure? (run '(λ (x) x))))
   (check-equal? (run '((λ (x) x) 5))
                 5)
 

langs/mountebank/unload-bits-asm.rkt

@@ -37,7 +37,10 @@
           (string)
           (build-string (heap-ref i)
                         (lambda (j)
-                          (char-ref (+ i 8) j)))))]))
+                          (char-ref (+ i 8) j)))))]
+    [(? proc-bits? i)
+     (lambda _
+       (error "This function is not callable."))]))
 
 (define (untag i)
   (arithmetic-shift (arithmetic-shift i (- (integer-length ptr-mask)))

langs/mug/test/interp-defun.rkt

@@ -4,5 +4,21 @@
          "../interp-defun.rkt"
          "../interp-io.rkt")
 
-(test-runner    (λ p (interp (parse p))))
-(test-runner-io (λ (s . p) (interp/io (parse p) s)))
+(define (closure->proc xs e r)
+  ;; Could make this better by calling the interpreter,
+  ;; but it's only used in tests where all we care about
+  ;; is that you get a procedure.
+  (lambda _
+    (error "This function is not callable.")))
+
+(test-runner
+ (λ p
+  (match (interp (parse p))
+    [(Closure xs e r) (closure->proc xs e r)]
+    [v v])))
+(test-runner-io
+ (λ (s . p)
+  (match (interp/io (parse p) s)
+    [(cons (Closure xs e r) o)
+     (cons (closure->proc xs e r) o)]
+    [r r])))

langs/mug/test/test-runner.rkt

@@ -248,7 +248,8 @@
   (check-equal? (run '(match (box 1) [(box x) x] [_ 2]))
                 1)
 
-  ;; Loot examples 
+  ;; Loot examples
+  (check-true (procedure? (run '(λ (x) x))))
   (check-equal? (run '((λ (x) x) 5))
                 5)
 

langs/mug/unload-bits-asm.rkt

@@ -37,7 +37,11 @@
           (string)
           (build-string (heap-ref i)
                         (lambda (j)
-                          (char-ref (+ i 8) j)))))]))
+                          (char-ref (+ i 8) j)))))]
+    [(? proc-bits? i)
+     (lambda _
+       (error "This function is not callable."))]))
+
 
 (define (untag i)
   (arithmetic-shift (arithmetic-shift i (- (integer-length ptr-mask)))

langs/neerdowell/test/interp-defun.rkt

@@ -4,5 +4,21 @@
          "../interp-defun.rkt"
          "../interp-io.rkt")
 
-(test-runner    (λ p (interp (parse p))))
-(test-runner-io (λ (s . p) (interp/io (parse p) s)))
+(define (closure->proc xs e r)
+  ;; Could make this better by calling the interpreter,
+  ;; but it's only used in tests where all we care about
+  ;; is that you get a procedure.
+  (lambda _
+    (error "This function is not callable.")))
+
+(test-runner
+ (λ p
+  (match (interp (parse p))
+    [(Closure xs e r) (closure->proc xs e r)]
+    [v v])))
+(test-runner-io
+ (λ (s . p)
+  (match (interp/io (parse p) s)
+    [(cons (Closure xs e r) o)
+     (cons (closure->proc xs e r) o)]
+    [r r])))

langs/neerdowell/test/test-runner.rkt

@@ -249,6 +249,7 @@
                 1)
 
   ;; Loot examples
+  (check-true (procedure? (run '(λ (x) x))))
   (check-equal? (run '((λ (x) x) 5))
                 5)
 

langs/neerdowell/unload-bits-asm.rkt

@@ -40,6 +40,9 @@
           (build-string (heap-ref i)
                         (lambda (j)
                           (char-ref (+ i 8) j)))))]
+    [(? proc-bits? i)
+     (lambda _
+       (error "This function is not callable."))]
     [(? struct-bits? i)
      (struct-val)]))
 

langs/outlaw/test/test-runner.rkt

@@ -245,6 +245,7 @@
                 1)
 
   ;; Loot examples
+  (check-true (procedure? (run '(λ (x) x))))
   (check-equal? (run '((λ (x) x) 5))
                 5)
 

langs/outlaw/unload-bits-asm.rkt

@@ -40,6 +40,9 @@
           (build-string (heap-ref i)
                         (lambda (j)
                           (char-ref (+ i 8) j)))))]
+    [(? proc-bits? i)
+     (lambda _
+       (error "This function is not callable."))]
     [(? struct-bits? i)
      (struct-val)]))