Thank you for your comment

Beau­tiful Racket / racket school 2019

Day 1

Powerful points

  1. Some more inter­po­si­tion points.

  2. #%datum: wraps literal data, so these:

    "str"
    42
    "str"
42
    copy to clipboard

    Become these:

    (#%datum . "str")
    (#%datum . 42)
    (#%datum . "str")
(#%datum . 42)
    copy to clipboard

    Ques­tion: what’s the meaning of the dot after #%datum?

    Ques­tion: why is the code below a bad idea? How would you fix it?

    (define-macro (#%datum . X)
      #'(list X X))
    42
    (define-macro (#%datum . X)
  #'(list X X))
42
    copy to clipboard

  3. #%app: wraps func­tion appli­ca­tions, so this:

    (+ 42 -15)
    (+ 42 -15)
    copy to clipboard

    Becomes this:

    (#%app + 42 -15)
    (#%app + 42 -15)
    copy to clipboard

    Ques­tion: why is the code below a bad idea? How would you fix it?

    (define-macro (#%app OP ARG ...)
      #'(OP (abs ARG) ...))
    (+ 42 -15)
    (define-macro (#%app OP ARG ...)
  #'(OP (abs ARG) ...))
(+ 42 -15)
    copy to clipboard

  4. #%top: wraps iden­ti­fiers with top-level bind­ings, so id becomes (#%top . id). It can be used to handle unbound iden­ti­fiers.

    Ques­tion (hard): why is this so?

  5. Some more macrology.

  6. define-macro-cases lets you make a macro with several possible patterns, like cond:

    (define-macro-cases m
      [(m ARG1) #''one]
      [(m ARG1 ARG2) #''two]
      [(m . ARGS) #`#,(length (syntax->list #'ARGS))])

    (m foo) ; 'one
    (m foo 42) ; 'two
    (m foo 42 "yeah") ; 3
    (define-macro-cases m
  [(m ARG1) #''one]
  [(m ARG1 ARG2) #''two]
  [(m . ARGS) #`#,(length (syntax->list #'ARGS))])

(m foo) ; 'one
(m foo 42) ; 'two
(m foo 42 "yeah") ; 3
    copy to clipboard

    Ques­tion: what’s the meaning of #' #'' and #`#,?

  7. syntax->datum lets you peek inside a syntax object to see what’s inside. Use this with care, because you’re working at compile time, not run time.

    (define-macro (m THING)
      (define datum (syntax->datum #'THING))
      (cond
        [(number? datum) #'"wow!"]
        [else #'THING]))

    (m 99)
    (m "foo")
    (define x 42)
    (m x)
    (define-macro (m THING)
  (define datum (syntax->datum #'THING))
  (cond
    [(number? datum) #'"wow!"]
    [else #'THING]))

(m 99)
(m "foo")
(define x 42)
(m x)
    copy to clipboard

    Ques­tion: why is the last result 42, not "wow"? Isn’t x holding a number?

Mission

Make a language called #lang injunction that behaves the same way as #lang conjunction. This time, however, don’t reuse any code. Instead, your expander must export only these five inter­po­si­tion points: #%module-begin, #%app, #%datum, #%top, and #%top-interaction.

Example:

injunction/test.rkt
#lang injunction

"hello world"
(+ 1 (* 2 (- x)))
#lang injunc­tion

"hello world"
(+ 1 (* 2 (- x)))
copy to clipboard

Result:

"whee"
'(kaboom 42 (kaboom 42 (kaboom kaboom)))
"whee"
'(kaboom 42 (kaboom 42 (kaboom kaboom)))
copy to clipboard

Hint: In this case, you can’t use #lang br/quicklang as the imple­men­ta­tion language, because it already exports some of these inter­po­si­tion points. Just use #lang br.

Hint: use syntax/module-reader to set up the default reader and invoke your expander, like so:

injunction/main.rkt
#lang br

;; smop ···

(module reader syntax/module-reader
  injunction)
#lang br

;; smop ···

(module reader syntax/module-reader
  injunc­tion)
copy to clipboard

This is an alter­na­tive to invoking the language as #lang s-exp injunction.

Summary

Level up.

← prev next →