#lang racket
;; let's figure out what the first arg to datum->syntax really means.

;; simplifies defining a lambda
(define-syntax l
  (lambda (x)
    (syntax-case x ()
      ((l e ...)
       (with-syntax ((var (datum->syntax #'l 'x)))
       #'(lambda (var) e ...))))))

((l (+ x 1)) 2) ; => 3

;; lets you define lambdas with a variable number of args.
;; args start with "x", then wrap around to "a" after hitting z.
;; note: (l x) is equivalent to (l 1 x)
;; (l (+ x 1)) => (lambda (x) (+ x 1))
;; (l 2 (+ x y)) => (lambda (x y) (+ x y))
;; (l 5 (+ x y z a b)) => (lambda (x y z a b) (+ x y z a b))
(define-syntax l0
  (lambda (x)
    (syntax-case x ()
      ((l0 n e ...)
       (with-syntax
           ((vars (datum->syntax #'l0
                                 (reverse (memq (list-ref '(x y z a b c d e f g h i j k l m n o p q r s t u v w) (- (syntax->datum #'n) 1)) '(w v u t s r q p o n m l k j i h g f e d c b a z y x))))))
       #'(lambda vars e ...))))))

((l0 4 (+ x y a)) 2 3 4 5)

;; let's simplify!
(define-syntax lx
  (lambda (x)
    (syntax-case x ()
      ((lx n e ...)
       (number? (syntax->datum #'n))
       (let ((letters '(x y z a b c d e f g h i j k l m n o p q r s t u v w)))
       (with-syntax
           ((vars (datum->syntax #'lx
                                 (reverse
                                  (memq
                                   (list-ref letters (- (syntax->datum #'n) 1))
                                        (reverse letters))))))
       #'(lambda vars e ...))))
      ((l e ...)
       (with-syntax ((var (datum->syntax #'l 'x)))
       #'(lambda (var) e ...))))))

((lx 3 (+ x y z)) 1 2 3) ;=> 6
((lx 6 (+ x y z a b c)) 1 2 3 4 5 6) ;=> 21
((lx (+ x 1)) 2) ; => 3