aliasing renaming

People are often particular about naming. Names still hold special power: we may rationalize that names don't matter, but there's something hardcoded in human beings about choosing the right name for a thing. It's a hard thing to fight.

Programmers are people too, and programmers also keep concerns (sometimes too much) about the right name for a thing. As a concrete example, the word lambda scares off a few people since it's a foreign word. We might like to be brief and be able to say:

    (def (make-adder x)
      (fn (y) (+ x y)))

where def and fn are really meant to behave like define and lambda, respectively. One nice thing about Scheme is that it's plastic enough to absorb a trivial change like this. Here's a small library for aliasing identifiers:

(module alias mzscheme
  ;; Practice writing macros that themselves generate macros.  
  
  (provide alias)
  
  ;; (alias old-keyword new-keyword)   SYNTAX
  ;; Creates a new syntax for new-keyword; any occurrence of new-keyword
  ;; is replaced with the old-keyword.
  (define-syntax (alias stx-1)
    (syntax-case stx-1 ()
      [(_1 orig new)
       (syntax/loc stx-1
         (define-syntax (new stx-2)
           (syntax-case stx-2 ()
             [_2
              (identifier? stx-2)
              (syntax/loc stx-2
                orig)]
             [(_2 e (... ...))
              (syntax/loc stx-2
                (orig e (... ...)))])))])))

Once we have a tool like this, then we can test it out:

(module test-alias mzscheme
  (require "alias.ss")
  (alias lambda fn)
  (alias define def)
  
  (def (make-adder x)
    (fn (y) (+ x y))))

That being said, the above example is a silly thing to do. Even in competent hands, this is easy to abuse; in the wrong hands, one can end up with something that belongs to an obfuscation contest.

> (alias alias a)
> (a define d)
> (a if i)
> (d (f x) (i (= x 0) 1 (* x (f (- x 1)))))
> (f 3)
6

Communication between people means that we "come to terms", and the inherent abuse here is to turn the language into something that no one else can read. In PLT Scheme's case, the above is especially bad because there's already an established mechanism for controlled renaming of identifiers as part of PLT Scheme's module system.

(module test-alias mzscheme
  (require (rename mzscheme fn lambda)
           (rename mzscheme def define))
  
  (def (make-adder x) (fn (y) (+ x y))))

Still, I thought the macro definition was cute (even if it's silly), and it's one of the more direct applications of a "macro-generating macro" that I've seen. But maybe this is all just syntax, futzing with words, distracting us from the real work on nailing down the semantics of our thoughts.