COND-THUNK

License: Apache-2.0

cond-thunk is a library that abstracts conditionals into procedures called conditional procedues (ct). This allows the programmer to abstract conditional branches into procedures or macros, allowing for multiple value binding or backtracking.

Documentation for this library is in the format of index.scheme.org and is located in doc.

Tutorial -- cond-thunk

This tutorial is to get you aquainted with the basic cond-thunk form.

The cond-thunk macro

(cond-thunk
  expr1 expr2 ...
  (else body ...))

evaluates each expression in order. If the expression is #f, it evaluates the next expression. If it is a thunk, then it tail-calls the thunk. If no expression returns a thunk, then the body ... is evaluated for its values.

We will start by rewriting map using cond-thunk. map in regular Scheme is

(define (map f lst)
  (cond
    ((null? lst) '())
    ((pair? lst) (cons (f (car lst)) (map f (cdr lst))))
    (else (error "not a list" lst))))

With cond-thunk, this becomes

(define (map f lst)
  (cond-thunk
    (if (null? lst)
        (lambda () '())
        #f)
    (if (pair? lst)
        (lambda ()
          (cons (f (car lst)) (map f (cdr lst))))
        #f)
    (else (error "not a list" lst))))

This is very verbose. We can use the helper macro when-ct which will handle the conditional and wrapping the body in a lambda:

(define (map f lst)
  (cond-thunk
    (when-ct (null? lst) '())
    (when-ct (pair? lst)
      (cons (f (car lst)) (map f (cdr lst))))
    (else (error "not a list" lst))))

At this point, we seem to have just re-made the usual map, but with more macro invocations. But now each branch is it's own expression, which are not limited by the definition of the cond macro.

Let's implement filter:

(define (filter predicate? lst)
  (cond-thunk
    (when-ct (null? lst) '())
    (when-ct (not (pair? lst))
      (error "not a list" lst))
    (when-ct (predicate? (car lst))
      (cons (car lst) (filter predicate? (cdr lst))))
    (else (filter predicate? (cdr lst)))))

There is a common case between filter and map: the empty list and the error check. We can abstract them into their own procedures:

(define (null-on-null lst)
  (when-ct (null? lst) '()))

(define (not-a-list-error lst)
  (when-ct (not (pair? lst))
    (error "not a list" lst)))

(define (map f lst)
  (cond-thunk
    (null-on-null lst)
    (not-a-list-error lst)
    (else (cons (f (car lst)) (map f (cdr lst))))))

(define (filter predicate? lst)
  (cond-thunk
    (null-on-null lst)
    (not-a-list-error lst)
    (when-ct (predicate? (car lst))
      (cons (car lst) (filter predicate? (cdr lst))))
    (else (filter predicate? (cdr lst)))))

This makes the clauses more declarative, and easier to modify.

Tutorial -- after

TODO