The fanciest define of all time

  1. The fanciest define of all time
    1. require
    2. Lovable quirks
      1. Precedence order
      2. Defining variables
      3. Resetting & hacking
      4. The vagaries of DSSSL
    3. Source code

A define that can destructure, pattern match, be nested, and create generics!

(define (foop so much #!key (insight 2) (joy 3)) (list so much insight joy))
(define (foop (? string? apples) (? string? horses)) (string-append horses apples))
(list (foop "way" "no ") (foop 3 2 joy: 1))

⇒ ("no way" (3 2 2 1))

It works.♥

When there's just a normal define (with or without DSSSL stuff), it expands to a normal define. Using that variable or calling that function doesn't have any overhead, it's just bound normally.

Then when you define more stuff, it changes to become a dispatching generic multimethod.

One normal define becomes a normal define. It can have DSSSL stuff such as keyword arguments, that's fine.

Two defines (normal or not), or one un-normal define (using destructuring for example), and it switches to matching.

(define (just-a-single (oh my what)) (list my what oh))

(just-a-single (string->list "hey"))

⇒ (#\e #\y #\h)

Here is how the my-map example I've been using looks like in this system:

(define (my-map proc (x . xs)) (cons (proc x) (my-map proc xs)))
(define (my-map proc ()) '())
(my-map add1 '(1 2 3))

⇒ (2 3 4)


You can also call require to backtrack out of functions if a return requirement is not met.

For example, here is a strange that multiplies its arguments, unless if their sum would be even, in which case return the sum instead:

(define (strange a b) (list 'product (* a b)))
(define (strange a b) (list 'sum (require even? (+ a b))))
(map strange '(1 2 3 4) '(5 5 7 8))

⇒ ((sum 6) (product 10) (sum 10) (sum 12))

This require takes two arguments. The first is either a boolean or a predicate, and the other is a value.

(define (mysterious a b) 'vanilla)

(define (mysterious a b)
  (require even? (* a b))
  (require even? (+ a b))
  (require (< a b) 'neapolitan))

(map mysterious
     '(1 2 2)
     '(2 3 4))

⇒ (vanilla vanilla neapolitan)

It uses backtracking which means that side effects are executed.

This only applies to side effects before the requirements check:

(define (eerie a) (print "Catch-all"))

(define (eerie b)
  (print "Time to check if it's positive:")
  (require positive? b)
  (print "It was.\nTime to check if it's odd:")
  (require odd? b)
  (print "It was that too. Nice"))

(for-each eerie '(1 2 -1))

This prints out:

blockquoteTime to check if it's positive:

It was.

Time to check if it's odd:

It was that too. Nice

Time to check if it's positive:

It was.

Time to check if it's odd:


Time to check if it's positive:


Lovable quirks

Precedence order

LIFO baby! Most recently defined is checked first. So put the fall backs first and then go more specific. This is a deliberate reversal of match-lambda since it lets you define special cases later.

This does apply to require. Put require last so it can backtrack up to previous definitions.

Defining variables

If you just define a plain vanilla variable, then there's not gonna be any dispatching there:

(define horses 23)

Any older stuff you had stored in horses isn't lost, it'll be ready for when you define a new generic using their same car signature.

The same goes for

(define horses (lambda () 23))

That's not gonna be part of a generic.

"Single variables" like this aren't saved, and can be overwritten on next call to define.

Resetting & hacking

"OMG, I sent a mistyped definition to the REPL and now I can't define over it since this new define just adds stuff!"

This doesn't work:

(define (wrong tyop) typo)
(define wrong #f)
(define (wrong typo) typo)

It'll have both the tyop and the typo version in there.

I mean, that'd kind of be fine in this particular case since the dispatcher will see the latest version first and that happens to shadow the typos, but, if you put typos in predicates or whatever you might be in for a rough time.

However, to reset when you mistype something and wanna re-define at the REPL, do (define reset: <the-name>), so in this example

(define reset: wrong)

And to get access to the entire underlying call-table* for your own metamagic and hackery purps just use (define).

We wanna make easy things easy but any thing possible.♥

Emacs nerds, here is an elisp function that resets a define you're in:

(defun mdg-reset-define ()
    (re-search-backward "^(define ")
   (forward-char 1)
   (re-search-forward "(")
   (let* ((end (1- (re-search-forward "[ )]")))
    (beg (1+ (re-search-backward "(")))
    (str (buffer-substring beg end)))
      (format "(define reset: %s)\n" str))
     (message "Resetting %s" str))))

Bind it to whatever. You then need to re-send the sexps you do want.

The vagaries of DSSSL

You can't combine DSSSL (i.e. #!key, #!optional and #!rest) and matchable in the same line, but, as you saw in the foop example above, the same generic can handle both DSSSL stuff and matchable just fine, in separate clauses.

The dispatcher sees all of that stuff as just one big . rest tail so it catches and collides with a lot of patterns. So be careful if you wanna combine DSSSL and generics.

Source code

This define is available under the name define-dx in the match-generics egg.

git clone

Inside of the brev repo, and provided with the big brev egg, there is an extension named mdg that imports it under the name define and the OG define as define-og. So just (import brev mdg), which is now part of the little brev compiler shell wrapper and is prompted for by the brev2scm conversion process. Or if you want just the define and not the rest of the brev batteries,

(import (rename match-generics (define-dx define)))