Thank you for your comment

Beau­tiful Racket / racket school 2019

Day 1

Powerful points

  1. S-expres­sion: atom or paren­the­sized list. White­space is collapsed.

  2. Program result = read → expand → eval­uate → print.

  3. REPL

  4. Atoms (plus the usual string & math func­tions)

    42+3i 1/3 0.333
    #b101010 #x2a #o52
    "hello world"
    #\h
    #true
    #t
    #false ; yes, we have no falsiness
    #f
    'sym
    (void)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    42+3i 1/3 0.333
#b101010 #x2a #o52
"hello world"
#\h
#true
#t
#false ; yes, we have no falsiness
#f
'sym
(void)
    copy to clipboard

  5. Pairs & lists: cons car cdr pair? list list? null empty '() null? empty? append

  6. Datums: quote ' quasiquote unquote unquote-splicing `(short ,hand ,@notation) '(dotted . pair)

    (list 1 2 3)
    '[4 5 6]
    `{2 3 ,(+ 4 5)}
    `{,(list 7 8 9)}
    `{,@(list a b c)}
    '(d . (e . (f)))
    (cons 'x (cons 'y (cons 'z null)))
    1
2
3
4
5
6
7
    (list 1 2 3)
'[4 5 6]
`{2 3 ,(+ 4 5)}
`{,(list 7 8 9)}
`{,@(list a b c)}
'(d . (e . (f)))
(cons 'x (cons 'y (cons 'z null)))
    copy to clipboard

  7. Func­tions: lambda λ values procedure? apply map filter (dotted . func . notation)

    (lambda (x) (abs x))
    (λ (x) (abs x))
    ((λ (x) (abs x)) -42)
    (abs -42)
    (apply (λ (x) (abs x)) (list -42))
    (apply abs (list -42))
    (map abs '(-1 2 3 -4))
    (filter abs '(-1 2 3 -4))
    (filter even? (map abs '(-1 2 3 -4)))
    (6 . * . 7)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    (lambda (x) (abs x))
(λ (x) (abs x))
((λ (x) (abs x)) -42)
(abs -42)
(apply (λ (x) (abs x)) (list -42))
(apply abs (list -42))
(map abs '(-1 2 3 -4))
(filter abs '(-1 2 3 -4))
(filter even? (map abs '(-1 2 3 -4)))
(6 . * . 7)
    copy to clipboard

  8. Vari­able = iden­ti­fier + binding

  9. Binding forms: define define-values let let* set!

    (define val 42)
    (define (f x) (+ x x))
    (define g (λ (x) (+ x x)))
    (let ([f (λ (x) (* x x))]
          [res (f val)])
      res)
    (let* ([f (λ (x) (* x x))]
           [res (f val)])
      res)
    1
2
3
4
5
6
7
8
9
    (define val 42)
(define (f x) (+ x x))
(define g (λ (x) (+ x x)))
(let ([f (λ (x) (* x x))]
      [res (f val)])
  res)
(let* ([f (λ (x) (* x x))]
       [res (f val)])
  res)
    copy to clipboard

  10. Condi­tionals: if when unless and or cond case match

    (if (even? 42) #true #false)
    (when (even? 42) #true)
    (unless (even? 42) 'destroy-galaxy)
    (cond
      [(even? 42) #true]
      [else #false])
    (let ([val 42])
      (case val
        [(42) #true]
        [else #false]))
    (match 42
      [(? even?) #true]
      [_ #false])
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    (if (even? 42) #true #false)
(when (even? 42) #true)
(unless (even? 42) 'destroy-galaxy)
(cond
  [(even? 42) #true]
  [else #false])
(let ([val 42])
  (case val
    [(42) #true]
    [else #false]))
(match 42
  [(? even?) #true]
  [_ #false])
    copy to clipboard

  11. Equality: eq? = eqv? equal?

  12. Loops & iter­a­tors: for for/fold for/list, in-list in-range in-naturals

    (for/list ([i (in-range 1 5)]
               [j (in-naturals 6)])
      (list i j))

    (for/fold ([sum 0])
              ([i (in-range 1 5)]
               [j (in-naturals 6)])
      (+ sum i j))

    (for/sum ([i (in-range 1 5)]
              [j (in-naturals 6)])
      (+ i j))

    (apply +
           (apply append
                  (for/list ([i (in-range 1 5)]
                             [j (in-naturals 6)])
                    (list i j))))
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
    (for/list ([i (in-range 1 5)]
           [j (in-naturals 6)])
  (list i j))

(for/fold ([sum 0])
          ([i (in-range 1 5)]
           [j (in-naturals 6)])
  (+ sum i j))

(for/sum ([i (in-range 1 5)]
          [j (in-naturals 6)])
  (+ i j))

(apply +
       (apply append
              (for/list ([i (in-range 1 5)]
                         [j (in-naturals 6)])
                (list i j))))
    copy to clipboard

  13. Modules: module module+ #lang

  14. Import & export: require provide rename-out

    (module inner br
      (provide foo (rename-out [barbara bar]))
      (define foo 'inner-foo)
      (define barbara 'inner-bar))
    (require 'inner)
    (define foo 'outer-foo)
    foo
    bar
    1
2
3
4
5
6
7
8
    (module inner br
  (provide foo (rename-out [barbara bar]))
  (define foo 'inner-foo)
  (define barbara 'inner-bar))
(require 'inner)
(define foo 'outer-foo)
foo
bar
    copy to clipboard

  15. Macros: define-syntax define-macro define-macro-cases

  16. Syntax objects: syntax quasisyntax unsyntax unsyntax-splicing #`(short #,hand #,@notation) syntax/loc

  17. Syntax patterns: ...

    (define-macro (dbl ARG)
      #'(list ARG ARG))

    (define-macro-cases foo
      [(_ 42) #'"kaboom!"]
      [(_ ARG) #'(list ARG ARG)])

    (define-macro (rev ARG0 "foo" ARG ...)
      #'(append (reverse (list 'ARG ...)) (list 'ARG0)))

    (define-macro (tell ARG ...)
      #'(for ([name (in-list (list 'ARG ...))])
          (displayln (format "~a = ~a" name ARG)) ...))
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    (define-macro (dbl ARG)
  #'(list ARG ARG))

(define-macro-cases foo
  [(_ 42) #'"kaboom!"]
  [(_ ARG) #'(list ARG ARG)])

(define-macro (rev ARG0 "foo" ARG ...)
  #'(append (reverse (list 'ARG ...)) (list 'ARG0)))

(define-macro (tell ARG ...)
  #'(for ([name (in-list (list 'ARG ...))])
      (displayln (format "~a = ~a" name ARG)) ...))
    copy to clipboard

  18. Inter­po­si­tion points: #%app #%datum #%top-interaction #%module-begin

  19. Comments: ;line #|block|# #;expr

  20. In #lang br: #R debug­ging

Mission

  1. If you already know how to write func­tions, make your own imple­men­ta­tions of map and filter.

  2. If you already know how to write macros, make your own imple­men­ta­tions of apply, and, and or.

← prev next →