From 5f56fb7d8da47f9b2f51b5bc339e1581448a788c Mon Sep 17 00:00:00 2001 From: heidisu Date: Wed, 2 May 2018 21:59:34 +0200 Subject: [PATCH] initial commit --- .gitignore | 13 + 0-start-calculator.rkt | 61 +++ 1-fixed-calculator.rkt | 61 +++ 2-lookup-in-environment.rkt | 103 ++++ 3-definitions.rkt | 143 +++++ 4-functions.rkt | 177 ++++++ 5-continuation-passing-style.rkt | 205 +++++++ 6-booleans.rkt | 236 ++++++++ 7-amb.rkt | 329 ++++++++++++ 8-zebra.rkt | 456 ++++++++++++++++ README.md | 4 + docs.scrbl | 23 + docs/Ambiguousness.html | 19 + docs/Booleans.html | 11 + docs/Continuation-passing_style.html | 8 + docs/Definitions.html | 27 + docs/Fixing_the_calculator.html | 28 + docs/Functions.html | 7 + docs/It_s_puzzle_time.html | 6 + docs/Lookup_in_the_environment.html | 29 + docs/Meta-circular_what_.html | 21 + docs/Refactoring_to_CPS.html | 43 ++ docs/Some_Racket.html | 14 + docs/Towards_zebras.html | 34 ++ docs/cars.png | Bin 0 -> 21139 bytes docs/circles.png | Bin 0 -> 22888 bytes docs/index.html | 2 + docs/manual-fonts.css | 251 +++++++++ docs/manual-racket.css | 324 +++++++++++ docs/manual-racket.js | 98 ++++ docs/manual-style.css | 770 +++++++++++++++++++++++++++ docs/pict.png | Bin 0 -> 2348 bytes docs/pict_2.png | Bin 0 -> 3970 bytes docs/racket.css | 249 +++++++++ docs/scribble-common.js | 170 ++++++ docs/scribble.css | 485 +++++++++++++++++ docs/sudoku.png | Bin 0 -> 3211 bytes scrbl/amb.scrbl | 201 +++++++ scrbl/bools.scrbl | 91 ++++ scrbl/cps-refactor.scrbl | 168 ++++++ scrbl/cps.scrbl | 66 +++ scrbl/definitions.scrbl | 154 ++++++ scrbl/fix-calc.scrbl | 221 ++++++++ scrbl/functions.scrbl | 95 ++++ scrbl/images/cars.png | Bin 0 -> 21139 bytes scrbl/images/circles.png | Bin 0 -> 22888 bytes scrbl/images/sudoku.png | Bin 0 -> 3211 bytes scrbl/lookup.scrbl | 180 +++++++ scrbl/meta-eval.scrbl | 84 +++ scrbl/puzzles.scrbl | 45 ++ scrbl/racket.scrbl | 84 +++ scrbl/util.rkt | 21 + scrbl/zebra.scrbl | 197 +++++++ 53 files changed, 6014 insertions(+) create mode 100644 .gitignore create mode 100644 0-start-calculator.rkt create mode 100644 1-fixed-calculator.rkt create mode 100644 2-lookup-in-environment.rkt create mode 100644 3-definitions.rkt create mode 100644 4-functions.rkt create mode 100644 5-continuation-passing-style.rkt create mode 100644 6-booleans.rkt create mode 100644 7-amb.rkt create mode 100644 8-zebra.rkt create mode 100644 README.md create mode 100644 docs.scrbl create mode 100644 docs/Ambiguousness.html create mode 100644 docs/Booleans.html create mode 100644 docs/Continuation-passing_style.html create mode 100644 docs/Definitions.html create mode 100644 docs/Fixing_the_calculator.html create mode 100644 docs/Functions.html create mode 100644 docs/It_s_puzzle_time.html create mode 100644 docs/Lookup_in_the_environment.html create mode 100644 docs/Meta-circular_what_.html create mode 100644 docs/Refactoring_to_CPS.html create mode 100644 docs/Some_Racket.html create mode 100644 docs/Towards_zebras.html create mode 100644 docs/cars.png create mode 100644 docs/circles.png create mode 100644 docs/index.html create mode 100644 docs/manual-fonts.css create mode 100644 docs/manual-racket.css create mode 100644 docs/manual-racket.js create mode 100644 docs/manual-style.css create mode 100644 docs/pict.png create mode 100644 docs/pict_2.png create mode 100644 docs/racket.css create mode 100644 docs/scribble-common.js create mode 100644 docs/scribble.css create mode 100644 docs/sudoku.png create mode 100644 scrbl/amb.scrbl create mode 100644 scrbl/bools.scrbl create mode 100644 scrbl/cps-refactor.scrbl create mode 100644 scrbl/cps.scrbl create mode 100644 scrbl/definitions.scrbl create mode 100644 scrbl/fix-calc.scrbl create mode 100644 scrbl/functions.scrbl create mode 100644 scrbl/images/cars.png create mode 100644 scrbl/images/circles.png create mode 100644 scrbl/images/sudoku.png create mode 100644 scrbl/lookup.scrbl create mode 100644 scrbl/meta-eval.scrbl create mode 100644 scrbl/puzzles.scrbl create mode 100644 scrbl/racket.scrbl create mode 100644 scrbl/util.rkt create mode 100644 scrbl/zebra.scrbl diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..480e226 --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +compiled/ + +*~ +\#* +.#* +.DS_Store +*.bak +TAGS + +*.orig +*.rej + +*.core diff --git a/0-start-calculator.rkt b/0-start-calculator.rkt new file mode 100644 index 0000000..0afdb7b --- /dev/null +++ b/0-start-calculator.rkt @@ -0,0 +1,61 @@ +#lang racket + + +(define (eval-exp exp) + (match exp + [(? number?) exp] + + [(list '+ args ...) (apply + (map eval-exp args))] + + [(list '- args ...) (apply - (map eval-exp args))] + + [(list '* args ...) (apply * (map eval-exp args))] + + [(list '/ args ...) (apply * (map eval-exp args))] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + ) \ No newline at end of file diff --git a/1-fixed-calculator.rkt b/1-fixed-calculator.rkt new file mode 100644 index 0000000..3eaca8c --- /dev/null +++ b/1-fixed-calculator.rkt @@ -0,0 +1,61 @@ +#lang racket + + +(define (eval-exp exp) + (match exp + [(? number?) exp] + + [(list '+ args ...) (apply + (map eval-exp args))] + + [(list '- args ...) (apply - (map eval-exp args))] + + [(list '* args ...) (apply * (map eval-exp args))] + + [(list '/ args ...) (apply / (map eval-exp args))] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + ) \ No newline at end of file diff --git a/2-lookup-in-environment.rkt b/2-lookup-in-environment.rkt new file mode 100644 index 0000000..0ee1687 --- /dev/null +++ b/2-lookup-in-environment.rkt @@ -0,0 +1,103 @@ +#lang racket + +(define (lookup env s) + (match env + [(list (cons name x) rest ...) + (if (equal? name s) + x + (lookup rest s))] + + [(list) + (error 'unknown (~a s))])) + +(define primitives + (list (cons '+ +) + (cons '- -) + (cons '/ /) + (cons '* *))) + +(define (eval-application env fun args) + (apply (eval-exp env fun) + (map (λ (x) (eval-exp env x)) args))) + +(define (eval-exp env exp) + (match exp + [(? symbol?) (lookup env exp)] + [(? number?) exp] + + [(list fun args ...) (eval-application env fun args)] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp primitives input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2) + + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0) + + + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)) + 0) + ) \ No newline at end of file diff --git a/3-definitions.rkt b/3-definitions.rkt new file mode 100644 index 0000000..ebc7bc9 --- /dev/null +++ b/3-definitions.rkt @@ -0,0 +1,143 @@ +#lang racket + +(define (lookup env s) + (match env + [(list (cons name x) rest ...) + (if (equal? name s) + x + (lookup rest s))] + + [(list) + (error 'unknown (~a s))])) + +(define primitives + (list (cons '+ +) + (cons '- -) + (cons '/ /) + (cons '* *))) + +(define (extend-environment env names values) + (append (map cons names values) env)) + +(define (eval-application env fun args) + (apply (eval-exp env fun) + (map (λ (x) (eval-exp env x)) args))) + +(define (eval-sequence env terms) + (match terms + [(list exp) (eval-exp env exp)] + + [(list (list 'define name exp) rest ...) + (define value (eval-exp env exp)) + (define new-env (extend-environment env (list name)(list value))) + (eval-sequence new-env rest)] + + [(list trm rest ...) + (eval-exp env trm) + (eval-sequence env rest)])) + +(define (eval-exp env exp) + (match exp + [(? symbol?) (lookup env exp)] + [(? number?) exp] + + [(list 'begin terms ...) (eval-sequence env terms)] + + [(list fun args ...) (eval-application env fun args)] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp primitives input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2) + + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0) + + + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)) + 0) + + (check-equal? + (extend-environment (list (cons 'd 2) (cons 'e 1)) + (list 'a 'b 'c) + (list 5 4 3)) + (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1))) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define b 3) + (+ a b))) + 5) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define a 3) + (+ a a))) + 6) + ) \ No newline at end of file diff --git a/4-functions.rkt b/4-functions.rkt new file mode 100644 index 0000000..5f69a5b --- /dev/null +++ b/4-functions.rkt @@ -0,0 +1,177 @@ +#lang racket + +(define (lookup env s) + (match env + [(list (cons name x) rest ...) + (if (equal? name s) + x + (lookup rest s))] + + [(list) + (error 'unknown (~a s))])) + +(define primitives + (list (cons '+ +) + (cons '- -) + (cons '/ /) + (cons '* *))) + +(define (extend-environment env names values) + (append (map cons names values) env)) + +(define (make-function env parameters body) + (λ arguments + (define new-env (extend-environment env parameters arguments)) + (eval-sequence new-env + body))) + +(define (eval-application env fun args) + (apply (eval-exp env fun) + (map (λ (x) (eval-exp env x)) args))) + +(define (eval-sequence env terms) + (match terms + [(list exp) (eval-exp env exp)] + + [(list (list 'define name exp) rest ...) + (define value (eval-exp env exp)) + (define new-env (extend-environment env (list name)(list value))) + (eval-sequence new-env rest)] + + [(list trm rest ...) + (eval-exp env trm) + (eval-sequence env rest)])) + +(define (eval-exp env exp) + (match exp + [(? symbol?) (lookup env exp)] + [(? number?) exp] + + [(list 'begin terms ...) (eval-sequence env terms)] + + [(list 'λ parameters body ...) (make-function env parameters body)] + + [(list 'lambda parameters body ...) (make-function env parameters body)] + + [(list fun args ...) (eval-application env fun args)] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp primitives input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2) + + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0) + + + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)) + 0) + + (check-equal? + (extend-environment (list (cons 'd 2) (cons 'e 1)) + (list 'a 'b 'c) + (list 5 4 3)) + (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1))) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define b 3) + (+ a b))) + 5) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define a 3) + (+ a a))) + 6) + + (check-equal? + (evaluate '((λ () (+ 2 3)))) + 5) + + (check-equal? + (evaluate '((lambda (x y) (+ x y)) 3 4)) + 7) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b 3) + (+ a b)))) + 5) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b (lambda (c) (define a 5) (+ a c))) + (b a)))) + 7) + ) \ No newline at end of file diff --git a/5-continuation-passing-style.rkt b/5-continuation-passing-style.rkt new file mode 100644 index 0000000..6a7073c --- /dev/null +++ b/5-continuation-passing-style.rkt @@ -0,0 +1,205 @@ +#lang racket + +(define (lookup env s) + (match env + [(list (cons name x) rest ...) + (if (equal? name s) + x + (lookup rest s))] + + [(list) + (error 'unknown (~a s))])) + +(define (primitive fun) + (λ (continue . args) + (continue (apply fun args)))) + +(define primitives + (list (cons '+ (primitive +)) + (cons '- (primitive -)) + (cons '/ (primitive /)) + (cons '* (primitive *)))) + +(define (extend-environment env names values) + (append (map cons names values) env)) + +(define (make-function env parameters body) + (λ (continue . arguments) + (define new-env (extend-environment env parameters arguments)) + (eval-sequence new-env + continue + body))) + +(define (eval-arguments env continue args) + (match args + ['() (continue '())] + [(list arg rest ...) + (eval-exp env + (λ (arg-val) + (eval-arguments env + (λ (rest-val) + (continue (cons arg-val rest-val))) + rest)) + arg)])) + +(define (eval-application env continue fun args) + (eval-exp env + (λ (fun-val) + (eval-arguments env + (λ (args-val) + (apply fun-val continue args-val)) + args)) + fun)) + +(define (eval-sequence env continue terms) + (match terms + [(list exp) (eval-exp env continue exp)] + + [(list (list 'define name exp) rest ...) + (eval-exp env + (λ (value) + (define new-env (extend-environment env (list name)(list value))) + (eval-sequence new-env continue rest)) + exp)] + + [(list trm rest ...) + (eval-exp env + (λ (ignored) + (eval-sequence env continue rest)) + trm)])) + +(define (eval-exp env continue exp) + (match exp + [(? symbol?) (continue (lookup env exp))] + [(? number?) (continue exp)] + + [(list 'begin terms ...) (eval-sequence env continue terms)] + + [(list 'λ parameters body ...) (continue (make-function env parameters body))] + + [(list 'lambda parameters body ...) (continue (make-function env parameters body))] + + [(list fun args ...) (eval-application env continue fun args)] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp primitives + identity + input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2) + + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0) + + + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)) + 0) + + (check-equal? + (extend-environment (list (cons 'd 2) (cons 'e 1)) + (list 'a 'b 'c) + (list 5 4 3)) + (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1))) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define b 3) + (+ a b))) + 5) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define a 3) + (+ a a))) + 6) + + (check-equal? + (evaluate '((λ () (+ 2 3)))) + 5) + + (check-equal? + (evaluate '((lambda (x y) (+ x y)) 3 4)) + 7) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b 3) + (+ a b)))) + 5) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b (lambda (c) (define a 5) (+ a c))) + (b a)))) + 7) + ) \ No newline at end of file diff --git a/6-booleans.rkt b/6-booleans.rkt new file mode 100644 index 0000000..c07effa --- /dev/null +++ b/6-booleans.rkt @@ -0,0 +1,236 @@ +#lang racket + +(define (lookup env s) + (match env + [(list (cons name x) rest ...) + (if (equal? name s) + x + (lookup rest s))] + + [(list) + (error 'unknown (~a s))])) + +(define (primitive fun) + (λ (continue . args) + (continue (apply fun args)))) + +(define primitives + (list (cons '+ (primitive +)) + (cons '- (primitive -)) + (cons '/ (primitive /)) + (cons '* (primitive *)) + (cons '= (primitive =)) + (cons '< (primitive <)) + (cons '<= (primitive <=)) + (cons '> (primitive >)) + (cons '>= (primitive >=)))) + +(define (extend-environment env names values) + (append (map cons names values) env)) + +(define (make-function env parameters body) + (λ (continue . arguments) + (define new-env (extend-environment env parameters arguments)) + (eval-sequence new-env + continue + body))) + +(define (eval-arguments env continue args) + (match args + ['() (continue '())] + [(list arg rest ...) + (eval-exp env + (λ (arg-val) + (eval-arguments env + (λ (rest-val) + (continue (cons arg-val rest-val))) + rest)) + arg)])) + +(define (eval-application env continue fun args) + (eval-exp env + (λ (fun-val) + (eval-arguments env + (λ (args-val) + (apply fun-val continue args-val)) + args)) + fun)) + +(define (eval-sequence env continue terms) + (match terms + [(list exp) (eval-exp env continue exp)] + + [(list (list 'define name exp) rest ...) + (eval-exp env + (λ (value) + (define new-env (extend-environment env (list name)(list value))) + (eval-sequence new-env continue rest)) + exp)] + + [(list trm rest ...) + (eval-exp env + (λ (ignored) + (eval-sequence env continue rest)) + trm)])) + +(define (eval-exp env continue exp) + (match exp + [(? symbol?) (continue (lookup env exp))] + [(? number?) (continue exp)] + [(? boolean?) (continue exp)] + + [(list 'if x then else) + (eval-exp env + (λ (x-val) (eval-exp env continue (if x-val then else))) + x)] + + [(list 'begin terms ...) (eval-sequence env continue terms)] + + [(list 'λ parameters body ...) (continue (make-function env parameters body))] + + [(list 'lambda parameters body ...) (continue (make-function env parameters body))] + + [(list fun args ...) (eval-application env continue fun args)] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp primitives + identity + input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2) + + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0) + + + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)) + 0) + + (check-equal? + (extend-environment (list (cons 'd 2) (cons 'e 1)) + (list 'a 'b 'c) + (list 5 4 3)) + (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1))) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define b 3) + (+ a b))) + 5) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define a 3) + (+ a a))) + 6) + + (check-equal? + (evaluate '((λ () (+ 2 3)))) + 5) + + (check-equal? + (evaluate '((lambda (x y) (+ x y)) 3 4)) + 7) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b 3) + (+ a b)))) + 5) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b (lambda (c) (define a 5) (+ a c))) + (b a)))) + 7) + + (check-equal? + (evaluate '(if #f 3 5)) + 5) + + (check-equal? + (evaluate '(if (< 8 4) 1 0)) + 0) + + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 1)) + 3) + + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 5)) + 6) + ) \ No newline at end of file diff --git a/7-amb.rkt b/7-amb.rkt new file mode 100644 index 0000000..dad9cf5 --- /dev/null +++ b/7-amb.rkt @@ -0,0 +1,329 @@ +#lang racket + +(define (lookup env s) + (match env + [(list (cons name x) rest ...) + (if (equal? name s) + x + (lookup rest s))] + + [(list) + (error 'unknown (~a s))])) + +(define (primitive fun) + (λ (continue fail . args) + (continue fail (apply fun args)))) + +(define primitives + (list (cons '+ (primitive +)) + (cons '- (primitive -)) + (cons '/ (primitive /)) + (cons '* (primitive *)) + (cons '= (primitive =)) + (cons '< (primitive <)) + (cons '<= (primitive <=)) + (cons '> (primitive >)) + (cons '>= (primitive >=)) + (cons 'list (primitive list)))) + +(define (extend-environment env names values) + (append (map cons names values) env)) + +(define (make-function env parameters body) + (λ (continue fail . arguments) + (define new-env (extend-environment env parameters arguments)) + (eval-sequence new-env + continue + fail + body))) + +(define (eval-arguments env continue fail args) + (match args + ['() (continue fail '())] + [(list arg rest ...) + (eval-exp env + (λ (fail2 arg-val) + (eval-arguments env + (λ (fail3 rest-val) + (continue fail3 (cons arg-val rest-val))) + fail2 + rest)) + fail + arg)])) + +(define (eval-application env continue fail fun args) + (eval-exp env + (λ (fail2 fun-val) + (eval-arguments env + (λ (fail3 args-val) + (apply fun-val continue fail3 args-val)) + fail2 + args)) + fail + fun)) + +(define (eval-require env continue fail exp) + (eval-exp env + (λ (fail2 value) + (if value + (continue fail2 value) + (fail))) + fail + exp)) + +(define (eval-amb env continue fail exps) + (match exps + [(list) (fail)] + [(list exp rest ...) + (eval-exp env + continue + (λ () (eval-amb env continue fail rest)) + exp)])) + +(define (eval-sequence env continue fail terms) + (match terms + [(list exp) (eval-exp env continue fail exp)] + + [(list (list 'define name exp) rest ...) + (eval-exp env + (λ (fail2 value) + (define new-env (extend-environment env (list name)(list value))) + (eval-sequence new-env continue fail2 rest)) + fail + exp)] + + [(list trm rest ...) + (eval-exp env + (λ (fail2 ignored) + (eval-sequence env continue fail2 rest)) + fail + trm)])) + +(define (eval-exp env continue fail exp) + (match exp + [(? symbol?) (continue fail (lookup env exp))] + [(? number?) (continue fail exp)] + [(? boolean?) (continue fail exp)] + + [(list 'if x then else) + (eval-exp env + (λ (fail2 x-val) (eval-exp env continue fail2 (if x-val then else))) + fail + x)] + + [(list 'require x) + (eval-require env + continue + fail + x)] + + [(list 'amb exps ...) + (eval-amb env + continue + fail + exps)] + + [(list 'begin terms ...) (eval-sequence env continue fail terms)] + + [(list 'λ parameters body ...) (continue fail (make-function env parameters body))] + + [(list 'lambda parameters body ...) (continue fail (make-function env parameters body))] + + [(list fun args ...) (eval-application env continue fail fun args)] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp primitives + (λ (fail res) res) + (λ () (error 'ohno)) + input)) + +(define (evaluate* input) + (eval-exp primitives + (λ (fail res) (cons res (fail))) + (λ () '()) + input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2) + + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0) + + + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)) + 0) + + (check-equal? + (extend-environment (list (cons 'd 2) (cons 'e 1)) + (list 'a 'b 'c) + (list 5 4 3)) + (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1))) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define b 3) + (+ a b))) + 5) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define a 3) + (+ a a))) + 6) + + (check-equal? + (evaluate '((λ () (+ 2 3)))) + 5) + + (check-equal? + (evaluate '((lambda (x y) (+ x y)) 3 4)) + 7) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b 3) + (+ a b)))) + 5) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b (lambda (c) (define a 5) (+ a c))) + (b a)))) + 7) + + (check-equal? + (eval-require primitives + (λ (x f) #t) + (λ () #f) + '(< 3 6)) + #t) + (check-equal? + (eval-require primitives + (λ (x f) #t) + (λ () #f) + '(> 3 6)) + #f) + + (check-equal? + (evaluate + '(begin + (define a (amb 1 (- 5 3) 6 8)) + (require (> a 5)) + a)) + 6) + + (check-equal? + (evaluate '(if #f 3 5)) + 5) + + (check-equal? + (evaluate '(if (< 8 4) 1 0)) + 0) + + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 1)) + 3) + + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 5)) + 6) + + (check-equal? + (evaluate + '(begin + (define a (amb 1 3 5 7)) + (define b (amb 2 4 3 6)) + (require (= (+ a b) 9)) + (list a b))) + '(3 6)) + + (check-equal? + (evaluate* + '(begin + (define a (amb 1 (- 5 3) 6 8)) + (require (> a 5)) + a)) + '(6 8)) + + (check-equal? + (evaluate* + '(begin + (define a (amb 1 3 5 7)) + (define b (amb 2 4 3 6)) + (require (= (+ a b) 9)) + (list a b))) + '((3 6) (5 4) (7 2))) + ) \ No newline at end of file diff --git a/8-zebra.rkt b/8-zebra.rkt new file mode 100644 index 0000000..93d42dd --- /dev/null +++ b/8-zebra.rkt @@ -0,0 +1,456 @@ +#lang racket + +(define (lookup env s) + (match env + [(list (cons name x) rest ...) + (if (equal? name s) + x + (lookup rest s))] + + [(list) + (error 'unknown (~a s))])) + +(define (primitive fun) + (λ (continue fail . args) + (continue fail (apply fun args)))) + +(define primitives + (list (cons '+ (primitive +)) + (cons '- (primitive -)) + (cons '/ (primitive /)) + (cons '* (primitive *)) + (cons '= (primitive =)) + (cons '< (primitive <)) + (cons '<= (primitive <=)) + (cons '> (primitive >)) + (cons '>= (primitive >=)) + (cons 'abs (primitive abs)) + (cons 'equal? (primitive equal?)) + (cons 'list (primitive list)) + (cons 'cons (primitive cons)) + (cons 'car (primitive car)) + (cons 'cdr (primitive cdr)) + (cons 'null? (primitive null?)))) + +(define (extend-environment env names values) + (append (map cons names values) env)) + +(define (make-function env parameters body) + (λ (continue fail . arguments) + (define new-env (extend-environment env parameters arguments)) + (eval-sequence new-env + continue + fail + body))) + +(define (make-named-function env name parameters body) + (λ (continue fail . arguments) + (define new-env (extend-environment env + (list name) + (list (make-named-function env name parameters body)))) + (define newer-env (extend-environment new-env parameters arguments)) + (eval-sequence newer-env + continue + fail + body))) + +(define (eval-arguments env continue fail args) + (match args + ['() (continue fail '())] + [(list arg rest ...) + (eval-exp env + (λ (fail2 arg-val) + (eval-arguments env + (λ (fail3 rest-val) + (continue fail3 (cons arg-val rest-val))) + fail2 + rest)) + fail + arg)])) + +(define (eval-application env continue fail fun args) + (eval-exp env + (λ (fail2 fun-val) + (eval-arguments env + (λ (fail3 args-val) + (apply fun-val continue fail3 args-val)) + fail2 + args)) + fail + fun)) + +(define (eval-require env continue fail exp) + (eval-exp env + (λ (fail2 value) + (if value + (continue fail2 value) + (fail))) + fail + exp)) + +(define (eval-amb env continue fail exps) + (match exps + [(list) (fail)] + [(list exp rest ...) + (eval-exp env + continue + (λ () (eval-amb env continue fail rest)) + exp)])) + +(define (eval-sequence env continue fail terms) + (match terms + [(list exp) (eval-exp env continue fail exp)] + + [(list (list 'define (list name params ...) body ...) rest ...) + (define new-env (extend-environment env + (list name) + (list (make-named-function env name params body)))) + (eval-sequence new-env + continue + fail + rest)] + + [(list (list 'define name exp) rest ...) + (eval-exp env + (λ (fail2 value) + (define new-env (extend-environment env (list name)(list value))) + (eval-sequence new-env continue fail2 rest)) + fail + exp)] + + [(list trm rest ...) + (eval-exp env + (λ (fail2 ignored) + (eval-sequence env continue fail2 rest)) + fail + trm)])) + +(define (eval-exp env continue fail exp) + (match exp + [(? symbol?) (continue fail (lookup env exp))] + [(? number?) (continue fail exp)] + [(? boolean?) (continue fail exp)] + [(? string?) (continue fail exp)] + + [(list 'if x then else) + (eval-exp env + (λ (fail2 x-val) (eval-exp env continue fail2 (if x-val then else))) + fail + x)] + + [(list 'require x) + (eval-require env + continue + fail + x)] + + [(list 'amb exps ...) + (eval-amb env + continue + fail + exps)] + + [(list 'quote x) (continue fail x)] + + [(list 'begin terms ...) (eval-sequence env continue fail terms)] + + [(list 'λ parameters body ...) (continue fail (make-function env parameters body))] + + [(list 'lambda parameters body ...) (continue fail (make-function env parameters body))] + + [(list fun args ...) (eval-application env continue fail fun args)] + + [_ (error 'wat (~a exp))])) + +(define (evaluate input) + (eval-exp primitives + (λ (fail res) res) + (λ () (error 'ohno)) + input)) + +(define (evaluate* input) + (eval-exp primitives + (λ (fail res) (cons res (fail))) + (λ () '()) + input)) + +(define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl))) + + +(module+ test + (require rackunit) + + (check-equal? + (evaluate '(+ 1 2)) + 3) + + (check-equal? + (evaluate '(+ 1 2 3)) + 6) + + (check-equal? + (evaluate '(- 2 1)) + 1) + + (check-equal? + (evaluate '(* 2 4)) + 8) + + (check-equal? + (evaluate '(/ 8 2)) + 4) + + (check-equal? + (evaluate '(* 2 (+ 1 (- 4 2)))) + 6) + + (check-exn + exn:fail? + (λ () + (eval '(foo 1 2)))) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1) + + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2) + + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0) + + + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)) + 0) + + (check-equal? + (extend-environment (list (cons 'd 2) (cons 'e 1)) + (list 'a 'b 'c) + (list 5 4 3)) + (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1))) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define b 3) + (+ a b))) + 5) + + (check-equal? + (evaluate + '(begin + (define a 2) + (define a 3) + (+ a a))) + 6) + + (check-equal? + (evaluate '((λ () (+ 2 3)))) + 5) + + (check-equal? + (evaluate '((lambda (x y) (+ x y)) 3 4)) + 7) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b 3) + (+ a b)))) + 5) + + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b (lambda (c) (define a 5) (+ a c))) + (b a)))) + 7) + + (check-equal? + (evaluate '(if #f 3 5)) + 5) + + (check-equal? + (evaluate '(if (< 8 4) 1 0)) + 0) + + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 1)) + 3) + + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 5)) + 6) + + (check-equal? + (eval-require primitives + (λ (x f) #t) + (λ () #f) + '(< 3 6)) + #t) + (check-equal? + (eval-require primitives + (λ (x f) #t) + (λ () #f) + '(> 3 6)) + #f) + + (check-equal? + (evaluate + '(begin + (define a (amb 1 (- 5 3) 6 8)) + (require (> a 5)) + a)) + 6) + + (check-equal? + (evaluate + '(begin + (define a (amb 1 3 5 7)) + (define b (amb 2 4 3 6)) + (require (= (+ a b) 9)) + (list a b))) + '(3 6)) + + (check-equal? + (evaluate* + '(begin + (define a (amb 1 (- 5 3) 6 8)) + (require (> a 5)) + a)) + '(6 8)) + + (check-equal? + (evaluate* + '(begin + (define a (amb 1 3 5 7)) + (define b (amb 2 4 3 6)) + (require (= (+ a b) 9)) + (list a b))) + '((3 6) (5 4) (7 2))) + ) + + +(define zebra + '(begin + (define (index-of l v) + (if (equal? (car l) v) + 0 + (+ 1 (index-of (cdr l) v)))) + + (define (neighbours? l1 v1 l2 v2) + (= 1 (abs (- (index-of l1 v1) (index-of l2 v2))))) + + (define (same-index l1 v1 l2 v2) + (if (equal? (car l1) v1) + (require (equal? (car l2) v2)) + (same-index (cdr l1) v1 (cdr l2) v2))) + + (define (member? v l) + (if (null? l) + #f + (if (equal? (car l) v) + #t + (member? v (cdr l))))) + + (define (distinct? items) + (if (null? items) + #t + (if (null? (cdr items)) + #t + (if (member? (car items)(cdr items)) + #f + (distinct? (cdr items)))))) + + (define (map f l) + (if (null? l) + '() + (cons (f (car l)) (map f (cdr l))))) + (map (λ (x) (+ x x)) '(1 2 3 4 5)) + + (define nat + (list + "norwegian" + (amb "english" "spanish" "japanese" "ukranian") + (amb "english" "spanish" "japanese" "ukranian") + (amb "english" "spanish" "japanese" "ukranian") + (amb "english" "spanish" "japanese" "ukranian"))) + (require (distinct? nat)) + + (define colour + (list (amb "ivory" "green" "red" "yellow") + "blue" + (amb "ivory" "green" "red" "yellow") + (amb "ivory" "green" "red" "yellow") + (amb "ivory" "green" "red" "yellow"))) + (require (distinct? colour)) + + (same-index nat "english" colour "red") + (require (= (index-of colour "green") (+ (index-of colour "ivory") 1))) + + (define drink + (list (amb "coffee" "orange juice" "tea" "water") + (amb "coffee" "orange juice" "tea" "water") + "milk" + (amb "coffee" "orange juice" "tea" "water") + (amb "coffee" "orange juice" "tea" "water"))) + (require (distinct? drink)) + + (same-index nat "ukranian" drink "tea") + (same-index drink "coffee" colour "green") + + (define smoke + (list (amb "chesterfield" "kools" "lucky strike" "old gold" "parliament") + (amb "chesterfield" "kools" "lucky strike" "old gold" "parliament") + (amb "chesterfield" "kools" "lucky strike" "old gold" "parliament") + (amb "chesterfield" "kools" "lucky strike" "old gold" "parliament") + (amb "chesterfield" "kools" "lucky strike" "old gold" "parliament"))) + (require (distinct? smoke)) + + (same-index smoke "kools" colour "yellow") + (same-index smoke "lucky strike" drink "orange juice") + (same-index nat "japanese" smoke "parliament") + + (define pet + (list (amb "dog" "fox" "horse" "snails" "zebra") + (amb "dog" "fox" "horse" "snails" "zebra") + (amb "dog" "fox" "horse" "snails" "zebra") + (amb "dog" "fox" "horse" "snails" "zebra") + (amb "dog" "fox" "horse" "snails" "zebra"))) + (require (distinct? pet)) + + (same-index nat "spanish" pet "dog") + (same-index smoke "old gold" pet "snails") + + (require (neighbours? smoke "chesterfield" pet "fox")) + (require (neighbours? smoke "kools" pet "horse")) + (list nat colour drink smoke pet))) + +(evaluate* zebra) \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..9cc8b1a --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +# Make your own meta-circular evaluator! +by [Jonas Winje](https://twitter.com/JonasWinje) and [Heidi Mork](https://twitter.com/heidicmork) + +Workshop instructions can be found [here](https://heidisu.github.io/amb) diff --git a/docs.scrbl b/docs.scrbl new file mode 100644 index 0000000..417d7db --- /dev/null +++ b/docs.scrbl @@ -0,0 +1,23 @@ +#lang scribble/manual +@(define scribblings '(("manual.scrbl" (multi-page)))) + +@title{Make your own meta-circular evaluator!} + +@(author + @elem{Jonas Winje (@(hyperlink "https://twitter.com/JonasWinje" "@JonasWinje"))} + @elem{Heidi Mork (@(hyperlink "https://twitter.com/heidicmork" "@heidicmork"))}) + +@(table-of-contents) + +@include-section{scrbl/meta-eval.scrbl} +@include-section{scrbl/racket.scrbl} +@include-section{scrbl/fix-calc.scrbl} +@include-section{scrbl/lookup.scrbl} +@include-section{scrbl/definitions.scrbl} +@include-section{scrbl/functions.scrbl} +@include-section{scrbl/cps.scrbl} +@include-section{scrbl/cps-refactor.scrbl} +@include-section{scrbl/bools.scrbl} +@include-section{scrbl/amb.scrbl} +@include-section{scrbl/puzzles.scrbl} +@include-section{scrbl/zebra.scrbl} \ No newline at end of file diff --git a/docs/Ambiguousness.html b/docs/Ambiguousness.html new file mode 100644 index 0000000..77f3ebe --- /dev/null +++ b/docs/Ambiguousness.html @@ -0,0 +1,19 @@ + +10 Ambiguousness
▼Make your own meta-circular evaluator!
►10 Ambiguousness
On this page:
10.1 Some tests
10.2 Some stuff will have a fail-parameter
10.3 require
10.4 amb
10.5 Btw let’s add a list-function to our primitives
10.6 evaluate*
10.7 Done?
6.12
    ← prev  up  next → 

10 Ambiguousness

If we’ve been through the previous part, we can keep using the same file. Or we can use 6-booleans.rkt as our starting point.

Now that we have continuations, we will add continuations.
We want to add support for the new forms amb and require. +An amb with multiple expressions, (amb exps ...) is a form that evaluates to the value of one of its expressions. +A require with an expression, (require exp), succeeds if the expression evaluates to true (#t) and fails if it evaluates to false (#f). +If a require fails, +the evaluator should backtrack to the last amb and try to continue from there with the value of one of the “remaining” expressions of that amb.
For taking care of the backtracky bits, we will use a fail-continuation in addition to the continue-continuation.

10.1 Some tests

(check-equal?
 (eval-require primitives
               (λ (x f) #t)
               (λ () #f)
               '(< 3 6))
 #t)
(check-equal?
 (eval-require primitives
               (λ (x f) #t)
               (λ () #f)
               '(> 3 6))
 #f)

(check-equal?
 (evaluate
  '(begin
     (define a (amb 1 (- 5 3) 6 8))
     (require (> a 5))
     a))
 6)
(check-equal?
 (evaluate
  '(begin
     (define a (amb 1 3 5 7))
     (define b (amb 2 4 3 6))
     (require (= (+ a b) 9))
     (list a b)))
 '(3 6))
(check-equal?
 (evaluate*
  '(begin
     (define a (amb 1 (- 5 3) 6 8))
     (require (> a 5))
     a))
 '(6 8))
(check-equal?
 (evaluate*
  '(begin
     (define a (amb 1 3 5 7))
     (define b (amb 2 4 3 6))
     (require (= (+ a b) 9))
     (list a b)))
 '((3 6) (5 4) (7 2)))

10.2 Some stuff will have a fail-parameter

The functions we use as continue-continuations, as well as all functions that have continue-parameters, should also have fail-parameters. +Like, we will change continuation-lambdas like (λ (value) stuff) to ones like (λ (fail value) stuff), +and things like (eval-exp env continue exp) to things like (eval-exp env continue fail exp). +For now, the different functions will just pass their fails along.

The evaluate-function should work like before. Just, it’s continue-argument should accept a failure-continuation in addition to the result, +and it should pass some fail-argument to eval-exp:
(define (evaluate input)
  (eval-exp primitives
            (λ (fail res) res)
            (λ () (error 'ohno))
            input))

10.3 require

In eval-exp we will add a clause:
[(list 'require x)
 (eval-require env
               continue
               fail
               x)]
And make the function (eval-require env continue fail exp). +In eval-require we will evaluate exp.

The continuation we pass along to eval-exp should carry on with continue if x evaluated to true, +or use fail if it evaluated to false. +The fail-continuation should not take any arguments.

The two tests that use eval-require should pass after this.

10.4 amb

To eval-exp we add:

[(list 'amb exps ...)
 (eval-amb env
           continue
           fail
           exps)]

And we make the function (eval-amb env continue fail exps).

In eval-amb we will match the exps-list. +If exps is empty, we (fail). +If exps has at least one element, we will evaluate that expression with eval-exp:
We can pass our continue-continuation along.
But we need to make a new failure-continuation, (λ () your code here). +We will make it so that if anything fails later in the program, we will eval-amb with the remaining elements of the exps-list. +(When we run out of elements in exps, we will invoke our “original” fail-continuation, as per our first match-clause.)

10.5 Btw let’s add a list-function to our primitives

Just, it would be nice to return multiple values now, so we will add Racket’s list-function to the primitives list.

10.6 evaluate*

So evaluate should work mostly like before, and it will return the first solution, or throw an error if there aren’t any.

It would be neat to have an evaluation-function that could return a list of solutions instead. So we will make one. +In evaluate*, we, uh, “replace failure with a list of successes,” maybe:

(define (evaluate* input)
  (eval-exp primitives
            (λ (fail res) (cons res (fail)))
            (λ () '())
            input))

Now we can, say, make a program for finding numbers that add up to 10:

(define adds-up-to-10
  '(begin
     (define a (amb 1 2 3 4 5 6 7 8 9))
     (define b (amb 1 2 3 4 5 6 7 8 9))
     (require (= (+ a b) 10))
     (list a b)))

And we can get one solution with (evaluate adds-up-to-10), or several solutions with (evaluate* adds-up-to-10).

10.7 Done?

Run and see that all the tests pass.

Next: Maybe It’s puzzle time, or we can go Towards zebras. We should be equipped for either. +We can keep using the Racket-file we’re working with, or skip to 7-amb.rkt..

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Booleans.html b/docs/Booleans.html new file mode 100644 index 0000000..12b20d8 --- /dev/null +++ b/docs/Booleans.html @@ -0,0 +1,11 @@ + +9 Booleans
▼Make your own meta-circular evaluator!
►9 Booleans
On this page:
9.1 Some tests
9.2 Literals
9.3 if
9.4 Some functions
9.5 Maybe:   and, or, ...
9.6 Done?
6.12
    ← prev  up  next → 

9 Booleans

If we’ve been through the previous part, we can keep using the same file. Or we can use 5-continuation-passing-style.rkt as our starting point.

Add booleans. Go blind.

9.1 Some tests

(check-equal?
 (evaluate '(if #f 3 5))
 5)
(check-equal?
 (evaluate '(if (< 8 4) 1 0))
 0)
(check-equal?
 (evaluate '((λ (a b)
               (if (> a (+ b b)) 3 6))
             9 1))
 3)
(check-equal?
 (evaluate '((λ (a b)
               (if (> a (+ b b)) 3 6))
             9 5))
 6)

9.2 Literals

We want to have two boolean literals: #t (true) and #f (false). +In eval-exp these can be matched and handled quite the same way as number-literals. +We can use Racket’s boolean?-function to match booleans, the way we use the number?-function to match numbers.

9.3 if

And we want some kind of if-then-else. +In eval-exp we add a clause:

[(list 'if x then else) your code here]

If it matches, we will evaluate the x-expression, +then choose then-expression or else-expression depending on the value we got, +and then evaluate the expression we chose.

9.4 Some functions

And also we probably want some functions, like = and < and so on. +Since our numbers are Racket-numbers and our booleans are Racket-booleans we can add them the same way we have added the other “primitives,” +like + and - and such.
We will add at least =, <, <=, > and >=. +We can add more later if we need more...

9.5 Maybe: and, or, ...

We can totally skip this part. It isn’t necessary for any of the stuff we will do later. But it’s maybe like nice or something.

We can implement stuff like and by matching on it in eval-exp and then kind of rewriting to an if-expression and evaluating that rewritten expression instead:

[(list 'and a b)
 (define rewritten-exp (list 'if your code here))
 your code also here]

9.6 Done?

Run and see that all the tests pass.
Next is Ambiguousness. +We can keep using the Racket-file we’re working with, or skip to 6-booleans.rkt.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Continuation-passing_style.html b/docs/Continuation-passing_style.html new file mode 100644 index 0000000..8eac518 --- /dev/null +++ b/docs/Continuation-passing_style.html @@ -0,0 +1,8 @@ + +7 Continuation-passing style
▼Make your own meta-circular evaluator!
►7 Continuation-passing style
On this page:
7.1 Not CPS
7.2 CPS
6.12
    ← prev  up  next → 

7 Continuation-passing style

(Not really working with in this part. Can play with stuff in the Racket REPL.)

Say we want a function that adds two to its argument.

7.1 Not CPS

A reasonably normal way to go about things could be:
(define (add2 x)
  (+ x 2))
If we wanna appply it to the number three and display the result, then we can apply it to 3 and display:

(display (add2 3))

Chances are the number 5 will be displayed.

7.2 CPS

A less normal way to go about things could be: +Instead of add2-function taking just one argument, +it could take two arguments and the second argument could be a “continuation”-argument. +And instead add2 returning the result of the addition, +it could apply its “continuation” to the result.
(define (add2 x continue)
  (continue (+ x 2)))
Now, if we wanna display the result, we do not apply display to the result. +Instead we pass in display as add2’s continue-argument.

(add2 3 display)

If we don’t exactly have exactly the exact functions we want at hand, we can make them with lambdas.

(add2 3
      (λ (result)
        (add2 result
              (λ (final-result)
                (printf "it's ~a" final-result)))))

So that’s weird. +Anyway we’re passing continuations. That style of programming is called continuation-passing style (CPS).

Next is Refactoring to CPS.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Definitions.html b/docs/Definitions.html new file mode 100644 index 0000000..c88a81d --- /dev/null +++ b/docs/Definitions.html @@ -0,0 +1,27 @@ + +5 Definitions
▼Make your own meta-circular evaluator!
►5 Definitions
On this page:
5.1 Some tests
5.2 define in Racket
5.3 extend-environment
5.4 eval-sequence and define
5.5 begin
5.6 Done?
6.12
    ← prev  up  next → 

5 Definitions

If we’ve been through the previous part, we can keep using the same file. Or we can use 2-lookup-in-environment.rkt as our starting point.

Passing an unchanging environment around is pretty cool. +Maybe it would also be cool if the environment could also be extended with more stuff. +Will try to.

We will use “definitions” to bind a names to a values, so that they can be referred to by their names. +When we encounter a definition we will extend the environment with a new binding.

5.1 Some tests

(check-equal?
 (extend-environment (list (cons 'd 2) (cons 'e 1))
                     (list 'a 'b 'c)
                     (list 5 4 3))
 (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1)))
(check-equal?
 (evaluate
  '(begin
     (define a 2)
     (define b 3)
     (+ a b)))
 5)
(check-equal?
 (evaluate
  '(begin
     (define a 2)
     (define a 3)
     (+ a a)))
 6)

5.2 define in Racket

Our defintions are going to work rather like the regular Racket ones. +Try out the following lines of code in the REPL:

(define a 2)

a

(define b +)

(b a 3)

(begin
  (define a 3)
  (+ a 3))

5.3 extend-environment

We would like a helper-function for extending an environment with new bindings. +We want to use this for definitions, and also for adding arguments to the environment when functions are called. +Functions can have multiple parameters, so we will make extend-environment take a list of names +and a list of values, in addition to the environment it should extend:

(define (extend-environment env names values)
  your code here)

The function should return a new list where the new pairs of name and value are appended to env. +The Racket function append will be useful. +Also useful: Racket’s map-function can take multiple lists of same length as arguments. Like:

(map cons (list 'a 'b 'c) (list 1 2 3))

When done, the test that uses extend-environment should pass.

5.4 eval-sequence and define

Definitions are not “expressions” in our language: We do not evluate a definition in order to get some value. It only extends the environment. +That kind of means that evaluating a program that is only a definition is not an incredibly meaningful thing to do. +Like, we, uh, we want results.
So, we’re going to add support for evaluating multiple terms, on after another. +Typically one or more definitions and then an expression at the end.

We make function:

(define (eval-sequence env exps)
  (match exps
    [(list x)  your code here]
 
    [(list ('define name exp) rest ...)  your code here]
 
    [(list x rest ...)  your code here]))

In the first match-clause: +The list only consist of only one element. +The one element in a one-element list is its final element. +The final term in a sequence is the expression we want to evaluate in order to get its result value. +We can use eval-exp.

In the last match-clause: +Since the middle clause did not match, x is not a define-form. +We will evaluate it with eval-exp, throw away its result, and use eval-sequence on the rest of the terms. +(Yea so throwing away the results seems possibly wasteful. Maybe side effects though?)

In the last match-clause: +A define-form. This is more trickier. +First we should evaluate the expression part of the defintion, +and create a new environment with extend-environment. +Then we can call eval-sequence on the rest of the list and the new environment.

5.5 begin

We use begin-forms to create expressions out of lists of terms. +We add a new match-clause in eval-exp:

[(list 'begin terms ...) your code here]

And we will use eval-sequence to deal with the terms.

5.6 Done?

Run and see that all the tests pass.
Next is Functions. +We can keep using the Racket-file we’re working with, or skip to 3-definitions.rkt.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Fixing_the_calculator.html b/docs/Fixing_the_calculator.html new file mode 100644 index 0000000..b4fb068 --- /dev/null +++ b/docs/Fixing_the_calculator.html @@ -0,0 +1,28 @@ + +3 Fixing the calculator
▼Make your own meta-circular evaluator!
►3 Fixing the calculator
On this page:
3.1 Working with a file in Dr  Racket
3.2 The calculator-code
3.2.1 define
3.2.2 read and quotes
3.2.3 match
3.2.4 apply
3.3 Making the test pass
3.4 Done?
6.12
    ← prev  up  next → 

3 Fixing the calculator

Should open the 0-start-calculator.rkt-file in DrRacket.

3.1 Working with a file in DrRacket

Click the image-button, or press F5. +DrRacket runs the file and the window kind of splits in two.

  • The bit above is the Definitions bit. +The contents of the file goes in Definitions; if we save the file it’s the stuff in Definitions that will be saved.

  • The bit below is the Interactions bit. +This is like a REPL. We can write Racket expressions here and have them evaluated. +The Definitions are made available for Interactions whenever we Run the file.

There’s a failing test. We’ll get back to that.

For now, try to run some expressions in Interactions. Maybe some of these:

(+ 2 3)

(evaluate '(+ 2 3))

(repl)

3.2 The calculator-code

There’s some stuff going on...

(define (eval-exp exp)
  (match exp
    [(? number?) exp]
 
    [(list '+ args ...) (apply + (map eval-exp args))]
 
    [(list '- args ...) (apply - (map eval-exp args))]
 
    [(list '* args ...) (apply * (map eval-exp args))]
 
    [(list '/ args ...) (apply * (map eval-exp args))]
 
    [_ (error 'wat (~a exp))]))
(define (evaluate input)
  (eval-exp input))
(define (repl)
  (printf "> ")
  (define input (read))
  (unless (eof-object? input)
    (define output (evaluate input))
    (printf "~a~n" output)
    (repl)))
3.2.1 define

The first define-form defines a function called eval-exp that takes one argument, exp. +For now, the eval-exp-function is the most important piece of code. It is for evaluating and expression and returning the result.

3.2.2 read and quotes

The following is a regular Racket-expresssion:

(+ 1 2)

It is the application of the function + to the arguments 1 and 2.
We can “quote” a term:

'(+ 1 2)

This is not a function application. It evaluates to a list with three elements: +The symbol '+, the number 1, and the number 2. +We can “quote” a term in order to get the syntax of the term as a data object.

Try out the following expressions in the REPL, and notice the differences.

(+ 1 2)

'(+ 1 2)

(list + 1 2)

(list '+ 1 2)

If you would like to check if two values are equal to each other, the function equal? is handy.

The programs we will evaluate with our evaluator are data objects like the ones we get by quoting Racket terms. +So we can write terms that are like regular Racket terms, quote them and pass them to our evaluator:

(evaluate '(+ 1 2))

(equal? '(+ 1 2) (list '+ 1 2))

The repl-function is a Read-Eval-Print-Loop. +It uses the read-function to read a Racket term. +read reads a Racket term and returns a data object, same as we would get if that term was quoted in a regular Racket program. +repl then evaluates, printfs the result, and, by calling itself recursively, loops.

So we can use the repl-function to get a repl for the language we are making. +Nice to have, can be fun to play around with. +(But we will usually call evaluate directly, with quoted Racket terms, when testing the evaluator during the workshop.)

3.2.3 match

Inside the eval-exp-function there is a match-form. +match is used for pattern matching. +It matches exp against a series of patterns, and evaluates some “body”-code for the first pattern that matches. +Each “clause” consists of a pattern and some “body”-code. So:

  • The pattern (? number?) matches if exp is a number (if the number?-function returns true when applied to exp. +If it matches, eval-exp will return (the number) exp.

  • The pattern (list '+ args ...) matches if exp is a list where the first element is the symbol '+. +If it matches, (apply + (map eval-exp args)), with args bound to the rest of the exp-list, will be evaluated. +eval-exp will return result.

  • The pattern (list '- args ...) matches if the exp is a list where the first element is the symbol '-. +If it matches, (apply - (map eval-exp args)), with args bound to the rest of the exp-list, will be evaluated. +eval-exp will return result.

  • And so on.

  • _ matches whatever. If none of the patterns above match, this one will, and we will throw an error.

3.2.4 apply

In most of the pattern matching clauses, we use the apply-function. +apply is a function application function. +If a function takes several arguments, and we have the arguments we want to apply it to in a list, we can use apply.

Like, normally we apply the +-function like so:

(+ 1 2 3)

If we have a list lst with numbers:

(define lst (list 1 2 3))

Then we cannot apply + directly to the lst-list. ++ can be applied to severl number-arguments, not one list-with-several-numbers-argument. +But we can use apply:

(apply + lst)

3.3 Making the test pass

Lets’s make the failing test pass:

  • Quickest way to get back to the failure is to run (F5) the file again.

  • DrRacket should highlight the failing test in the definitions window, or we can click on the image in the REPL to highlight it again.

  • We can stare at the failing test and at the eval-exp-code for a little while.

  • And then fix.

3.4 Done?

Next is Lookup in the environment. +We can keep using the Racket-file we’re working with, or skip to 1-fixed-calculator.rkt.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Functions.html b/docs/Functions.html new file mode 100644 index 0000000..b6c40ab --- /dev/null +++ b/docs/Functions.html @@ -0,0 +1,7 @@ + +6 Functions
▼Make your own meta-circular evaluator!
►6 Functions
On this page:
6.1 Some tests
6.2 Make a function
6.3 New match clauses in eval-exp
6.4 Done?
6.12
    ← prev  up  next → 

6 Functions

If we’ve been through the previous part, we can keep using the same file. Or we can use 3-definitions.rkt as our starting point.

Functions are good for parameterizing pieces of code.

A function in our language wil be built from a list of parameter names and a list of terms for the function body. +When called, the function should extend its environment with its parameters bound to the arguments supplied by the caller, +and then evaluate the body.

6.1 Some tests

(check-equal?
 (evaluate '((λ () (+ 2 3))))
 5)
(check-equal?
 (evaluate '((lambda (x y) (+ x y)) 3 4))
 7)
(check-equal?
 (evaluate
  '((lambda ()
      (define a 2)
      (define b 3)
      (+ a b))))
 5)
(check-equal?
 (evaluate
  '((lambda ()
      (define a 2)
      (define b (lambda (c) (define a 5) (+ a c)))
      (b a))))
 7)

6.2 Make a function

When eval-exp encounters a “lambda” we want to make a real Racket function.

We make make-function function:

(define (make-function env parameters body)
  (λ arguments
    your code here))

  • env is the environment the function was defined in.

  • parameters is a list of parameter names (symbols).

  • body is a list of terms. Maybe an expression. Maybe some defines and then an expression.

make-function returns a Racket-function (made with the λ). +That function should extend the environment it was defined in with each parameter name bound to the corresponding argument-value, +and then eval-sequence its body.

6.3 New match clauses in eval-exp

[(list 'λ parameters body ...) your code here]

When the 'λ matches we want to make a function with make-function.

Also, we will add a very similar match-clause, for when people use lambda instead of λ.

6.4 Done?

Run and see that all the tests pass.
Next is Continuation-passing style. +We can keep using the Racket-file we’re working with, or skip to 4-functions.rkt.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/It_s_puzzle_time.html b/docs/It_s_puzzle_time.html new file mode 100644 index 0000000..421c5cd --- /dev/null +++ b/docs/It_s_puzzle_time.html @@ -0,0 +1,6 @@ + +11 It's puzzle time
▼Make your own meta-circular evaluator!
►11 It’s puzzle time
On this page:
11.1 Find the missing number
11.2 Find the digits
11.3 Sudoku
11.4 Done?
6.12
    ← prev  up  next → 

11 It’s puzzle time

If we’ve been through the previous part, we can keep using the same file. Or we can use 7-amb.rkt as our starting point.

Now that we have our great evaluator with amb and require, let us see what it can do!

11.1 Find the missing number

Do you ever see pictures like this one in your social media feeds? Well, now you have a language to solve them for you.

Write a program in our new language that solves this puzzle by the use amb to define possible values 1 - 9 for the car colors, and require to define the restrictions.

What happens if you allow the green car to also have the value -2?

11.2 Find the digits

Find the digits symbolized by the blue, red and white circles that fits into the calculation.

11.3 Sudoku

Our evaluator can also solve sudokus!

The easiest way is to require that the sums vertically, horizontally and inside each square are equal to 10. +But then we might get more than one solution and manually select the one that follows the rules, +because we have not incorporated the rule that the digits in same row, column or square should be distinct.

If we want to do it properly our program has to define a function that takes a list and decides if the elements in the list are unique. +One way to do that would be to loop through the list and check if the first element is contained in the rest of the list, if it is, the elements are not unique, +otherwise call the function with the rest of the list. (This function will also be useful for solving the Zebra puzzle).

The sudoku in the picture is from minisudoku.com. There are more sudokus there, and you can check your solution.

11.4 Done?

Towards zebras, then.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Lookup_in_the_environment.html b/docs/Lookup_in_the_environment.html new file mode 100644 index 0000000..fdde577 --- /dev/null +++ b/docs/Lookup_in_the_environment.html @@ -0,0 +1,29 @@ + +4 Lookup in the environment
▼Make your own meta-circular evaluator!
►4 Lookup in the environment
On this page:
4.1 Some tests
4.2 primitives
4.3 lookup
4.4 Environment as input to eval-exp
4.4.1 Looking up
4.4.2 eval-application
4.5 Done?
6.12
    ← prev  up  next → 

4 Lookup in the environment

If we’ve been through the previous part, we can keep using the same file. Or we can use 1-fixed-calculator.rkt as our starting point.

We see that most of the match-clauses in eval-exp look quite similar. +We will do some steps of refactoring in order to not repeat ourselves, and also to be prepared for things to come. +Later the users of the program will be able to define their own variables with names they choose themselves, +so we do not want to continue to match on the names ('+, '- and so on) as we currently do in eval-exp. +Instead we will look up the values of variables in some lookup-table that can be extended dynamically.

4.1 Some tests

(check-equal?
 (lookup (list (cons 'a 1)
               (cons 'b 2))
         'a)
 1)
(check-equal?
 (lookup (list (cons 'a 1)
               (cons 'b 2))
         'b)
 2)
(check-equal?
 (lookup (list (cons 'a 0)
               (cons 'a 1)
               (cons 'b 2))
         'a)
 0)
(check-exn
 exn:fail?
 (λ ()
   (lookup (list (cons 'a 1)
                 (cons 'b 2))
           'c)))

4.2 primitives

A name (a symbol) together with a value (e.g. the number 2, or a function) is a binding. +We will put bindings in a list. +When the evaluator encounters a name it will look it up in this list so that it can return the value bound by that name.

We will start off by making a list called primitives containing our four primitive operators, +and look up in this list every time the function eval-exp sees a symbol. +We will use list to construct the list of bindings. +Each binding will be a pair, constructed with cons.
(define primitives
  (list (cons '+ +)
        more bindings))

4.3 lookup

We will implement this as a recursive function. +If the first binding in the list is equal to the symbol we are looking for then we return the corresponding value, +otherwise we call lookup on what remains of the list. +If the list is empty it doesn’t have the binding we’re looking for, and we will raise an exception.

We will make the lookup-function:
(define (lookup env s)
  (match env
    your code here))

It should have a couple of match-clauses:

One should match the empty list (e.g. (list) or '()), and throw an exception. +We can use Racket’s error-function to raise an exception +(see the function eval-exp for an example of use of error).
The more difficult part is to match a list with a binding (a cons-pair) as its first element. +We can use a clause like:

[(list (cons name val) rest ...) your code here]

If this matches it will pick out the parts we need: +name will be bound to a variable name and val to its value, +and rest will be bound to the rest of the list. +We then want to check if name is equal? to s, +and return val if it is, +or else call lookup on s and the rest of the list.

The tests we added should pass when we’re done.

4.4 Environment as input to eval-exp

We will pass primitives as an argument to eval-exp, and make eval-exp use it to look up values. +So, in the definition of eval-exp, instead of

(eval-exp exp)

we will have have

(eval-exp env exp)

env will be the list of bindings we will use for looking up stuff.

We should modify the evaluate-function so that it passes primitives along to eval-exp.

4.4.1 Looking up

Now that eval-exp has an environment we can use it for when there are symbols:

[(? symbol?) your code here]

When this matches we want to apply our lookup-function to env and exp.

4.4.2 eval-application

Now, instead of having different match-clauses for '+ and '- and so on, +we can have one clause for function application:

[(list fun args ...) (eval-application env fun args)]

We should be able to evaluate the fun-expression to get the correct function. +We’re using a helper function:

(define (eval-application env fun args)
  your code here)

It should evaluate the fun-expression and all the expressions in the args list, +and apply the evaluated fun to the evaluated args.

Should be pretty similar to what we used to do when we matched e.g. '+, +only we don’t use a hardcoded function (like +), +and we need to pass the environment along whenever we call eval-exp.

4.5 Done?

Run and see that all the tests pass.
Next is Definitions. +We can keep using the Racket-file we’re working with, or skip to 2-lookup-in-environment.rkt.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Meta-circular_what_.html b/docs/Meta-circular_what_.html new file mode 100644 index 0000000..a5b3e52 --- /dev/null +++ b/docs/Meta-circular_what_.html @@ -0,0 +1,21 @@ + +1 Meta-circular what?
▼Make your own meta-circular evaluator!
►1 Meta-circular what?
On this page:
1.1 Programming languages and evaluators
1.2 amb and logic programming
1.3 Outline
1.4 Goals for the workshop
6.12
    ← prev  up  next → 

1 Meta-circular what?

The idea for this workshop comes from the classic book +Structure and Interpretation of Computer Programs (SICP). +It is a good book, you should read it!

1.1 Programming languages and evaluators

A programming language is a language with a certain syntax and given rules, +that makes you able to write programs that hopefully do what you expect them do do.

There are different strategies for how an implementation of a programming language executes programs. One approach is to make an evaluator. +An evaluator (or interpreter) for a language is a program that rather directly executes expressions written in that language. +In order to execute the program, the evaluator needs to parse the expressions to something meaningful for the evaluator, and then evalute the expressions.

When making a new language we can implemented an evaluator in more or less any kind of language, +but we will typically have to spend quite some time working on lexing and parsing before we have something meaningful or fun. +We will use a subset of Racket’s syntax for our language, and we will implement the evaluator in Racket. +Reusing bits of our “host language” like that is what we do when we’re making meta-circular evaluator.

But wait, why would we write (something very similar to) Racket in Racket when we already have a Racket? +Well:

  • Is fun.

  • It can be easier to modify and experiment with a tiny language we have made ourselves. +Easier to do things like, changing the evaluation order of things so that it’s more lazier, +or, as we will do in this workshop, add support for “nondeterministic” computaion.

1.2 amb and logic programming

The way we will make Racket nondeterministic is by extending it with the form amb, which takes multiple expressions and returns one of them, +and with require, which will allow us to specify constraints that must be satisfied. +With those extensions we can write programs where the evaluator must search for solutions by choosing different values for the different amb-expressions.

This is a step towards logic programming where a problem is defined in terms of facts or rules, that might result in more than one answer. +Unknown values are represented by variables, +and unification is used for solving the "equations" and determine the valid values.

1.3 Outline

What we will do in this workshop is to start with a simple calculator evaluator, which allows us to calculate the value of expressions with the four basic operators +, -, * and /. +And then gradually, through several steps, extend it until we have our notdeterministic evaluator amb.

We will go through the steps of implementing +Lookup in the environment, Definitions, Functions, Booleans, Continuation-passing style and Ambiguousness, +before we move Towards zebras, our ultimate goal. +It is possible to skip familiar steps: Every step has a corresponding Racket file that can be used as a starting point.

1.4 Goals for the workshop

Our goals for this workshop is that you hopefully learn something new about

  • The Racket programming language

  • How evaluators work

  • Continuation-passing style

  • Logic programming

but most of all, we hope you will

  • Get inspiration and new ideas

  • Have fun!

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Refactoring_to_CPS.html b/docs/Refactoring_to_CPS.html new file mode 100644 index 0000000..1749d50 --- /dev/null +++ b/docs/Refactoring_to_CPS.html @@ -0,0 +1,43 @@ + +8 Refactoring to CPS
▼Make your own meta-circular evaluator!
►8 Refactoring to CPS
On this page:
8.1 Some stuff will have a continue-parameter
8.1.1 (eval-exp env continue exp)
8.1.2 (eval-sequence env continue exps)
8.1.3 (eval-application env continue fun args)
8.1.4 Our “primitives”
8.1.5 (make-function env parameters body)
8.1.6 (evaluate input)
8.2 So that did nothing
8.3 Couple of tips, maybe
8.4 Done?
6.12
    ← prev  up  next → 

8 Refactoring to CPS

If we’ve been through the previous part, we can keep using the same file. Or we can use 4-functions.rkt as our starting point.

CPS, besides being weird, is kind of neat. +If you’re implementing a function, +and the “continuation” —everything that is to happen after— is made available to you as a function, +then, uh, that’s a thing you’re in control of.
You can decide not to invoke the continuation. +Or you can try to invoke the continuation several times, with different values. +Later on we want to use an amb-form for expressions that can have multiple possible values: +We want to “continue” with some value, and if that turns out to be no good, we want to try some other value instead. +CPS seems like a good fit.

8.1 Some stuff will have a continue-parameter

We will rewrite a few functions so they have a continue-parameter, +and so that, instead of returning a result, they apply continue to a result. +We will put continue just after env in the parameter lists. +E.g. eval-application will go like (eval-application env continue fun args).

8.1.1 (eval-exp env continue exp)

eval-exp isn’t too bad. In most of the match-clauses we return a value pretty directly. +In those cases we will pass the values along to continue instead. +In the case where we call eval-application, we will pass our continue along to eval-application and put it in front of the other arguments...

8.1.2 (eval-sequence env continue exps)

The cases where we have some rest-expressions are a little trickier. +In, say, the 'define-case, we must make a continuation-function to use with eval-exp. Like:

(eval-exp env
          (λ (value)
            your code here)
          exp)

Within this continuation-function, we will do the stuff we previously did after the call to eval-exp: +Extend the environment and call eval-sequence again. We will pass our “original” continue to eval-sequence.

8.1.3 (eval-application env continue fun args)

Maybe the trickiest. We must evaluate the fun-expression with eval-exp, with a continuation that deals with the arguments. +For every argument in the list, there will be a call to eval-exp with a continuation that deals with +the rest of the arguments and performing the function application. Along the way we must keep track of the arguments we have evaluated. +Finally, the function we are going to apply will take a continue-argument before the evaluated args: +We will pass our continue-parameter along to it.
It is likely that evaluating the arguments is the hardest bit. We probably want this:
(define (eval-arguments env continue args)
  (match args
    ['() your code here]
    [(list arg rest ...) your code here]))
In '()-case: Evaluating all the arguments in the empty list is maybe not too hard?
In the (list arg rest ...)-case: +We want to eval-exp the arg, +then eval-arguments the rest of the arguments, +and then cons the evaluated argument onto the evaluated rest-of-the-arguments. +Like, we’re really “just” trying to map eval-exp over args. Having to work out what needs to go in which continuation makes things more confusing though.

8.1.4 Our “primitives”

Instead of e.g. the +-function we want a function that has a continue-argument first:

(define (my-plus continue . args)
  your code here)

When this function is applied, all the arguments after the continue are collected in args, as a list. +We can use the apply-function to apply the original +-function to the args. +(And we want to apply continue to the result rather than just returning it.)

It is pretty possible, while not exactly necessary, to make a helper-function for this. +One that takes a regular function as its argument and returns a more CPS-compliant function. +Something along the lines of
(define (primitive function)
  (λ (continue . args)
    your code here))

could be convenient.

8.1.5 (make-function env parameters body)

We’re not adding a continue-parameter to make-function function, +but we need to add it to the function returned by make-function. +That continue should be passed in as the second argument to eval-sequence.

8.1.6 (evaluate input)

For now, we want evaluate to work the same way as before, so we are not adding a continue-parameter to it. +But it does use eval-exp so we need to add a continue-argument there. +We will use Racket’s identity-function.

8.2 So that did nothing

So, if we got things right then we have kind of made no changes. +Under the hood things work differently, +but there are no new features and all the expressions in the language we’re making should evaluate to the same values.

How dull? On the plus side we didn’t have to write any new tests...

8.3 Couple of tips, maybe

Okay so this stuff is like not straightforward. +Because CPS. +Also because we have to change a bunch of of interdependent functions: We change one and everything breaks. +So. Two tips:
One tip: +Use Racket’s identity-function for stuff. +If you pass identity in as the continue-argument to a function, then identity should just return the result we’re intersted in.
Another tip: +Maybe change eval-exp so that it handles the simplest expression, the literals, correctly first, and let everything else break. +Then, when rewriting each “feature” to CPS, we can test them with expressions where all the subexpressions are just literals. +E.g. when working on eval-arguments, just use a list of numbers for the args to begin with.

8.4 Done?

Run and see that all the tests pass.
Next is Booleans. +We can keep using the Racket-file we’re working with, or skip to 5-continuation-passing-style.rkt.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Some_Racket.html b/docs/Some_Racket.html new file mode 100644 index 0000000..3323393 --- /dev/null +++ b/docs/Some_Racket.html @@ -0,0 +1,14 @@ + +2 Some Racket
▼Make your own meta-circular evaluator!
►2 Some Racket
On this page:
2.1 Maybe use Dr  Racket
2.2 (function argument ...)
2.3 (something-else other-stuff ...)
2.4 A very subsetty subset of Racket btw
6.12
    ← prev  up  next → 

2 Some Racket

We’ll mostly introduce things when we’re going to use them, but we’ll mention a few things here...
We are going to implement an evaluator for a language. +We will write the evaluator in Racket. Racket is pretty lispy and schemey. +The language we will make evaluator for will also be pretty lispy and schemey. +On the whole: Lispy and schemey.

2.1 Maybe use DrRacket

The Racket installation comes with DrRacket, which you can use for writing and running programs and so on. +It’s pretty nice.
Some things:

  • Ctrl+L inserts a λ-character

  • F1 searches for the name of the identifier your cursor is on in the Racket documentation.

  • F2 makes a blue box appear! (or disappear)

2.2 (function argument ...)

There will be stuff like:

(+ 1 2)

(string-append "zeb" "ra")

((λ (n) (+ n 1)) x)

These are function application-forms. +Each form is a pair of parentheses with some elements between them. +The first element is the function. The other elements are the arguments.
Okay.

2.3 (something-else other-stuff ...)

(if (< 7 x) "lessthan" "notlessthan")

(define x (+ x 2))

(λ (n) (+ n 1))

These are not function application-forms, but some other forms. +Good to know.
Anyway, the first element is usually kind of important. +Like if you wanna know what the (define x (+ x 2)) bit does, +it’s probably better to press F1 with the cursor at define and not like at x or something. +Also, in the evaluator we are going to implement, we will totally look at the first element of a form when deciding what to do.

2.4 A very subsetty subset of Racket btw

We will try to write code in a style that isn’t very far away from like, modern Racket, but without introducing like a ton of Racket. +We get most of the work done by working with lists/pairs and simpler data types like symbols and numbers, and then pattern matching lots.
So like, people who are familiar with Racket-or-Scheme-or-Lisp might read some code and think something like:

Anyway it’s totally okay to use parts of Racket that don’t mention in the workshop materials. +We don’t have to, but like, we can, it’s fine.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/Towards_zebras.html b/docs/Towards_zebras.html new file mode 100644 index 0000000..f71a02e --- /dev/null +++ b/docs/Towards_zebras.html @@ -0,0 +1,34 @@ + +12 Towards zebras
▼Make your own meta-circular evaluator!
►12 Towards zebras
On this page:
12.1 What, if anything, is a zebra?
12.2 Adding stuff to our language
12.2.1 More list/  pair functions
12.2.2 Quotes
12.2.3 Strings
12.2.4 equal?
12.2.5 Recursive functions
12.3 Writing a zebra-program
12.3.1 Some lists
12.3.2 Some helper functions
12.3.3 The requirements
12.3.4 Return a list with all the lists
12.4 Running the zebra-program
12.5 Done?
6.12
    ← prev  up  next → 

12 Towards zebras

If we’ve been through the previous part, we can keep using the same file. Or we can use 7-amb.rkt as our starting point.

If we add a few more things to our language, we can use amb to figure out who owns the zebra.

12.1 What, if anything, is a zebra?

There exists multiple variations of the +Zebra Puzzle. +We will use the one we find on Wikipedia:

  1. The Englishman lives in the red house.

  2. There are five houses.

  3. The Spaniard owns the dog.

  4. Coffee is drunk in the green house.

  5. The Ukrainian drinks tea.

  6. The green house is immediately to the right of the ivory house.

  7. The Old Gold smoker owns snails.

  8. Kools are smoked in the yellow house.

  9. Milk is drunk in the middle house.

  10. The Norwegian lives in the first house.

  11. The man who smokes Chesterfields lives in the house next to the man with the fox.

  12. Kools are smoked in the house next to the house where the horse is kept.

  13. The Lucky Strike smoker drinks orange juice.

  14. The Japanese smokes Parliaments.

  15. The Norwegian lives next to the blue house.

Now, who drinks water? Who owns the zebra?

12.2 Adding stuff to our language

There’s a few things that are necessary, or at least convenient, for solving the zebra puzzle.

12.2.1 More list/pair functions

Can add some primitives:

  • cons for constructing a list or pair

  • car for getting the first element of a list or pair

  • cdr for getting the tail of a list or the second element of a pair

  • null? for checking if something is the empty list

12.2.2 Quotes

In Racket, e.g. 'a is translated to (quote a) by the reader. +If we want to support quotes in the language we’re making, we can match on (list 'quote x) +and continue with the quoted syntax, x.

Quoting can be convenient for list-laterals, like '() and '(1 2 3). +Also for for symbols, like 'foo.

12.2.3 Strings

Maybe we want strings, for values such as "red" and "zebra". +(If we have added quotes to the language, we can choose to use values like 'red and 'zebra instead, and skip the strings.)
If we’re adding strings, we want to recognize string-literals in eval-exp, +We can use string? for this, same way we use number? and boolean? for other literals.
We don’t really need to do any fancy string-operations in order to find the zebra. +We can totally add some string-functions to our primitives, +like string-append and, say, string-upcase, +but we don’t have to.

12.2.4 equal?

If we add equal? to the primitives we can use it for checking if things +(e.g. strings, symbols) are equal.

12.2.5 Recursive functions

The list is a recursive data structure. We might need recursive functions. +Since our lists are Racket lists, our strings are Racket strings, and so on, +we can probably get away with writing the recursive functions in Racket and just adding them as primitives. +But it would be neat to add support for recursive functions to our language.
One way to go is to combine it with adding support for more rackety function definitions, +the ones that go. +We can add a clause to the match in eval-sequence:

[(list (list 'define (list name params ...) body ...) rest ...) your code here]

Here we must extend the environment with the function definition. +To make the possibly recursive function, we make a helper-function:
(define (make-named-function env name parameters body)
  (λ (continue fail . arguments)
    your code here))

This should behave mostly like make-function, +only the function should add “itself” to the environment before adding the arguments to the environment. +It can create a copy of “itself” by applying make-named-function again. +(We’re really using Racket’s support for recursive functions to build our own support for it.)

12.3 Writing a zebra-program

One way to go about this:

12.3.1 Some lists

We make a list of colours, a list of nationalities, and so on. +Each element in the each list is an amb-expression with the possible values. +(We can optimize a bit: E.g. since the puzzle tells us that the norwegian lives in the first house, +we don’t need an amb for the first element in the list of nationalities, +and we don’t need to include norwegian as a possible value for the other elements.)

12.3.2 Some helper functions

We probably want some helper functions for stuff like:

  • Checking that a list contains no duplicate elements +(we won’t allow e.g. two red houses)

  • Getting the index of an element in a list

  • Checking that one element in one list has the same index as another elemnt in another list +(for things like “the Englishman lives in the red house”)

  • abs (or we can just include Racket’s abs in the primitives

  • Checking that one element has an index that is off by one from the index of another element in another list +(for things like “the Norwegian lives next to the blue house”)

12.3.3 The requirements

With the lists and the helper functions we can specify the different requirements.

In order to make the program go faster, we should add the different requirements as soon as possible:

  • After defining a list, we immediately require that it has no duplicate elements.

  • After defining a list, we add all the requirements that we have the necessary lists for. +Like, once we have defined a list of nationalities and a list of colours, +we will add the requirements for +“the Englishman lives in the red house” and “the green house is immediately to the right of the ivory house” +before defining more lists.

12.3.4 Return a list with all the lists

Return a list with all the lists.

12.4 Running the zebra-program

We can run the program with evaluate to find one solution, +and maybe run it with evaluate* to check that there is only one solution.

12.5 Done?

OMG.

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/cars.png b/docs/cars.png new file mode 100644 index 0000000000000000000000000000000000000000..85e911f07a69453941a2412c6de273436353e3bc GIT binary patch literal 21139 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 a{@ATE%5Qw4ZUPUIWbkzLb6Mw<&;$U;f0D-l literal 0 HcmV?d00001 diff --git a/docs/circles.png b/docs/circles.png new file mode 100644 index 0000000000000000000000000000000000000000..59bcf8bef14216eaff07fdc5ec983aad9ec99c72 GIT binary patch literal 22888 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 E0#O;^`v3p{ literal 0 HcmV?d00001 diff --git a/docs/index.html b/docs/index.html new file mode 100644 index 0000000..37bd919 --- /dev/null +++ b/docs/index.html @@ -0,0 +1,2 @@ + +Make your own meta-circular evaluator!
▼Make your own meta-circular evaluator!
On this page:
Make your own meta-circular evaluator!
6.12
    ← prev  up  next → 

Make your own meta-circular evaluator!

Jonas Winje (@JonasWinje)
and Heidi Mork (@heidicmork)

    1 Meta-circular what?

      1.1 Programming languages and evaluators

      1.2 amb and logic programming

      1.3 Outline

      1.4 Goals for the workshop

    2 Some Racket

      2.1 Maybe use DrRacket

      2.2 (function argument ...)

      2.3 (something-else other-stuff ...)

      2.4 A very subsetty subset of Racket btw

    3 Fixing the calculator

      3.1 Working with a file in DrRacket

      3.2 The calculator-code

        3.2.1 define

        3.2.2 read and quotes

        3.2.3 match

        3.2.4 apply

      3.3 Making the test pass

      3.4 Done?

    4 Lookup in the environment

      4.1 Some tests

      4.2 primitives

      4.3 lookup

      4.4 Environment as input to eval-exp

        4.4.1 Looking up

        4.4.2 eval-application

      4.5 Done?

    5 Definitions

      5.1 Some tests

      5.2 define in Racket

      5.3 extend-environment

      5.4 eval-sequence and define

      5.5 begin

      5.6 Done?

    6 Functions

      6.1 Some tests

      6.2 Make a function

      6.3 New match clauses in eval-exp

      6.4 Done?

    7 Continuation-passing style

      7.1 Not CPS

      7.2 CPS

    8 Refactoring to CPS

      8.1 Some stuff will have a continue-parameter

        8.1.1 (eval-exp env continue exp)

        8.1.2 (eval-sequence env continue exps)

        8.1.3 (eval-application env continue fun args)

        8.1.4 Our “primitives”

        8.1.5 (make-function env parameters body)

        8.1.6 (evaluate input)

      8.2 So that did nothing

      8.3 Couple of tips, maybe

      8.4 Done?

    9 Booleans

      9.1 Some tests

      9.2 Literals

      9.3 if

      9.4 Some functions

      9.5 Maybe: and, or, ...

      9.6 Done?

    10 Ambiguousness

      10.1 Some tests

      10.2 Some stuff will have a fail-parameter

      10.3 require

      10.4 amb

      10.5 Btw let’s add a list-function to our primitives

      10.6 evaluate*

      10.7 Done?

    11 It’s puzzle time

      11.1 Find the missing number

      11.2 Find the digits

      11.3 Sudoku

      11.4 Done?

    12 Towards zebras

      12.1 What, if anything, is a zebra?

      12.2 Adding stuff to our language

        12.2.1 More list/pair functions

        12.2.2 Quotes

        12.2.3 Strings

        12.2.4 equal?

        12.2.5 Recursive functions

      12.3 Writing a zebra-program

        12.3.1 Some lists

        12.3.2 Some helper functions

        12.3.3 The requirements

        12.3.4 Return a list with all the lists

      12.4 Running the zebra-program

      12.5 Done?

    ← prev  up  next → 
 
\ No newline at end of file diff --git a/docs/manual-fonts.css b/docs/manual-fonts.css new file mode 100644 index 0000000..6a232ed --- /dev/null +++ b/docs/manual-fonts.css @@ -0,0 +1,251 @@ +@font-face { +font-family: Cooper-Hewitt; +font-style: normal; +font-weight: bold; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAADz8ABEAAAAAgKQAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRlRNAAABgAAAABwAAAAce92mdUdERUYAAAGcAAAANgAAAEIDYQQuR1BPUwAAAdQAAAQyAAAU5m9JQYtHU1VCAAAGCAAAAiEAAAOGPYUP8k9TLzIAAAgsAAAAUwAAAGDC6LsMY21hcAAACIAAAAJUAAADZloTMqdjdnQgAAAK1AAAAAQAAAAEACECeWdhc3AAAArYAAAACAAAAAgAAAAQZ2x5ZgAACuAAACi+AABS/E3zEcZoZWFkAAAzoAAAADYAAAA2CUlVUmhoZWEAADPYAAAAIQAAACQIRARmaG10eAAAM/wAAAJSAAAESivaM/9sb2NhAAA2UAAAAigAAAIoyVre4G1heHAAADh4AAAAIAAAACABWwCYbmFtZQAAOJgAAAHOAAAFPm+7uUBwb3N0AAA6aAAAAooAAAOvrpTpIXdlYmYAADz0AAAABgAAAAYCoFoSAAAAAQAAAADV7pT1AAAAAM+3XmMAAAAA1jezHHjaHYvBCYBAAMOSKuiBL8dxNUVXtxwlEAJF4ChXCRtO9i4M7vrDW/8UjSEunu3rfPADVNUClQAAeNrFWEtoVFcY/jJJnNHaRM0k5jUaXzExim03XXVRqqKoVaMVtFXra6WoiFDEjZvSLLqQUko31W6qoC5ciGbTuAkiVoOE+ACTEhTiJIRa4ZLFiD1+57/n3rnzuJObydz0fPwn5/73nP/853+dyUUZgDnYiN2ItLCh6vjBMyfQiAryoRT0+2ZUfL53fQuav+jcxb5z21b2uzo3s3fnlB07evoEYnokVIGI/I0hUnNBS6vumv8j1mA1QmzqamiSrcKylTUt2ZZ6TVhCE9ORlSG3X93N4oykMU3ZDyj9KalHJVWvnEBgTmN5OYFlptLWCDD7dXD7GqmpINoE11jkjojkoZLqO2T7TeQns5ExU56zuf+HHULNalpXdQu0BYaNJUYNdM64dlB9rqW6C8q8rV5y5U11XfVm+ymNqeaxjgex8UhJ42FUbTGZwTVqgvTCxauM3COH/aAa9HpGjRu8mSF9J5zZ+dawvgmKqZMhxdcD1eXa43fBzx54okE/2z1rXtLM7jVrNJIzom+/x39/C/pc3M+YSQ77+4Roph5xbtKsIbLkPs3Zyee+sJ+ZicMmwuzK4swtcG5qMKgz1alexLgHOfXMzetkbpVz7jfZ3a4PF11c9mquOey7iB41QK313B6zRmMgN4KN3EcaObe1JdqmvJU4dzTpnT+lKhwsmkTuWOnlTj1HZ1Zf3mmjebku/H5vFPFbLQy/pYLpU5zfPPeFle9tEXYISd/Q5IaUF6WTqx7n4SX9at9klcbvfi1ZvlnqpV92+OVIsH3z5nFhuf8WXa0K/tILlOdjee0wlkaxdvCvPr52KKxvGcqhSH5vbZq8VWIWovKf/mzMEc4HmIsPZVSFaszDfCxADeKoRR0Woh4NGesb0aS/GyCBRexbhLeEtBTLsBwrOGrFSuG2oR2r0FGibwaVHoAnyG4x0d+BHscN6vm0mHqnob+JJAyc1iT6O4CQ3TqEKrkuynWaYmY/yPqEsSPEil4CZdoEWrVVaAGt41AN+XGStvFql9LN/gpj99q/dgx0+FiowlAQW9r76lYr/Sz3XR1poegUpTYxRkmzez6nJcS+jYyWxYwXHQWrJApWyBn12dp4tuWMCR1by2iL9hBiIJ53Tp0LPW4w0Ccod32ekOjV0W6jxQCivwPts6UGtkcruS4ukVUlmWBTtVCtsYSdDV5qNdQkOaGpntZxKEo7NXAHrWG7h9It4ul1LLTxJOWyZzUjQmsaoYyV5Ol8i2IN1tJrn+Az2n4dNnCXjdjE3TcTCXxJLMJ27KTvvsJuemcP9tFz5/E9V/9AfIQLxMf4Cb9Qyq/4DZ/iEv6gvCu4Rok3cIvyuont+JPYgTu4i07cI/biL+JrPEQfvkE/sR8DxAE8Ib7FM+IgnhOHMEQcxjDGcATjxEn8AwunkMJbfId3+A9ny9hw7j0TS3YjAAB42o2SV0yTURiGn/5tiSFN1RZKYippiOLChXtdGAUHIlrrQr1oUK+UEFouNErce68ojrj3XnHvPePee+95j+//0wsTMeFPzvd+5z3v+f5vHGxAPP1YhBHQh3tYOJpPCg7xlJbiFNgwsIvx42ifmxHA3yEYkg3mZMuGglmy/2ideeHIEAJDC8N5pOYXDS8kLVJUECE9qg0tLaXNsljWHrtrWt3GRYKi1iDNysRGg5h6cxkaxNBNnNBh+I1Mo8AoETtSsVy0ZrBuxitKMqmSO/DgxWt6NqfpUUk6TxlajKn2UE21j7ZOEk3USSKjrH2SidonKcs43BTH2OIYa9bg1f98Ot9Jb8VLUf41SaUWtalDXeqpmvqqpCGNaEw6TWhKM5rTQv1opYzb0JZ2jGEs4xjPBCYyiclMYSrTmM4MZjKL2cxhLvOYzwIWamqLWUIJS1nGclbwlROc4gznuMAlrnBNf7zJbe5yn4c85inPeclr3vKej3zmGz/4pczLsu1IBpl0ojNd6EoW3cimOzn0oCdBehGSrg999Vr6k8sABjKIlaxiNWtYyzrWs4GNbNKMtrCVbWxnhzqxi93sYS/72M8BDnKIwxzhKMc4zklOc5bzXOQyV7nODW5xh3s84BFPeMYLXvGGd3zgE1/4zk9+q7sudXoEEaJWzxM0Id9/WLt8n1YVrUDszVWV1qZJ6c3+5ZWnrFxhZfUKK5PLU/4BFQSHQgAAAHjaY2Bm4mI6yMDKwMK0h6mLgYGhB0Iz3mUwYvjFgAQWMDDoBzAm/AYyBUD8MB8fdyCl8JuJ6d1/NkYd5heMOgoMjJN9gYJMQsw8IDkGFgD/QQ9lAHjarZJZUI5RHMZ//6+NtBei1NtH2VX2IkKUnYhUUpSxhxlpmMmeJGtCmJElS8oSEpohY1y441Lm68V0685avuPM93VjXLjxzpz/Oec95/zOmed5ABecLRTRFcnSM3HMXSVR93NIxA0virnCA5R4iL+ESLjESrwkSYqkSabkSr4USLHlleWd5b0RZPQ1wgyrEWXEGPFGklEXYY2osKZYc6z5kZ0dFqU01aCaGhrFVbwkWMIkRuIkQZIlVdIlW/JkkxR10QKNYCO0ixbXRTvuoOVpmiilPqkXqkU9V82qSTWou6paVakzqlKVqzJVqkpUsSq0R9tD7SFmu/nR/GDazFbzrfnabDEz2trbimwvbfW22tYgdz+nAv/tc7d4OhTlL65g6RpZ/sFwnnTBVXvgjgfd6I4nPbQf3vjgix/+BBBIED3pRW+C6UNfQrR7/QgjXOscgZX+DCCSKAYyiMEMYSjDGM4IookhlpGMYjRjGMs4xhNHPBOYSAKTmKy9n8JUppHEdGaQTAozmcVsnYq5zGM+C1hIKotYTBpLWEo6y8ggkyyWk80KcsjV79/PAQ5yiBOc5gKXtPeXuarzVMN1bnKDWm5RTx23ucM97tOgk9bIQ57wmKc0a8IW8shnjZajkIsUsE482MZa8aaEs3p9q/iIL6v/0G49O3S9RhO7WMVGh5xeumxgpwgr2c0+KrHRxnd+8As7P+ngkd7xjM/iJu7iovPpLwH6z3Y6dfYt7KWMPRymlCMc5RjlVHBKr5/kHOep4g1f+MZmx/1fKXI+5Df1H6ywACECeQABAAH//wAPeNq1fAl4VFXS6K17k26yQqe70yFk7yQdspH0ks5Gku4k3bezkw1ICJGQsBNCCAiICKIIqCOyBEF0HFRGnZE3oqLD86kzw6AzMoi4O4zr/P4g6Mz8I28Yf/rm1Tn3dvftpEnk/76XL31vL+fUqapTVadOVZ3LsEwyw0Ame4jhGCWT+xwwM0qPK4OYb43PKYIvlB7nWHzLPMeRr4PJ18eVCrheehzI9yZVsspgUumTIeTiG2+wh9yLktk5DMMy5QzDHOTCKUxGbeL0Oq3eYmtX51V3cOHu5xZ2dGADbFcNIxAhb0de1bVh+atqIo1cuPBPiBD+yVAcWSu2m8YkYjuLyWpS0pdWT196K31J33cusdgs+y12y7zlGXPxvXm/mb63ZezPgM/sl/HPfly6HT+OeHBM+cgpdirHM+lMPlOK/FBGx4PebFAmQDxoFPoUA4LPhZlg0ujo3VxgMuqsnLEA36YblNEmThOts6ZnQYpCC88nbnY4C5b0bFyeGhM3M6nM7uQL+zo2L56qjatwtlTVlqhjn5jJF2pCgyrncPzWzEemDKZ9PrmlbtLsvqC1d0/tq1J2T/9mSmuVsmUBN+TOshUFFxSGXw2CX80ojLjIzjQzQUz6yFVuDadjYpkMppDhGSZZDwTNaIJuSrqEYLTJWGDVcuR9tEhHuoUzUyzxY3QJGAss0p3QIWJfVwmppQUzUiO793R3u/SJTQvz1ujmdvMu/MR3XyrNVeSW0gs2yxHf55Syr01WJmeGNc+d24yXsMTo0BnuP0mf5jbD26biYpOKXIRy71vC98yRq+wupEPP5DBlDBMsou5lMcE6klPqCgjnlTq9QWEwGa0Gij2nRZaXcR7EIWTJrVUllhkL5sxdED21KCH1/UyXfV2nY/bdisW2/+htMGVNT08xaorMSnNx2Oq+0OqezJIWayjf0cGHxln0uVrdfzbfwf1s6Zbadpvz3662EGczWxaS5cqKicnKmhqSWVSEYkHkldlH5ZVKa3Xj5HwipQz5zTSyA6ahDE0mEopEmCKJ8ETr9Llgaqivb5o1q6m+vgHmax55q3/g/D7NvvMD/W9hvxTsFyr2A61GodSXAZUqUwJAqKzjoOaRMyuljivPEP0JZkLhd7CRS6L6E4YQ1AQvpV5p1U0Gg1Vn1SkN+G99yhKc9bhqZ0R2VkfKsSn3RSzMbNZzSXsURmPGI4mDMZuNGRlHEzfEMJSOPGYXm8HeifAYMGlRvVB1UbUgzP7nP+M/eye52sW2GSO7mINMBzOJYaxajd5iRCU8uNoWPKOD35FZ1yG2gTJIhs2UZxaTNuPfUFZRgd9TG4F9OdIXu3V0EKsAzGTkRwnyA78HNAhQ8rXja46/XsG9LtqMMpSZWJSZMEaHEM0Fxmitigi9BcwoCPge5dlSNvT9EP7D/icUT+A/m73ijjtWCC+QK1Q9/7xw6vnnyVhWBJjGTWFCGWY6WEwq5BUKJ5smpJx5OfVq7ls2dtXt1qPufNK2ENsm4bhxiG+yNtkC4jxRrdFbzJKOKeHvkCfEwKwcfVe9or3V+f3QFoNZ+Nxmy4FFuY6sUGfrwhUx/xqcH17abhXOUrm5ijjoUAMYq8anixaTTCu98L0WCRVl47OhfN88frDf1dFVG9reTIbaUFx1b/+m23/4fQMfyddXOKqV1c09K2P+tbpr8tYs7bzqKV3rtt0aRvnosamhRPKS9RakCGnX6sMAeQAnnMJxaKreutXxr/bH3s5jI4QgG/xOuB0gzotzOIFhNWnkBkRpUCNzOLnJMTmfDXX19tWEFPVEl6rhbWFdROXilbt2rSJ4ds6NmtthNUXBCZtwuXDr2vC1d267leJnxTGmI190zHSiGQhaoZSBxQGtZcCRr+NlRkzPBrf81FKocyxbunX7mlW7+me+sqK4OxZ6axVN3fMaOF1FlcPVw2++NXT95j1bws7vndUo7C01Tk4Mnb+6u1XV2kVlthgRSEf6QlDCVMla0INSry2GK8L79ZDafwm+h5hsdxJ7Bj5k6PrhmcNoXEEKGCZIRI8aM9m0yewuRZXT+38Bhy7cu3nDlotbNpZUCf/m5/W6kG/z+JDQunmdvIbvnBc21DVlR172nZO7Vq3qmnxndnQXTigEN/KRrtpaVyTfCEubqiZV83z1pKomwsMZiFcyxSuDYXQWXA4KrN71gSIWCWryrWf6CDqmFuRgwVTneRkDp7ISA8OQf45ep5x/sLLEmDRZxj9p/YfnxXWdaLfao+EdHTCX6Dkr2g5sM4kJl1kP2pBakA7RhojNqV1aj3ZpH6PAOUnTRoA2LQ+uCQ1wXJgET1/mT5/mL9Ox85gRbBch+RSWZG0wvkjTSXAN3rLbz9jto+EBtskBC5uBbZ4TGuFpB4Un2ptY/P0XyMOpTDzCE5URuaclK5M+vYyzmNM5/O4/a0ucnYOn9CZTOjuDTcjJTbLGdbAfDPSH3/ngOWtrUVG7tXB+5Uxnem2t+y6P/5M8ksM9hrCLGQeac1zbdCjaDE4GYzJSkYlks8AgiTv1OUxKFV30clnPdKmNVku6JElwVfHK/Un7PnpXuA7M+fWv3mqo7SzLDc1f1oN/S42hBQpTdXFc6dItNYoTn38xPMtsnuV0Og8vyRoC+Dzjc4C2k3clzF5vi3W1bu+N6d3e6tqLPpjG2FOb0LGrKeOrNzLe+gxCmt5r6m6MaewWaUCusA5Og9wOJauPWm9IVuqBMwmLv2goFL4qbADNpmuc5vqVN99kfy9UUX2pwT4q1K9IJoZJIb1EYaS6nQVqvUoyfpz3Xc3pZduGdtyz7IM/793r7Oycu3Wrc+5cLry7T7N++vQdmqV9MCC8w/OTeR46ha8rqqdUkzWmCOW/EPlLZo7qGS5AGh87VVq9ZGC3dS5UHq257bYdW7fu+L81DXOUPfNg8Ojwm6G33/nimxlvvihcjduw8sCThN4aSi+xDbjaUnwRx2gteO016zi07+zZfYeEui1D69YNbYHBU8e48GOnhJ8/cCTjyANE9hAGuBEGWmJiLlXSqwaeF/ZDkfAGLBfquXCb8FWF8K5Nav+tZI887fU18LjwJEwXPuSlpnuoXBOaK5HmRK8/JSNUMjdWsqKrFNC2+76dO6+5GjsUfT0LVyiXFm4/2x524o2M0y9Rgh96IuPocOnZCuHtDnG9J7RbRLxxsdCj+48TpEqGb3leeJKwngu//j30C3vQKzqC7Rux1wHJX8KmB3jyO34msOJHrsIz+H4KhSXNiklDnFYL9PDzly7vrCqtrirFDcNfb9uy+fbIpd3diyUcpki8U4GJU+s5pVav2gPpcy5ebD61BMcQWuGXwstCKWzb+3dsKfLvAr4LJus8xfiC0M9DDcK2eOj6hMoj8Tk4HSFrGqWQ3f+V7asgvu+rr/p49gH3avaBY0IidhtgdyOlX0h9XRJPVHqgfcGgYl0NwgNBVQ0wwBGi2T0vCnrs1/8i/EXUGzJPTdSPmYYrRhKdqSSiAcGylZ8q9Rnh79u2wZS7hH8oF3aioOIljEoluQwNH8VJohcRrke3JlOpJ9gYE1hqSvToPZexkvHYw3+U2+DKzHQ15O7eE28yJyaaTfF7YKbwOy5ckzuvQlPRmauxRSTZ8ybn2ZMiPDgfpjhPYVK90kVwnkKdc6vOD28iZwao2kFxfzjTrk8JKVkmor9QGRVS4aVB+KB8ZVfQt4csVz2UwC/8aVHRfZ+PFiVOuiIQOffc07gpPCYwQUeyhRfQafOnCZhcnIcspCkbP/hWRpm+6GQ+l0m2Widduntgyzp+VofSNb9l8ebBnetu28YvaFbOuqUTBpOeCV0wcMemmFULXWWTbK5I1ZLO0MVr794YurCvyRFSXSOOjR4sXEH6lFR2VOiEaSGNPw3vs2+5LexbNqL71YhfsagnyHELSq8mGlWE3BVQvmUj33aynd8YNrSTjXVfXtHWvpzVur/eOSTp2DVqq3CNC9ZzRKShD83y6TcaJnEadwn7e2wzfeQa145tUCuDw0Bshf8c2/P4kYUP1m18bMFjG+senMSedhdjn2r2f5PX9SsUfqJkC1H2TWraE9UxDBK//LL1tdfavvqq+be/gfvhDuFl4IWtwhqYLTxN+2mxXw72w31DGq6dImbV/MWGV/9P45UrV9gkoQjeIHsHbBcmwreiC0bYQ3zvDNiy+Ro6kls2Q7gQb2QPczaju5ezUdiVuH9Q4/6BRhTQMOCr8tzOnec43n79lLRvke0xdJxJfRW3GOu5169XkN8yR3YwP4j9dcRK4uuHc7t2nVtv50rt+HsCaOh8EL+BEItblEbR/UDDI/oP16h/MbIBpoz8mo6By07e5/dUUPjr2UWQ4NlD6vTr6zrQYh0V5T0HbeJpNp5JIJQnexf+ckAnQy+6HmUslU+dAY246PrCfWG2jc7m7obHrFXVBZUqQ2PhkjmK71aZDq001bQ12UIbnOFTI52VVSUhycUFSYu6fztsbH1wqro9JN2MY5bimJdwDzmF7GzUKp+LTYIeKrUqWjJH+pQdxt7Fvb2Ll5tCixWO/DZXTY2rjUsSXuT3rItZt6eFH2Z3CSuEH5qXdcd0L6N8zkfYHyM98WRvQy273/or6hkhbH1tXbW9clHfqv7+VX2LKu3VdbXu+ctri6bwyynwVTUaW/3y+YRH6GvD5158jTpUBGJ8JKDoDak83pDQY3YoSkLzVyDW61rM5hbEmI3noda9btjZTOEKumZQeBBmKb5/Q3w1xOtLSx6NMS7zBtxwJKfD34SdwQdr6ipXLxlcs/rTVZ+56lnIU155pSYvqHrF3nXRa/ftXXd24dxXRB2BOVwWkXk12U5TPTdRH1KnJaj+ev9+R2trC58TH2Ww5LN3DZYLOfBu+W3NdWEzQ7IZEa8c+BTxiiNyEWwZ5RCKIR9x6fQSj84k7DEtXNTXt4hOWO9HCyorXDU2cwtfW8u3mKHHsXNl9Ipdzc5h4Y7uVSvnRtS7auCj5oWt0e0LZiHeqCrwLvJZ5ZEKLWJOZkuJ9x1Fq+tbHTML5psdKAHHa+fXCffD0uKSZmEIu/j2AOwl0Q/HnaWKuPYuR2gHG+X+jr2ELjA78sxIDm0TQUbRqUQ3wGAhhIitCVc0aZb8po5stsz9a5El3KwOyR9BjYdPcMAwaQSTknoDNsf12SdONA2v5JLcn0DMH4SXQLP+MLZ3Ya8HaLyEtnch8tc/x+9LEeGLVO9wJ+wl0nM3mHSE1ZQH7EUHYmMWL4riUMuqZYmmIWc9rCua0SQMem6bhvmWOXOaa0XY8C7CjvKDLcJEt/FdkYsIqmhDfavEQ+xf2z6/jpHLJI13BKX4NpVBol7S6YY7Ph0Y+HRAeP+hurqH6sL2ro1Zu5dcWpfPj5m/nFworNKRQriEsKjuBKcYfIgQledkug4JvUaClHkZKo9bUvYwp3CdrULSqO7AAZmuEzwL4TMvbNUoGeXkcrnXvFAyJCXKaqqWrhbzm6BwUbitrmH3K2yrCLqZzjPhoR5hkxiZEVdgrY+JoOGULBfZKWKLzkFlk3Ar8s8xS/SF4R3sl47ajKpsTjd4QoseyzN6eYfg8uqKWYual847XV3sLK0sae6bu+KWJb2OPHOO2aAMqS5XOGYdD5pZljcnWzHJzgc723qrgwaJnuNYPexTVM+JmlNStTQCQhXe9Ounn863GKLic/iW1lYHG1Uu/KE0O2RmWF0zVJQPUzpnIoz32CgiK2qTCMFn3iwzq2cWdBNRCSu4rb6VjRIOoLDAfcJdwzVtXfWk/1S8XMT+uDaZxOX4/K9rDz9SexIb58E593fSmn0M24SLvq5nudfDog3zBh3zbmu7bZ5jsAtOCaXYyQp/IC/s6PVXzmLfMLp2Wclqj6uEWteyY2fLz3/esnNHy1E26uOPhR+E7z/7DEQ/X4dycQH7kBih2oR7Zitn+vdDta/Wzmp5tXYBrpfshQsgiPBTyV5bhO9d703a5FTQr3sc1ggX1r0sbMiDJ6A8T5gH5WKfqdJ6nyBGiTz7yGicAyqB6XoLFeoCE6jzcgsKcvOiylsycnMzWsrRJcgpPlcfG1d7rjjHXlF7wZxqTzVfqKXrtB39gB2Sj4CTYHdIHoLkI0CqOKZOhG6VhhJVCQenmCj0maOGXE9GrI2LrR8zIoGbBhWsCX5HY8jGaCkeQCyGoeA564FMc25GUQveC7IzrPA7Z2FGHXkRWztSiHY0SrS1Or3aZMBl6wDNt7zJxpN0C4mbnmJjEeckJtOX4eBkm2Ky3ntVltPo1CnEBVbB8YTtzsbb1YncAefAan1CfFnK1s23h2nivnVtYENY7jjHb85+OuaeVPfV4CMRPUOKDT+p+jLu0SfZNULe46Xw3yCMMJ74aSr62bjfJztujQ4nKFpHIqmmXM6AnEu3eH0C4B3Vuj+8lB8EwULMk9yUyPjgniZN/6I1S53sB801xbfYXllgt6c1mxZE2drqFqwd3hr+JRkDVxHWib5VNI01ixogJYnEKLYhe/D+xjNnGn+yZk/5Oxf4C+fK4VE7ZAsOOCm8Z99u/+AD+3bklW/uiReJs89RCXA44D54RahyXydXbDcd9fVDpCmfrHaeAIY+xbuP9RgcD1+9/g41O1ol/i59wtbwYWf50q7TjmIHmp1Zi+Z2li2d94aj2FmCn/rm8vZZnM1hbwqyOeDu+frUBmqHSsvzs7JzFZOqXIqu1JSmUd8FWzKDLTPIBXG9jX0QNnjWY7K6IlMs52cLs9lLc/CPxmVKRq5yXUiPEiXQxDAFU3B3N0WRxE6JTiqYkp6kFt0h3EmmULLKQNyPiUTRPd9lqLt8WXjh9fOQcf688NF+e4lNk9lgcvYYDD1OU0OmxlZi56urPxebXWbThI/Ok7buLyumR0w15ie4FpXElCxyJRnNsap8ey8fw/eKMdZ05j24hea8UokXBKO9YxqXG+Ua65ItyZAVMmOudaZz5mD6jLaZlY9VBr/gMiyr038ovA35cJelbGa+ssQSqgrJz52ttNbXOR9clWNdooqYqYhN/UuR6MsYmcO4hhOfP4LwTqnTGixp4k3Yv/8M/Gx4+Awb7hgcdBwsOyjepBjj+2wGm0PiDmoLCZbkwTU7fFMpPAXaG+dGghg1qwQr+oxKuotPY5goQhrx88jeD9d8HU2HEaEmToTSnAVak9Gibl/f3r6+jO/l+d7BhITUaQl6fmqiPi4hIY7tIj+1nyI/8fP14ZXl5b+MncrqjDEEj7vZh2AV+4kHj7u/YR+y20n8GP4KC5Dnk0mMgrBZnju0aj25RmM0ZBdOV0wvpBdL+/Z2/Gc3KrPN5mxltsWSH1Td3FwdVN3SQuOzP0Oe7KT5Kr8ME0fMvZRl+jNcY3feW3nvvZXC41K8dipsRzsfRdc47OCNWcuSL5MB1D88mqSP5ypKbi8r10y9FU6a036ZnBSckNISdvvMXGViZtxWhBUNd4AWYWWRuGDAnIss5eLLODTbguPSU+KtlrgUfVxwORnDZKksLbexXGNigjIu0RwXFxSbhEOVZk8qnToNfVWbrVQp2vYPcN+3Sdz3gUmph7y6+dLGj6Xr3mv4WxT1QMkOQZVLorxlbAmoQJPA6lSRnBZuzXDk1FUbSMzml8L/iss3xsUZ8+NIrAC1UTujo0xTMS9Xc/17Nj7XlhwJUA+RybZc4ieDkXkIdtH5Rcoemg27UOOBOYL7ij7EQIOrhlW0WHqSA1MSqdLoU45MjstMiCuLVyfmaYOmlyye+Vr25EhVIqdrKkw3NIh0aXBetFwEif6C3ptDA+3Vrrr4jVnzYLsZlKbsFuFZHD0DdXgjyhOx0LE0eurdCmqDiWjjhxQtFYSNbU+1tbW2tQrfmZeZzxdCJVs+Z8XK2Zo5K1bM0dhrauya++4TtpK07Gj9BItOq7RY08QbKM+c2SccOHNmP5z2aSfe0JkmdHMqinskyhX1/lES1VQog/VgkhEUrLSaLOxfSn/6s2Kz2f18BVtRIVR7aLx/fkpJ13Rgvrd0ceHCRg/F+/fBCmq7yDhKjuQk4ontMiFo9Y1l2DfobjKM1V+khePSqFy4O2OsdEOzl99BZB1E+qKQvgKmmKxRMvrgJgRfjQhzfgxYeyNV2EhQzvXyA46OpxluN7JrKuESy8ShLD7LRol5Fp1v420xl3FWUzTKv4bYps9ri/nOwVt6ZYmWlo49ixeHb9zZ02pttZrr8vLbykoc6ZvYmo4OynESozpB8xORfhkKzqTT+2UpPq0p5X2ZCvbZfmaC/kr//r01ZeP3V/n311sRA4MfiNcdyyqWOapkUMr7++0+OM9TOHGj8NCIbqJWT1XJZPQDGW3MSk2ZrUqTbjLQP52RW5CFL4boggj/iERnlP8IkrvgB/fxxiuNMmAH0T1yePH8De4D1WTVEDP0GqUETJ2u40ystIq9a22wZoEE8ous+ZuuvZCcm5ycyy00WK0GSyyBzWlilyL01eR7krKmuhRP49uII6D/qJZeBj3FFSxwUdieCQnC5WyYJjwe/6/aeqh5+ENvPuXcOfY1YZaUK8mh+aE8f/vn2SSOTpsQkZwMkm38u8c2Ttt0qzdpRNNIF1R+ttKhfPF1Xwopg2SV/hGRK9lPVsoFnRDXQ3k2iEQH/TJCdxDx9FDBneifsL/Sv/+/iXiO0z9qVH9RPP1APCKJpxcKT6VTyukhnCPeOhQ5JEl8/ECdJOLjhXOESg/BR0VzRic8vjfd5esP8GWUeJI9eqaftiO5pffl7XDZwnallEhfu5FLeHXTdqESPJGuA3yShxjSulQkhBtx4/US0iHW1IiQiYOCrwP8ocaGRrH9sIgwS7jG3onyGEGlHU23ZMizQKVW0QC0FFOJGjq779ChfWf599+niUFYXQK3HDuVceoYrIYO4YsS4ZyYIGSlnNLzOH68f1bJMEbVZXmm9lGKPirtdNij7ZyUezpBc0+J42efiBQGykAF4XwEzEJxW/qpPNzUGMqAY2zGufzRY6RMMIY464GGSRHlIPBIUZJcSGM9T8fKmYie0bMUaNgz/tMVePhBn4lGGy3icETiqX4CLCStCzR2OSpf4AFXiHJNYjGbWTP7ExqLMVjFajKd0tAy4+OPPf+bZe8pjwqknKYWsZtObb8Y/pNlFNItaWYDiMWHyRodiPn3om07VpUnFBeU3rVjqCKpuNgKf0oQ3s7pQlyF22NhRs5sfAeH3nyxNH9u56uItq2ge95LGdtrhbCK4aNbnfBfxcNSDkXMl53A9UcTIGNG1nxf1uwrIsSjM2fcb/p/DBylDM5SIqgTwtEFgiOJpRfU7yVhHAOtRfIDRHhHKF4xgSB6pt0L8iky2WPgPUsnmpVycSfEOhxvNs5A6JMyct8jdd6sHFrV0XlZrTfDjNtQvUotT8vu9iaZed6XleXCHxVzzLhdeRTN07sRSZV5kXmVnpysDWlMxP1vDvHmyzzZLxKS98SqlTqpPkaK2+Lu15xuAEW93V5dVenoW9K3pNxhbOQnp/KmW+rLViwv42EwN7O1tLK+3uZ+gl0wf0X/PGXFgpwkc0dxcLLVnLDAGTy4OqtqBuExzcMhfSQPl/3jM3FUuMbJxmXUdfATZeTYT46K6+n/EAdqS8fBYTduO/9HOMy4CT5IQj0OGlz1trJt1V0TYmI+enS1DBf2KsWl+Gb4McYWj4PWa9bstJS5qlTpNiF6L5vMBVn4Qtss4ndJmq+8m8DQo7Dj4GWcLcyeEJmXpDiehAvaYYJLHom8/lhc2FFxpvFwCkLv3dqgoh77hLjdQtpa10pevDSfXBEbj7wqIjtTv2yrIRICYysmzYJJPFUppZOAZmS5ImFH8CFXXdXqpfcUJa3c03JLw0+9KG9PKdi0akCoCo042G8yroYpfunaxTnFY5BfuHDf2l2ROUUxIvrwnJjLJXlYks/OD7xfiJaHQj3UeDcMr3g3DL0LvVlumveeO2f0juHBVb6kdwxNhFcunuTZM3BiThD1kuSpE8bPVBOTFDhbLXyH5mhsyhoyj97kGHQtDDxGB1qbGw0xaozkcceQnPYbDPOtaE3GjnQXMR9BUg71kkRLyvjUSM7+DYZSzW6aHYAipaR77Mg3eN3tOdNCssxkVXA5nkRmk8y3t9aDlJd+J29HLLfLoUaOyduN/BHXwEjaLlSCJ7LC5dgiUk3z6Ys8dnLkW7xeluL8Ul7c4xK4HLUk3k/z7x58pTnIwpWcREMt0TqrVulJinpTuOmGdIPSYk2PkuWc83fNX1szLb7cPPDpQP/yJvO03GkZv7itqoCmoNnLFWFFVdZMbaLjnWVSMnrvjFpTXNxCqzPZPTovTXPkV3EvlRowSz42wjEqb77Q3277p9HhVo+VlsscyadPu3FGne57/LLq0TiDgTLr7MqjNwVXOQruWZzxHwk3YRy4koL4gS4RJSQQdHiDSowEH3kfJlba3xjvMVPgN5TbfwYCElTrmwefTor8ShxnZM/66DfeAEpywEFqqGRzuO5tZTPYe737eEuyVilVoufBtXPYCPrs9vvwdpy299RZaJHLBilDOiYtChqdmq5HySR3SktV/2YyDayaXTjNQu7thXHCqzFfp9nq6iBv6teGiro6Nqq6agjRzEurcqyhd+FyrREKMpbPr80X/mggVU1EB2jun+YAogNm/4lA+lcAOKhJ8a8CIELzY2ApR8ESqNkZH9bUwLBEwfMHt9xjmvwhikLHSXUOlyh+sQGhgmSF/cGCE63vGDRrvLaM1hrQusJwWbUBCQx5Kw7+hIR6qw5+kGyxjdTFcElinguxkRXBqfRqX1WM0uYw9pHSlT6jwykVxeRzScILYuWKS/gBGnx1K5xU+3CJ4jNFhlGaRJ0XK4hGwrxofSgSxDLxIzns7ZwG1y2yd9R4KgIsZiuNpZrUijAwwT8TYtNi1UlFK8sLaCB18Rctv910bXF0XKRZ0+Oa8Zs3SZQ2lb1Eiu9JjWEOuFHOsxjLaJjj+YgKWcHhGs+AzZMCeIctD1P3UBq/1WgJ7BumtnuLEL310IW4D40nnsD41fpEfANU7H9YQzZ5Y6v22bh+aZ37GGWDwh+/GpHAD1CReAZFJ1BVIvzrqB/+qRPjT4IigUiwOKqqHMsqAlNRWelPR+pEdHDiOAFICa/u6kIVDUzN4OBR6YwGyVuQcw6xgU86WEX4ow88TPIQ4Xfu4TJBXzor1S3VbyZNUMFJEqWBqjjhlhJ1xo1LOdkrJ0WZ+v8RmyX4WxD/GJq1RRgy3HGJsNBaL6283o21dHoIWNxjvvtuh8NT88aeKBZiPQTwPy9etkz4QF73VoP6b0L8Y/3i6XpSMeJTW/mxEWjxqGaB8HNvdD21UtTFylyplpSsc3qy2sv8YGUk+IEVNzVjS14dlcn5nkGyli4dVf1a0KUOLUwThyvOUewZ8JXCjptrECXJL0EwWxQjWcaCStDN7RtABHyjLdBZUQ8CbVGIFnjsUiXiTCOaE52oYcl5Rw0qvibg2ZrZw47C44WBT9hwvN3qdFol+nLgU6SP1Psab6LiF4e30uGjx639tT7RBEXnimD8GmD4VXfzunXNhAe1iNXDUk7EmxE5wNc1eXMhYtyO1tfSOjSpvpbsNaR5v4A8DCYnmKQTOGRWxFM4wjM0Z+O2cGv7fXujs57cjriHInujMNIu6frnfrmrC6iLMricD+7LaCQIWPazk9jWRWyYdFZatt+qIY0IzKSTcpjhfjCJ9ynCbJlDIMIGcX0mMCv8YNJd1nOzCUSpxoLYoBhqg9ACERcH91dU7KOG+I8/Rur7IaSyFO4SfjZgXy18aINqkZdJpE5ErG329dOrkrocAwMOUDgc8BPhqTZHm7AZ6hhvzkjKA/rnjNBE+7JET0gJMnlq6BmJn3Qf5vEbA+7DkLn+O689uCiO2m4dPOqPT5Q/PmnSquFDSTjpUfVRaIkKL8drauAqaknL/VEThkXtHo0e0WzUa1S0u2gMW8xSm2TmiDig3sO5RQf3sQkes+T+ct9BeKhvaO3aoT44dOqYZJuOnYK50uk+yT5xi+m5h+kkbuof25Lpsl/hC+52tGliCGKxN5h1b4F5x6qBgVU7zOTuVtWJu+vJfhGsdevoRmjdun1rdeIuCC9/ojbXc9byBI3V6yc4RUWYeKOTVA8R72qc01SXZTJkpvl59dhqbTpLfhXbZrLxkFVt/+3oKJzTJ8DZIM79jdAOlZyR8TCX1hWWnkVspbhHj8VdGsgf/SdEEfOjQJQv8VzZCTEWfFMny6iWjXO6zE793IlOmLHN/Z71C95BmtJJ3e+PrIKnQYobVcK/gjM2fjU8e+Go52xdDj1bVzE2Xiqj1zAec7zh0/e84dP+IYkRi0bxaPPK0XHUu9Z42BEZiF89Q8FSUJXWgtCzAsWBcDVNwDcvls96sexod2wfy8EFs0ejuKAiaPAG3LS3BfnqRHzyZLppeRIFdxyR+qvHZZ9Yqjw22SdXOT9arjyY3Ei04kRtmki6RNeM7Pfp+UlSWxXpO0EprS/iQUrhXpEyz4FKn67T8xq4vmrFuEagExsEjP+pDeItjD65sf4k48vLkrqnGLJ2j8nLjkmtePOzn8kSKWPztE6/zIkUO0GdikLfNyVg7GR0sbB/DGWZbLQx8Zl/ygfjpNzwEU/8wpcd9sTIpQzxcGOD79ymVBlDn/FAz28SP26yWPXKyU5xwgy0Y2/5HeVEx+76N/LjnFJt7C9o/Hs0DBPCiENj9Kj8eAgXftT9R98REQ8OR6T+hAI5DuVNb/hjcMThuL7bh4I0Po2nj+5Pxo+aMywfncTV3U7ZCRUfDxRiTR2VTTkK94sC+vYoRqCcylnh40NAOIhKlag7j/szA1VFzg60c3PYRXBYPL8qhe4ekYJ1nhwCyxxmO2GOdA5gTO35YbkA7RmV1wNmPrsNhtmrpI4LxsaMu/3DxOw3vpCwVA9/xlMPn6zNQMRJQbznN+512W/cQ77fytka5ldcLH0+gsVMDt8oTdry1cl6Lo+t4Xdk6qdLzyJiS+lzySaRqgX584q4cOmBRT/mmUYsGQ/sdDy1fES99907dOwrfhh48WAJHpBF8VDJMDH5DXdFhpc4Mn1mCmRR3FQy7AL065B1Q5qqmD+DC76gteeqZBW4hP+GL4QfQIHf3I1GZSF9DhONk5OdXbL0+qwDDpN/6Y/wWkGePRbMSc8eK2AcTDuz6CaeP5bm9wkmeBpZ8M09nQx2e9657/E9qIx9wfegMmHgxz60LGyCx5f5LshfI3OYEVhRp3zHQjwnQkQZlbcRS9ONsqJ02maE6PgT4hmBLADTYVJLTR+XQZ8TJj4PyUD0FlcnfJHzN14PQJms1GvRJngCj8jfFTU8XxO2dmV/j63CpdytgtCkb/8j6beq3cqdtnMr14LBVmp7bM+dd8dtWPoPfPuPU6H/vYfKp5qNgg9xbVTS/IF4PEOrU+oNOhIzQ9OD6+O2TMeJr60zrGxmudVakcn+cPFienrcmTOVOyHyrbeE/9qJOJegbDWL+gYmUqsLeoDfdAkPswfdi6GvS9jIhQsP24WHYTul0UHb66h+WkJAS5Z0B2yH7dgIzF1439gFfe7F7EHG277LAz8EgZPzPhvl7Ug5vrAR+sQzJA7cl0n4qC1ka49DOPBH6MM2t8nxEu1gGvMJa2KnoxVMHHsizxrghF5Btu+EXtvoE3tdnhN7Z7xH9+gZoW30PAy1JMnSUw2RVdITDfMg21nKP/hSIyiE95ylzt0nmuAt+6ZN9l30wkjPPFqNMB5G2SKnMMizkSxpKrywGUIvHCZPPhImsS27djqPOY4JEdZj1tF91DlgCdYGay1p2jx4WOiTHpdUsXMXj112kB4EVzJYlBjfQTOSTDPJUfRwKEfPlWrpOXfxSUkBz7qDFCPxP/MO4eRY+KiD7+4K70Fx0V+j62iW5K/dEPoYyGPh0kPfDPP/AL0TOaUAAAABAAAAAQAAxsl5Gl8PPPUAHwPoAAAAAM+3XmMAAAAA1jezHP8k/y0FAwPBAAAACAACAAAAAAAAeNpjYGRgYHr3n41Rh1Xzv8p/FVZmBqAIMmAUAgB58AS0AAAAeNptU09r00EQfTNLL/XQmMaWaDVpTWpS1LYJqLHGmmqkiZSAeEh78CIiBD+AoNhTRA+CIKKCpx7Fb+DJk1UQb2LvRvyDeNGjxDeb/ZUYG3h5v93Z2Z1981auYxL8yQr/NomPWJSLqGoTk8Sie4ppfYQZbKEqZRSJKWljmLE5rs1JDTmfU8cI504Tx4kTRDHsUQxzJ8P3rK23XNsjgrzGXveK669gv9ZR1xZKuk7OEkLc7Y3xGQ35yTUF1OU76u4gYw+Je4yXAy+TV3FUHcaZU7U93TryehUprWCPFll3GWdZ+wh5hucfkDOs4RduKHBEkzilw5jXCdabxrzcYl6S4xiWerV3n8tvVPhdc1mujRFc5/P2cf2Kzy/JA+bFUOaeSX2HlHQwLp+I98jw3CTeYCmcn420DxqafrstzrvnWddN9wQLcoe9GELB60XdqfkoY22eM+vnDiNJjHHuA/My7FlF17DBuYRsUG/mujQSAWPUfMLrvQNcFQnfg2zoQQA6rKuDBjrdr8QffYn4tv6DaCKjt3HM96Af1gPr1QLrM713gLtGth6k/wW2ut94r2XyW+KHn4/0H4R5qxcv98N6wF5VPNt97Uy7q50XsXnP+m/3M7b7214Rmx/pCWpxwXxgXrS6AvuxNFDTQ4izV2mvkdUZ2L1AyT3mPvSq90uPY9639M5/TC97P5l+do/Ix/TSILP/TeIZcZnIuS+9N2pvzr/ZFt9ry3NO7uMc4+2hPKZlDgUDNrsZajeluzBqviPORzCv9r9bjQN6CSmk/gJjI7OIAAAAAAAqACoAKgAqAD4AUgCCANoBPgGWAaQBwAHeAggCHgIwAjwCSAJYAn4ClALAAvwDGgNMA4oDogPuBCoEPARUBGgEfASQBL4FIAU6BW4FmAW6BdIF6AYWBi4GPAZYBnIGggagBrwG6AcWB04HgAe+B9AH7ggACB4IOghOCGgIegiICJgIrAi4CMYJAAkuCVgJhgmwCdIKDAosCj4KXgp2CoIKsArQCvYLJAtSC24LpAvGC+YL+AwWDDAMRgxgDIwMmgzGDOIM4gz0DTQNZg2KDZ4N9A4GDlQOkg6uDr4Oyg8CDw4POA9UD3oPtA/CD/IP/hAgEDYQYhB+ELIQ7hFEEXARkBGwEdQSBBIoElgSfhLAEuATABMkE0gTXBNwE4gToBPKE/oULBReFJQU1hUMFSYVaBWMFbAV2BYAFhoWShaKFswXDhdUF6QX6hg8GJYY2hkMGT4ZchmoGbwZ0BnoGgAaQhp4GqQa0BsAGzwbbBuEG8Qb6hwQHDocZhyCHK4czhz4HUQddB2kHdgeDB44Hm4emB7OHvgfNh9aH5AfyiASICYgMiBKIF4gdCCIIJ4gsCDMIOQhBiEsIVIhfCGqIfAiKCJKIoYirCLwIy4jhCPUJBwkXiR8JKQk2CUOJS4lUCVwJZAlsCXUJfgmCiYoJkYmVCZiJnYmiCaaJrom1ibyJwAnGCeiJ7QnxifUKAooLihGKF4odiiOKMAo4ij8KRYpJClUKX4AAQAAARMAZwAGAAAAAAACAAAAAQABAAAAQAAuAAAAAHjazVPLLkNRFF2356KKpAZEOroRA02oVjyCmQoGXkmlTNHSGy3Xbb3+wgf0A3yBoYGRxxeY+RTr7HsupUlJdCAn3WedvddeZ+99TwEMWBEoWHY3gDp/AbaQ4CnAEURxZ7DCIu4NtjFihfwOxKwRgzsxbKUM7sKNtWVwFBvWm8HdmImEnBjqkYLBPUirULMXjkob3IddFerEkVC3Bvcjqh4MfsSgejb4iTrhXc+I2nGDXxCzhwL8qpCwh5HFKTxcw4eLI5RQg4NRHCDJfRJpZDCFMWLN08wimQ5WuV8yoyb8HCqCS6iSc0K8R+tgiayq6OrTOs55KtJWzB2fiqUGvRS9PnOSLe5clMgxq0uxRr0WkMca1wpRWPfCF4XG/PEPhVZ9Nd/yNz2X/TucjcOTz73AaIW7zzyHWYdtn3OqzXp5estce4wVGdvmy/EE6cxCU67+Itl//cZKcvYwjwmun/gT3/gXMo0jxnVmhZ4cs4J5HBifJ5VeU+mETAeboq+rXZZOajInl2ztrUp2jfZKIocy8eIv/gs79O2TH2oGrzbHWei7Nui/EO+c2Fl2kME07bR4gu8wSx1dvyf9uqL1WWUOZ1RzGfHJKb8D4qLSVAAAeNpt0FdwzFEUx/Hvic2uLIkSJQgRLSHBJgTRU7UIIlGirs1mE1n/f/yzK0QfvTPKG6PNGIxeB8OD3hndDA96Hw8YnWTvjid35t7Pmd85d+7MJQDf+jOWWvxnSWj5DpBKVMJEIGYsVCYIK1WoSjAhVKM6NahJaPn92tShLmHUoz4NCKchjYigMZE0oSnNaE4LooimJa2IIZbWtKEtNuKIpx3tSaADHelEIp3pQle60Z0e9CSJZFJIJY10etGbPvSlHxn0J5MBDGQQWQwmmxyGMJRhDCeXEYxkFKMZw1jsYmILc5nHOl4xn+UsYT3b2SqBLOYhc1gtZrGwjIWc5rFUZgM7+MwnvrCZXVzkPLsZh4OV5HEZJxe4xHWucJVrvCafW9zgJntw8ZFV3OU2dyjgLe9ZxHgKKWICbjQ2ojORYgxK8OJhEqW8YTJlTGEq05nGUTYxkxnMYjbv+MAxCRIrv/jNH0GqSFUJFpEQqSbVpQZf+cZ37klNCZVaUlvqSF2e8FTCpJ7UlwbsZZ+ES0NpJBHSWCL5wU+e8VyaSFNpJs05Li0kSqKlJS94yX0e8YD9HOAwRzjDQQ5xlgXs5BwnOcUJacVSiZFYaS1t2MYK1rBW2opN4swu95TiAj/xFq9WaLMl2fymKpP9eXI7v4mWJN2la84ii11pTnXYDV0z5ylSHYZu91jS/ENO/1Ca6joVGXaH1+M0uxUZKnT7MGXk6R6Tu/wwZ6q2pshUU5oiS4WGIkuFhmKwCksU2Sr0+AjMMQo1V6C34jTnqoEyH9bc8iftDodT81jL/pWmNK+hB9kNQy91O/M9Fl/lLbb6NApdBR7VzNNLtYoPik9IT6kwPdkW5zf+L3vc64QAAAABWhICnwAA') format('woff'); +} + + + +/************* Start Cooper-Hewitt license ******************* +Copyright (c) 2014, Cooper Hewitt Smithsonian Design Museum (cooperhewitt.org), with Reserved Font Name Cooper Hewitt. + + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. + +The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the copyright statement(s). + +"Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. + +"Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. + +5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. + +************** End Cooper-Hewitt license *********************/ + + + + +@font-face { +font-family: Charter-Racket; +font-style: normal; +font-weight: normal; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} +@font-face { +font-family: Charter-Racket; +font-style: italic; +font-weight: normal; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} +@font-face { +font-family: Charter-Racket; +font-style: normal; +font-weight: bold; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} + + + +/************* Start Charter license ******************* +(c) Copyright 1989-1992, Bitstream Inc., Cambridge, MA. You are hereby granted permission under all Bitstream propriety rights to use, copy, modify, sublicense, sell, and redistribute the 4 Bitstream Charter (r) Type 1 outline fonts and the 4 Courier Type 1 outline fonts for any purpose and without restriction; provided, that this notice is left intact on all copies of such fonts and that Bitstream's trademark is acknowledged as shown below on all unmodified copies of the 4 Charter Type 1 fonts. BITSTREAM CHARTER is a registered trademark of Bitstream Inc. +************** End Charter license *********************/ + + + + + + +@font-face { +font-family: Fira; +font-style: normal; +font-weight: 300; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} +@font-face { +font-family: Fira; +font-style: normal; +font-weight: 400; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} +@font-face { +font-family: Fira; +font-style: normal; +font-weight: 600; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAAHAAABMAAAAA8dwAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRlRNAAABqAAAABwAAAAcejWA8EdERUYAAAHEAAAAHgAAAB4AJwEvR1BPUwAAAeQAAAzJAAAufsATCxdHU1VCAAAOsAAAApcAAAeEea4ezk9TLzIAABFIAAAAXQAAAGARTEjhY21hcAAAEagAAAJeAAADfi1PSJpjdnQgAAAUCAAAAGUAAADcLqwVBGZwZ20AABRwAAAGcAAADW04JI58Z2FzcAAAGuAAAAAIAAAACAAAABBnbHlmAAAa6AAASaEAAJVwJvOfpWhlYWQAAGSMAAAANgAAADYHEy/+aGhlYQAAZMQAAAAhAAAAJAe1AsZobXR4AABk6AAAApQAAASkYRswlWxvY2EAAGd8AAACTAAAAlQv41YUbWF4cAAAacgAAAAgAAAAIAPMAktuYW1lAABp6AAAAjYAAAWWeXHCQHBvc3QAAGwgAAADDwAABL0OjfQ0cHJlcAAAbzAAAADHAAAA5wgX+o93ZWJmAABv+AAAAAYAAAAGTJpaEgAAAAEAAAAA1e6U9QAAAADODu7hAAAAANY3/RkAAQAAAAwAAAAWAAAAAgABAAEBKAABAAQAAAACAAAAAHjaxZp5kBXFHce/82BhWY4VfMDuAgvLsaCIogiiYhSWUzQqhwcpSwOxrJQWZRGLqqRIwj8oHonGxOCxnlFykERiguIikpD1WI/VuCTZlCwxj+NVdDxeGYcUE518umfetfeFzq++0zPd/evj19/+dU+/J0dSkTbqAfWdv/CiFSpb8+11N2rK9euuu0Gzbvz6zWs1X33JoyBQjMBp922K+s1dtWCcplTNXWHuy8z94ksu4r7skou5r1i2lHuORmzNTd+6SUNuuG7dWsVtjOydFPXTEPvukGJy99FLfV4YEOO9SAVIEU+Xa5IqNZkyT9LJmqpTNE2n6jRN1+k6QzN0pmZqls7SbJ2tc3Su5ug8fUWbdItu1Wbdptt1h+7UD/RD3aW79SPdox/rJ7pXP9UW3af7scuDekgP6xE9qsf0uH6mF/Wy6vSa3tCb+osa9Ff9Xf/QO2rSP/UvHdRhJfVvva8P9JFS+kSf6qj+q2P6n0PLYwutxa7QTu3Vfn2u/U6JM96Z43zV+Yaz1tnobHV2OgecA6QiziHnPeRj4MUGOe+htT82LDYaDIudHJsemxWbRdznJj9ah3LkvayQZkOrFYn2cp9lkM5rS0Qcj+c5aH1uWkf7DnCPaSljsA/00/AgqRFBQiODlEoDT6OCRo0JfBUqTszwYBupvkpIKeN9FDlHE44JXKvrkppE10XXJ7Xe6sZ4ch3H5imxaWltF23P5umLtoe2F9WaggEjqTvMb/KafEnKGm7r8yKNUfbtGKV7GhC18SjlHEP7GNqNUW2mJpecqUhvZKhrWzUgqjtlY0tsz1PopEv3bC7HvjmOo2JzNzHc62nnU0GttoMdQYN2BbXE2nzox6I6PNg9BHaO0lnOOF1qywpL9G1O068C7D8EezrwZxB1nKChGkbcCI1UiUpVhvZojVG5xmqcKjSeuTElmgOzYf95Ol9VWqgLtVwrKOMqrdLVukartU7rtSFvVtybw/9qZoBh/hN6FrY9pxrt0vPaDUP/rFrmg5kLB3VIrj7Ux3D+KA2OOUOdYc5w2F3qlMkpmGJ5P1gTnaed150jsbjzdOxCsNF5um9l3wv6rtIaFdLjMno6GkwIdmgS75N5ngpmgJngLOJmB4/pbMJzsOi5QZPm8HxeUK0FhIvIsxgsARdiq6WEy8FKcCVWX0Xc18h3NeH1xG3i+RZwK9gMbgO3gzvAnaRvAfeB+8ED4EHwEHiY9EfAo+Ax8Dj1P0m4Ffwc/AL8EvwKbAO/Ruc34LfgKbAd7ADPgp3gOVADdoHdYC/tqwUvovsSeJm4V0AdeBW8DurBW+Bt0AD2gYPgEDgMjoD30f0AfARS2O0Twk/B0aDaiQVJ58Sg0YmDEYDZ5EwOEs4U6u2nE7DWMFAFP5lRDqx3zJw0KR4pHikeKR4pnmPmwkAVozmUPOMIK8B4sJr39YTV4HlKJ90x5Q4mt5cpaxyoAOPDctHw0PDQyK8jrRW2LV8r1Uwr2+ZvotWAVjWtS6BZrXJsMxaMI74CjAeTeJ/MfJsKZoCZoCrDKxdeufDKhVOuLqPUZWA5zysIVxJeTngFZVxFuNryy9U63tdT9neI22D5loRvSfiWhG9J+JaEb0n4loRvPnzz4ZsP33z45sM3nx41wDm/A3658MuFXy78cuGXC79cPUO9zxLuBM+BGrALPE+ZuwlfIH0P+CP4E3iRdoR88+GbC998+ObCNxe+ufDNhW8ufPPhm6u/ofMuSICDxB0i7jDhEUKXsj4EH4P/kO4xGrHAhwEJGJBghKoZoWqnFB6WYWfDrFpGpxar15JaS2otKbU2xSfFjIdPik+KTwrjhBeMh6NKWA7GgiqwCB4sBkvAUrAcrATGA1xteWlGyMP3xfF9cSzoYUEPC3pY0MOCHhb0sJ6H9Tys52E9D+t5WM7LzNBXeH4VvA7qwVvgbbAPHAJH4GK6xyfSn7jpm+LMuFpmHH3kuRSU2V1OX3Y1RXjKOH7cweM+oYGOWVEGKTZhr/GhYxdX3I0Hn8UeqiFoCrygPkgh2DZwzTqmiTwnA5+3FFZLsuLVqYC8CQN18zLlc0/mx9m7b1P9CKYtqTCNd9MuL8zXpdp8e28KGpFUfmym7lIbJoI6VvBeutpvadibvFYW97Qu+mdsFtrQPIWxydxcoUXxWE3BZvqbBMwsUorzx6OlDZmDvdj/DrXNWDRZSeKnR4b9sX0qSreUtHp2RLkjWh49JzO1F1nu+K3WscPWsQO71Zgao+jB5McjGcsQy46LXaiCWuK2Z2vLHckWlkr1Anv8Hugm7axpbNlKO6/ScyyZO0bEJDIzM4VVUq2NZVvzLz+WXVRziyTyYwxLo3mZCG62NSaaa7esKaw9v93Gu3WNaZ3zIVHrvLz56rNrDmdR6J+8KMWNemn9Vo6tU/kM6ahe2FwDkqARZprQeN5IbI46pMGwOpyR5Glkd9sQbMWOfBOQatbVeLDH5I3KrO9NLnZnVls/E1mDtnrhCBoGWD/lpz1TxkeF/WUnGWwj3fjtcMyLrYdLtpx1edxy0+21WqmWY5mJ8TOjVIxWXWjRrN/oaC6Suz7yoKbsUrte+dkeRfZvsCOWLSkesaZTPiqHG7XGEvZ5D3UYO7rWiqnQ05Nu/GEy7YPI0Yifrw+20MIao20tEg+2pz15/jzNW5vq0cnaqyDXA7TJkKJIt1Pez7bI5bssy5F0P5pC/01Mo7VnurWN4XN0T+WOQzTf3PbY2SytnO/j/Ks0b9TnROtxkU0pt0/xTI4ivoXjUTkmvahFaTl+o4NVu/m6WtSNGeb2YHZ7x2d96kmbclnRqYwLc57nRBxq2/LhWK1Ur13NW9mT1TvvmtDjlrl2RejOVdw7Y9iRrTJ1+V8ce7vb8g7ncqqFhp+X7rVrhXC8mrpndbt+NdvbtNLe0q7NUbOedc7qrezXjuXvSrtp9tKucyO79+qiXm3+CtaqfeIt6uoecxs60c7iZmxq6LhfreYo6vpMsd/8X+jVzuxKRbuqxPFcbbrmAewupFM2bf411bVvuV5rfEEb8eU2rTgvX0EmJZ5ZLxV+e7D7TOV7QuOzbC89+72cjW/sdft/lv1WMDvo1rnTXS7Qj8Zc3S+K/9R6rPOzM7gn+KhXag2/flx9WVdpL+wO63I9QvY7qz3+dHuMavLeDwc7YGCdZf6O/BXky/eXnepPsrnFwi/nzFdzU8v5G32hJdv3ap06X0nk7g5a31nZuuz4mjOinlon54whcVxHxc/uVzo6L+v6PoXd/O60jw2/lDutubWtcemMP8nuZI+T1RLZ8xB7UpHq7PiaM6Iu7ISanxF1yf+FZ2pd+R4Oz4hy+9mJHbffvfUnPCNKP3dm/c2crWxpq13tnxF1zxf1ZF2NfhGqsb01J0R7WhuDXvoqjOuMLuQubzcl3quz5doucMKcoR1Xj5fjYbaxIm7J7HrrO1qRW2NoR+wIrrU771r8hZtdbdvws81+Y8z5tSiV/UZNtzI6R3ynxe8ViexK1PlVoHtnQvaE28/apXW/m++1wt9yWtkHp5rbtbdPS4LtPSzgjB6ktryWZjifwCb1LVllvWLC+v/6tr93886WU+1y01GhU6FB0dtie1+iKs0H0oAoj7nG2vcBmocssbIoSo0R20d9o2+uIeqn/iq0uYvAQEofTGz6H1onRrXI1jCCckcShv/YCi/zry3Z/22ZOsP/bpmTxImaxL0y0p9PSW1dC8C86HlJTnw6bmGrWn3oSZ9I0teAqNehLAFDIhnG81jan5US+8+zUMw1Ckn3I5QltkfhNYHnCdYC5t+csUxdph0lFgWRRfpjj/72aYx9Dv1xua3fWG4gNjIYpIoMBtuRCGFsXplBbs/avuYjc5Gq6D7PjtaCNiw3xvJohKZmYk633+Dj4cL4ZnkLI5yGFFgxvayIYpUJR2VmUFpjKrVMs2M0GradmqnH1DAJTLQiC2mGvVciEyOcopncDSsnc58e6feLSkrr5V79bTvzTx8qc+Kyp9sVeVLYqpUKM1IApkVi/zNM+3NlYkZkZ8C4qA9pKbDvoYSsqUCrkNjCjAWyCOMqW2lRpUVWL7zM/4bTMHN/GnkMjM2nZ6C80Wrr6oeciYyP7qfZ0eqP5WKUWWi1ByHmX6LDiIvbf9WORPrDizLSR5N3AL2bivc4lfEqYWTPJ7YKOQlGLtLJzKullHaJLqVdy7QC1lyuKxntVbpGs7Vaa/QV3YRcoHXIXK1H5mkDUqWNyHxt0t2UdS9ymbZoO6X8Xn/QjXpGu7VWe/UyGnXIBr2GfFdvIN/Tm9qn79t/PG/Sfh3QZr2L3KGEDulOHVFKd+kT5EF9ilTrqD7TQ07MiekJZ6hTpied0c4YPeVMcabod/8HCOJD8wAAAHjarZXrS1RRFMV/d2acatQ0s0mGCgszK7Mye5dkqYT5YhokRCLR6kOiMRoVREH0zt7vtz0+Rn9A36MiIqIiKiIiIqIiIqMIwdZ96C0JGR8c7l733rPXOnvfe/Y+GECAo7zEV1hcGiFUtzXaQPb66NoN5DfUtjRSiU8+dHZaaODBG9ObLPwF1UXpZC0riJg2bNqyilLZcEWZbCS8QranTl1tQwuhddHaOtKbovWN5Ddv2thMoeWRJJvYvWIcfoYwlGHKIJ4EzZg+wy0LI8ggm0VilhKhhnoaaGEbu2jlJBe5wU3Lz1D2fmEcl2k3Soydxm3r2TA6bPRkOljlYKuD92z0BhwMO9jmYLuNvnIHbzn41MY4v4M5dhxxn5VXgjLbzma26J2XUQQZLTSjTBGmkaf/YT4ZjJS3z8k6ScNDKmPlM14jsdc5m+3t1jO1GTRVUydZc0FyY9Ls4tkMk0ufeAYhXam65ljfMXmAeXR9bYMcR6/3KHAYqZqZoe8ZG8flBYW5in1BH5guO03eeczTPl/SR76rEdLeN9fPZynF/VBxlcZoR9uxFLJcddc/LVdvnOq7K64SygkPQNFVTVfPcGOsVHdYNUBdV3uCutHf8VZRzepBUHdXyFC3+zf2Gtaouw3OGvY6BlOcTkoMu///FeiLmZnirJtsdfYiVlr93fSGJo0AOzTiLf9gD3/zroqJZDJJZ8lkxT1VXX+aane6qnGmKmuW6mO2IpurnTlfu2mh/v1i/aPd7GEv+9jPAQ7qTDjEYY7oLDjGcU7ohDjFac5wlnOc5wKXdDpcoY2rXOM6d7jLfR7wkEc85gnPeM4LXvGaN7zlHe/5wEc+8YWvfOM7P/jJL37TYXiUW0BXkzJysv0DynOOjgB42mNgYeJn/MLAysDC1MUUwcDA4A2hGeMYjBhtuDiYuFmZWRkYmBhYGhiY3jswLPgNVKMAxAwBkUHBjAcYeH8zMQv+12Q4wSLF+EWBgXE+SI5JkGkzWB03ALa2D3oAAAB42q2SR0zUQRSHv7e7gmIDaUv/gywgNrACihUBe0VRFMSIGmMjoLGCB7EjIMaCiprYxV5QEZFEOXjXGDHxbywnj0YSwR3HhRgSD16cZN6bkvne5Pd7gJX2GYzoiBTqnbj2NsnUeQ7j6EIfvepJEYeoRom7eEmQhEm8JEmKpEuGZEmu5Em+FFmaLG8t76x1tjeGh+FjBBqhRoQRZQw2kowcoyY8IrzS8dLR1mpR6nc1zTRczLNikx5il1CJk0RJljSZJZmSLctlnWzuxMTwNOxGcAczsYNZ7mKKZor6rj6pV6pJvVCNql7VqvvqgqpWp1SVqlQVqkyVqhJV7ExwOpyRP1PbYj9YTafZav4wW8xv5lfzo9lgFrx3vq9ozmqOdYtq1+Q/DzeLh0tp/qILlo6V9R+M9pc27Ywb7nSlGx50p4fWsxe98cRLO+aND7744Y+dAAIJ0p6GEEqY1jycCPoSiYMooomhH7H0ZwADGcRg4ohnCEMZxnBGMJIEEkliFKNJZgxjdUeMZwITSWESqaSRzmSmMJVpTGcGM5nFbN03c5lHBvNZQCYLWUQWi1lCNjksJZdl+v/72M9B7f9RTnKOi1zgEle4zFVquMF1bnKLO9zmLvd4wENqeUQdj2ngKc9o1ISNrGQVaySAbZyngHVisIW1+uYAp3Xc5NJpNVs7abeeYh2vUc8uVpD/53wDOyWQPErYSxWf+aK7vI/4ib94iw9PxMFzWrT0YRIsIRItMfrNdvEVu857KGM35ZRymEqOUMFxTujzY5zhrO7v1zi1ZYWuOood7QV/AV3srcgAAHjaY2AgE7QBYSJDIpMZAwOT0//PyPz/H0Ei/z/CxTYD1QgCxdWYDgHlFP5//K+GkAOKfGZSBIr1gGWhbBS9nxG6maWh+lOB0BMI7/43YXj8XxfGZ3rKaMv0htGMQZGpEgABeTrCAAAAeNqtVml3EzcU1XhLCNlISGiZlsoIpzTWGEpZAhgIM3FccBcnQDsDpZ2JHbov0I3u+4J/zZukPYd+46f1Psk2CST0tKf+4HclXemtehoSWpK4EtYiKRt3xehSgwqXroZ01KWDUXxDdq6ElCklfw2KQdFqqRW3WCQRkQjUwppwRBD7HjmaZHzDo4yWbUn3mpSbubp20NkZ1Fo1KtTCImVL0fK1sKiKbieU1Gxiaj5yJc0xmosimVp20qaDmOqOJB3m9cPMvNcMJazpJJKGmmGMGclrQ4yOMzoeu3EURS6spaGgRWI5JNFgMliB26B9jPY1krvjosWMu3mxEkXtJCKnHEWKRDNcjSKPslpCc66UwJd80Awpr3wqKB+egxp7lNMKnsh2ml/xJa+wj661mf9pIK61KDtbxGIgO7IDBenhfAlhWQrjppssR6GKipGk+Ush1lwORle/R3lNA0F5TWRsbAsYKl8hR8pPKLNyg5wWrKD8rEcDWrKpw/AlJ1Ykn0DzccSUeMGYOqjXBoZFUPNni/1s7dCbszdkT3HKMCGA37GsdVTCmTQRFi5ngaQLI3tWIp8qWbAqdm6znQ5gl3Dvu7Zx07A2Dq3tHMqiPFxVjGaLHo3oNJOpUTtZ8GhUgygljQQXeTuA8iMa5dEyRqMYeTSGY8ZNSCQi0IJeGgti2YkljSFoHo3rxuUwzbUXogM0sqpue7RLN5bCxiU76RYxP2nmJ3QqxoMrYTo+HpCT+DRW5ipHNfnpCP+N4o+caWQiW2qGKQcP3vod5BdqR2eLCtt62LXrvAWXh2cieFKH/XXMbk7VNglMhZhUiFZA4uya4zgmV5NapCJTuxzSuPJljYZRfDsVCs6XMdT/OTHhiDHh+504nSiU6U7Z3Y8w7YZvk2WPpnTqsJxGnFnu0WmW5WM6zbF8XKd5lnt1WmDp6nSA5RM6HWT5pE53sHxGq17cqRAjwkpWyLnOF8Sj2Q2L0/3Fm3axvGFxpr94yy7u04JGyv/Bv6fg3z7YJeEfyyL8Y7kf/rFU8I/lAfjHsgT/WM7AP5ZPwz+WB+EfS61l1ZSpp6F2IpYBchsHJpW4epprtaLJK5OHW3gIF6Aut8miSuYU99BHMlz2/nAvtelwocaVRodm07wzVQvR/9jLZzeEZzvOES2PGcufw2mWU3tYJy7rlrbwvJj+Q/Bv4ayaS484U+zrUcQDDmxtPy5JMufRMV3ZU/Xo+D9RUdAt0E8gRWK6JCuyzo0Aob3Q6dRVHZ0jxBuDRovucNxxpnYjwnPoWNO0C7QcmmjJ0NIh4dOOoLzaqSgpqx2ceXIzTVbseZRTfo8tKeZeMr8UrmdkVrrrmZns3sjn/jqIVq3MDrWImx08eE1j7nH2AcoEcVtRNkjaWM4EiQscc397cE8C09D11SJyrKBhkR+nwcBowXlbKFG2k+bQPJCMPAou/9CpOJG9Khkj8N+0HfS+LhTCqV4sJGbzM91YqCrCdLq/RINmfVHVWSlnsdoPITtjI03icliRVbzdbH13UrJd3VRQoYTRhY2fCTaJW1V7N1uKS/7MBkuCXrpi/pZ40OVeis+if1Q4iou0KwibLl5SWY0qacXZjXt7btPqstvctDq/5d5H7Tivaa78KIW+ppPlDmzjGoNT21KR0ApVsCMwLnN9ztjIJzSkfOs6F6jC9ang5tnzF9CY8Mb0tvzLkq7/X1XMPnEfqyq0qg31Uoy6dtbQgOfKvagsYnSyXFTduHS96YegjhBM2WuPbxDc8MkKHcUtf36b+Qs4ztk9SceAL2o6AdHgKNYQbrmIB7cXrRc0FzQ1AF/Ua2hhAC8BOAxe1muOmWkCmJkl5tQAlpnD4BJzGFxmDoMreh298DzQK0COQa/qdcfOhUB2LmKew+gq8wy6xjyDXmOeQddZZwDwOutk8AbrZBCzTgYJcxYBVpjDoMUcBm3mMFg1dvlAN4xdjN40djF6y9jF6G1jF6N3jF2M3jV2MXrP2MXofcT4VD+BH5gRnQX80MJzgB9x0M1oHqObeGu7nFsWMudjw3G6nE+w+XT/1E/NyOz4zELe8bmFTL+Nc7qELyxkwpcWMuErcKv98742I0P/xkKmf2sh07/Dzi7hewuZ8IOFTPgR3DP9834yI0P/2UKm/2Ih03/Fzi7hNwuZ8LuFTLij13fkMr0vWr9Mg6uUPdC83Xuivb8ByjvTswABAAH//wAPeNrNvQlgHNWRMPze657pGY000tySRiNpbt3XSBrJkq227tOWLMuSbMuyLNuysY0PjDmMjcAX2GASbpxkQ/KR5EuWJA7mSoCFJCTZDUn42FyQzR3ItyFZEpZkD4JHf9Xr7rkkG0iy//8D0oiZ6X5V9ep+VdWEES8htIydIwKRSNUXKKlufUQSd/9b3Rf0uh+3PiIw+JN8QcC3dfj2I5J+zzutj1B8P2LxWsIRi99Ljf/6jW+wcxe3e9kEIYxUL7xJXmIXiJFkkSK5gDAmTBFBGB4gsNg0oXScDlqsdqtoyi2P1jfWOR12vS8U9QuR6upO/O/krpzT7b7qap+3pua79Fm8Zy99iB6DeyKcLtnOKNxqSqCUDpNBi8WSg/eywR3w56vrvYefgx+4JDv2Js3G6/Phlweud5Micv3A+drhCbnELDGqFwE6yrZl0oyM4YGcbINAiHEqy8SMxtEBHRWEEWHQLYfwDf4hNZLti69TvzgpFxYUFBQVFBV63Pl5uS5AzGa1qP/kWEyecuqXIg6/5I/yn4YI/4lI/EcHL8wz7O5eY9/lOGjfZe9YXdA9An9fDT+dsX92X1VAv/LixIfgn4kXJ++HfyZffBHIQIoXtrBsYYyESYNcV5DvEgTmMTIqGPQCACz0A/oAqjBHkGjjQH8yhZcNBQuCdqRb0K6XHP6GUDjqjNQ1NtSHwlW0ob4x2hBxOF1SyO/TO+xOVyFl2dunth4e6uzb3NjVOLhzdnr17PahDnl1bUvT6OatXx+9MuveuzP7V3VEayqiLu/Wvt7N5gfuzejobSwPB6vyi7YToiPywk+FTvZN2EcTccBuBMlKeQWSk/YLVOilVN8DXMIkwuZgp3WipAOwqTAN/LNugIiifpro9eP6QSCszW/zBQ2mgnIjDVOdPVLXUO/3uZCV6hsjdU6bHd5Q/r8BmYx9J1azhr4YC/f19PS9NX3v5s0D/Zuf+cAH/h3/vHea3XexJ8K++MXNM5s3D8/M/N2WmdjKGeXv4dUzMwQg7lx4k/2RfYUUkACpITOypaS4yJ1vFqhBEPWUCKx/4HwOMJYL4GTTwPbrOGOQaaA4GSHAR+7EJ4DlCP9Yk4hJ2Vzoqa70BAoDZT673uQqpy695PKH9X6OQZRvSoRLi+RqlOqiYdwXAbZmBXyC28TkfcGmjz04MHX9vqNtHdHqHTMb93a3f8j/28HmR3uWl3lD5WVlgVAJPeTdv+bOjjU7Jls3ltf3VfZsnOhqWVt2z8p/jHyurquuiX6noMbvbvD6S0tRYlH2yFe57NnkHHxniihyl8NMznJN4lDaCP9+wcJOWiasIdlEfyFLpDXl1hzgoyqhfgWLuvQfbe8bqW5c7nYvb6we6aP/FvvlP25valt79OzDZ4+OtkXnlHu44R6lyfdozAH+LBTsZiaFGz+Zco8XaeE35qJto/wWa9uatsP1OXQD/Qx7jZhJRM7JyjRlGA2SXicKjGaRnoHz9uGJx3FX1sCuPIp/HJyUjbCwmZiZyV5OpahLcklhKRwNR11h6rSd8J2dm+rr2rT1rO+4jb121/Jd7h1d8ze173bvar0T1hske+mvgG1NpFvRLg5QUbC9IhG2waZzko2KwAL58GWRjiV9Sqk4BW+JQwCCoin0pvxyWwTED3QFCKZ/8J4998B/dM+5c9seeIDTp2RhLXmJ3AXrFcruDMCA9hOU7HF1fwgdclhxe1QFm0390RDq1rz2VaW+Dl9Vta+o5e6Hc/Fe9VRPZ+lu2N9c2cGVxFhCSSibTL0NXjobe4lWU/12fJ/reFjfqPGEysX25EVB9FSNrmlzDvvEwt30vFAF6+kvgAqvKadC2EbP/2bv64LjnRvzhXlQWCUga0aQNSOxkBI5mNABIsDHRWicDVKSbTZl6EVipEYdbFuwDrgE5CCnkPpCOQBCDs1tbmxsbmps/Nzvrr/+d4fXHKb51x+O/esNM0/RjV96KvZJDk8E7pgB/J1BSuUQcIigUJMMDyC/ULYJVhthg/BOBsmwWOw6kM2gBXgjYok4vA1Ud1/Lz/afio3O0m9vWHfLxfOzswoPg/TQ/wIc7KRMDudkM1BrQFbWjwZRVWiqMI3QQX/IYkNlTEG6vZK3QZVpYHYQefqbYx+lteZY/6NHmqv6lq2ZPLXjWrow8sSd2zZ94aHO6mjv8n1XKms6Ft6k78CaAdImt+ZRUZcLXOYF7a8HRHSAmK4f6A44gn4VRd000ekADABrGi4fJ4P+gNcPFAQGBKvg92kmoZxGFdOgQYRKyFFI6Ttnr7pz7cCy9ct75peZS+tWttUOreyYmp87PNDcPvH8+utmOzvaogc2NtRV1q/oHd/Wv2JdliiNK7AGgO64x2ZSIZeiAqX9BomJvSAYIB5UIHHJAfoA3VXJCKJMeBtsLgHMpiPCjENHYq99bffD95r3Dp07d26cvlQam/3sZ5U1QsBHFPY2j8jycgdleqCDgHQAswirgA0/SvQEyAP00OlQEMXhZHr4QB6BIJLJnUoQeMtvgX1yIDEYvePA6eFVDcOtPXuryjfS27JjsZqm8b0/n7tlpqt9cMXNLrpz+rPOa4GvSwGeDMDZRYrJCrkFHBiipyLNp6Cb+gkIoqijIupAjUN0Oo3b83I97tzivOJQAOEBTuGmWVJ3w++rYtw+CD5JAZH+MFJev3KNTt64ds+x7fLMMs+9x9ft6WsUDkTq2X0jnmv3Dl29Z9eZ+g1XdT7ySuzvB/55uP0Mp1nrwlv0T0AzPeoWVCW0HyhFepJVvw3FHA0vKoY/xf79OqqP/SP9Ilt/8YEga0IBEMAveZPlAK424gHfBKTY68pkIpAcSK+YPcCPMY3UeXklIUUCJAUhsHrRkGLzBHBK0NrVNaK9Q0b06emf9t928uqDNx3feWzD9JG5zrHR5QeWv9zS1h/ZFGG2TSs6rlt3cP+6gy0tu9du3hgba2worJqsa2mlN1U0Omt7Sutq0C8MLPya86CNFKKU2oH1GDflNgoIC4jGLMCoQMsGAyUBDmM0EA37/KplVsWB1quuUqRuI9UVwdY2bBrbf2buqvkvv0SzIq2R5SC77R1for03bJu7+Z5rv/5yLX16dlN3R+dK5FXVb6Zvo04lrQPnHWhFgFJ8/0eTnWe3bEOfjqBPl3h38nG7Pd2ptqQr4lR1TG/1Vld7fVwvM8WmwPromXU9phgVBQwr5ws6E4cGneLcBAyphgcAcTiSAeHGJxUUboYUYBLGiN6ZAAfu1El20t+yJuBDsBME7EQlbQi6sih9NnaCHq6IPU9bdz58zcNTZ04o9BskH6ev0u/yGMEnF6l6btsii6aGC0FgXfyXvhrbQe/Hn4/Pzc4tta5N59CFK+k+ejh2ooK2xp5nTbDu5lO3Kut6QOd+E3goHzRatVyBmp5ycwyGRDgKf2sunyCI06BgxsVBe76/zKIz5ZVT0GX1K8QUzWoWpDitqPPavGB5MK+ytKt57fpjW3cHGxqCZxTCUXN+Ubgt6M8POr3BdnnHps6K9nCw4fcJW8vIsoWQ8BWArZo0kdvknGJqEKONdkFnAHJIAmxvJWxvGREzqEEnGubAuVYF00hR80DcwEYGiCRxIR1DH7Y68WWB6YTx9EtI2hWTsq22piFS01TbFPD7A8FQwGcCp13nAukJNNSTSF0hU8Q97DdTTaJcFu7QxyVK8DngjWhDiL1UvOfQ9xbAkH1/2yevaN67paldEi09DeMbrtu5brhp6qP3f/rJxz+1ecsVg8s8nrGNpW+/9ALVr9xzdtXJh1vDpQ3Xbjtye3nsX0d/dNtHX/jEJ7/KHI/d0v5GFt/HhT/DrzWg99CLC8l+IsIWimQ7IAQRHnoCYIbABzDCFyRgInTRvWEI5GwRGxUiAn2+4v9WnP6X//VK7KXJxyYefJBduDjEumLP0pXAiWvh3l1cp5qJD7mkiNs71DDc0DGmmwJdz20Pt0Ij4qA35PV5vdzkgQF2ABGUl0YXeMHl1KJSjtvhp+a3bDyZf2jNRHP0ocrhqaaffbdhor+st2bF+Av7Xqb3rH+qOtY0UmFjFyzhntqWQZOYOcRlrAZ0dAT4w0Gicn0WiIsZFDJoZ4CuX5N2xenS1AwlluxMdLoc1KE4XVFXXBHGw0U6M9TdNjF/6qHP3HzNeGdLz+DU+g3Lhtf+w8P/+9m+1XVHjt98VJEdpMtmnivI5bkCULhqrgDEZkpxvIAOAW4Y6qsUtKMgIgr+Av1BYXNLSUfHl06H29avb3jmC81Tm9pK6NTAthpbzPb2miODNVZ2Iaey/wZFp8B69Dewngl9Pfh/HsTDJxr1QURV6idccernjrjX4bV46Q9jP/kJzYntoh9kI1/e8sIs3Eu77485Hn65OOm+mkfB8wP8jlzq+R0t4EHQb//xe987QW9hIy9uif0cb6bsySrYkzzSLXcYKKMgWAxYTMyFXRH7IYoWBZ24LW6W8O5kGhwotKKUYNrBmpOZIelIHs2TYIt06buDkuQPRyx6uv7sh584eXyid8XImu0jo3L1lVnv7M7+4vnP/MOa/qajJ09f735kS+x8Z5x2bJDTzisXgnRgILMNQ9jhAaZEuAmaeRE7vyWC/7LBE2+cgP9oQ+wFdiH2W+qI34+8Eo8rwa/gQbEWV0bg6ldOnFDou/Cnha3kl3xti2ymlDsj4Ic4qMlR7gqDswwLgVTk+uWSE4Ut7R/ektfdxfouPrJsYllQ47O9fC0jKZdLDDquo8EbwWVBuPnCIki8aBSNkh6+J4CAO8ptgAQVbCDdr5ygR//4+zt+DxoRBRt+6H7aHvtG7KS2//8G9weay04FFxCkTSpClhwBlEUpsCzs+E9jh05QO9zgi3BdFcD1O7jOhv5RjkEUKGoFUAlgO46KybS1WRwOzjxev4DJMvjXKQmofOBf9rubnEZRnL/xpGgw2uejnzkqXvcw3XBXR8xFf7Pq7tgXgO4e+qvEPg7Dmtk8dgQwGSZfUMupiQqHxcEtpBfXcOA22iIhoDAb/uyvRft1n/6NaLuOlW39aAx27+L3Nn6KlnJZRr49CXxrAmyUvF8yf6r+tC3gU8OcuPMk5RRbckCtsZMfO33mQfw5E3vuwdUjdP1nnn36YfyhQuyd2MXD6j42cR1tvZykeS0Br5dLmqoyo3Y92loLBlOfu61vqL379AePDp/4p1vuoj88HGvtuXr/m+zClUTF4yb2FOAhgQRWymXmLCb0oCsB0QJqLW7DedDEffRxYTAQCPgUa65iErVLLpC2qrg5c9I/c5TO3EWvnFyz7Mj6Mx9BPOl6FbNbfzwsrti1rPnJzwK6Gr9OAZ6ZED0Cv4JC1lGUfEwbYFikakmVN7x+L8RHXFeBPbDBtuGmFUv1IY49axjtfPb+T/Sc+A61nV7ZOTRyE/3X3s3O2A+oI/ZbduGFpsjPkC/MsH8WwNtLquRyJ9gCl54lgiXNFiQHi2V+n5pATERGavYwSdtg6tBy23UfmekZ2tbc07xq38zJuVs3dHSM1bZGx+a2f3360PSqnsba8to83+ZV63aODbaWh0Plbu8mgCkT6GDm+w0OJ2KbMA88KFRcOcq1TYOXkQsnnmaM9V98nPXvRJz6AScQVpKDOouH88PJMQf8ziE5fpsfY3pqUZgSVQng0mBhQ6cOHzl+olU+AuJTu+fk8b30xVhjX+8H6Tfx3nqAbYDD5pCtCFsCLCvKexDEBsQ0QkvF+0599+++d/YIa0TNgdfmACZRLoNhOZBlFNBX7YcYUEgSQwAum2TbLDbQRICjwGVeiCgSbxOiRz+7Q9z1qaPH14n7brtSnOZqyXnxdXj9Cltx8XnWip4vwNgK6/BMfIYE9wennnJYuW/HBm1Wm4Vnz4WICwJqwcaXeeGpu64Rj9z+7HfvPCueuZ3upZ2//W3sq7HT1Bl7HfVxDO4ra/ZOAkWF6hRjp7gWh99GYrRCHOAE2GF/OORM/tmJn975AfEDQNHR2NvA1Z+LfZUu53oJk1F/5PfktpkB62npksT5gZYOsFo41EaKyRIehb4Ze452mGN1tDP2E/okG4oV7d5GX9tJVD/nFloo1KuRgaY1ML4bQ+00hYFePDLQgfCgrqCFb7xx9dXXCg9vvehOy1sxjAt0QtRGV/7mytd3CzflvTOP64RhHUd8nXeJQHT+hgiwbYQ6YJk3rp1lv57lORyWzQQQOT0Jf0G/tVMu0Gn5PXKMk/ggoATBCVLAWf4FPel004jNH5Yczxx8Zv7agyybtsS+9oMf4AVZC1vonxf+CaNxfq9L5PfwJjok4p9jVvrG380pOVh2lPoEOSlPJ4Wj1Bf+eQt7rn3TVq4ri3i+qZi4IfbplFe6YNec4LkVUlEnATuDpupHnSVS3ZyW9poc0FOwtKoEegq8RQUBD4YGJTyrgQpDCmlZ75bkNJiAbguqFPpDi71gXUH0iuFNN1+3srZp+VDR7OSebb9cUVLZu4Lu/pWnwDBmaOvbMLB2Q2FdiXsiuCF268orqiqHOcyrQScE2VsgEy5yk5Kyt4PXTZwOJkBsA0a3PwuPnNwpbzPt7clElp8jMamm8WFjlODcnfiEB0NpWf5ss91qdmW7rJhnc4GHAahxzROW/BabEvRIDueLTRNf37dtXb1+/8/3RSKtVQH2VuyXA7HXj3y4o569dnH3kzPren7fjPtUDnvwEuyB7TI+/OTSPryN2pb24YHG5fXRlsGp646fODTbuyzSdN1k6drl99545CMrVoUf+yzSsRLoqAc6ou++R7ZnglQZJNCD4DCBxQCzyXoVUuXqeNJWTxEObjdF7WStIOUjeJMHQGqUPCk7TBmUgDebnZFrylUSvejQUp/qxIbCECm6LPFDEho8AOF0RXjD6sj8fkN089ZtB+lzT2wZ636rYXMjNZovuttW3XPshg9xPkC6LQDdrMAHy+SojufiGGVoZyG+JNuQT1WW1aL4cTZotzkdNpfdFfB7cySeR0BQXMnJoLBPioToO7FHzQc7lkfX7rrh2I1791z32kzGS+wXd9QOdd1/4+GPnD2S8aUPfhD3zwS/PgF0dJA5OYPhtnEo+CmF7OH2VsKzCs5IbAppNTqgBCnAbPgRBXU0t/hToB8lVktOtpmfgCgxmwHppxpnD41IiumMIPFye7sClZWlxUfN++ZHR2fYW0Xr7L5w08bYAH1s47IBCMeIdSHEitkGUkOWkU/L2S4qCt5spjOwfnAYYLurAeQoxCdGo7gPtg7zhvQoMRCd3gAawGgUNivk1OuV6A4JK00TSRqTAJkmvFIQjUff76WTspuS5mh9pKqiJFhcmJfrsJkMOoHU0BoT4OuKcIOO7lBSVhH3zKGkGnlysYXWaYlHG6YaMcurt161vONkaf1A33DTuhs33rLXV7dt8qoZrz/HW12/Zfcd18/vP1c3UbOxoq6+3NtV5G2qaQ7V7RifbdluFcNTq7YacsCBHukZWTc6Qh+ojjbWbo1y3boafl1kb4IfUCaHQRpoDs86onrv1bKjk5p757cGuL2AkCiK2gJdcq4lXpyf79jwgfkiX7SRvZoVe3XgI7Ej9FDY38/5uwV+/0Rw83P4VoWbHFq+cAKFbXRACbAxn4iuFSVzSe9OPm6xKP6dlRMFSWYDq/iTKj9wScDvmZ9nv2+vrGyveOc1ZiFs4ZcLYXU9G2m8gEGasmiOJjwTaMFHMYlkBvBwi+eUNyYf84cc6DLFQzl9Ys2cqmU185NXqKu+MpUv99HXY4UH9ggf5asrOp2f77/F4zvwqNT4TiEnpaMD8Jca4mGAh+ENjzCj4EZFJBvQ8anHL5x65MvsNfPFLOr9w29iLyt+Qw/oiEK4bybGSpTnwlHH9SZ5wSEfWtCgogBgg+yROsoKKitaOuY9lqn11p4ett188Wyptu9CJuicAjImZxpEpqMFdkZ02tGxQ6I6HZ3mVn50QC8y9eA4jyMhxXNyk/HPJmWT3+q3+nyWHDwLx6jZhUo8mU0S7LLX2DGxpbB74rb5/KJo1by7sKmKWdpHRkaQcQ6UBfpit9KDpf6+JB4tBh4dkTNMsF167o8pkNqQ7ByW0QGdqCTH3GAU1VS1qja1TyblLMXV9lmsfvRmvXHIIgqo9AhyMQDYNfMBzsKx0wgZwKXpatjfYnB7LGqeSDVrSWGY3W/1KnkitF91QS0z7wvR+w4c/HXs7pMHrz52/PXj1Pj44088cfSB++Zvuu8e7g+EwB8o5v7AVtkuajY/i9t8QJn1JJt89J6V2hDNIqDJx/fwuEoR3ORPk0y+32dFk++SFKwVqx9NmPz5fdLyjV/fu2Vt7cxebvO/ZWa/XTmMRn9ZyeNbxnp+H+V2NwR2txhUo4ucVv0XJ6gPCcI1kgm2Q+g3QVjf4+Zvi+lvTyYZZWEa+CjNvoFRRsOHKMb3MeljMCpGIyVGl9HlsGVngZI1UINmlLlNjlrCloQ3EQWbvLOtPPyp+YYN22cPzk7US2CSH+96q2HkosNMWdfdx2/4kFyLvijw2ylWBPswO3DeCiBmo2LMMjLUjAZKwSHLhhcWf1fon1S+aCGaAzaqRh9u9HTx/+L+j/L+5ON+n0VTpoqkoCWUvj2/P7N8ypPrzHWtK2KWrQekG/THAKZskP+vAa2LFd+K0SIzI+DeCuhbqQkOxbfSuJASjxu9K1JMi9G3iipBcWhRTOxQo+afl0eqh84d3LxrVWNrV7iyumfN6M3T82PtncN+j9drD1/TOdE0XOrJdXscrt7u4cmBvgZFNxkBtqPsHmLHeJ1iZoBvcK9IMXeqiCbR6eLROgSSVuVoF3QVqCq0+lEHegBoHelIZcPqB0dG5m8yX+X2FO4eLaGfp44NV2cf3xD7bdinxNL030HT55A+OQOPsjMxJ6LqAx4Aj3Jx3Bz37pzqm5pft1n1655ANcCTWTYl1o6CzudOXEP/fK6vrXp+r9S69U5miX0wWNpOD1/8ffvIxzjOoPTofwIMEsbzOhqPOkcTUSfPzitRpxIt0//8/L3nT+8Xr2KWi7+He26gn+D3wtzCj+BeS8Tgo+8tBmc/uurBNeLohw/d1CNuOrZOHMQV6F2xPbDKOP10bJJ+CmLlP8Nif4J1eAxukkRBOVHlZklZxWqzKudleJoQ5nG4ZPP/h3jF7ef/7s4JcfzM/efv/va3qevt8+f/I/Yap8NCiNPBjCcVmZwOoGtJTzoxzMRsyVWIYYbwbQWNajT5++Kb9+YM9drLP3XLPvFqAPzftlxpmMqMLgPYB+mjsAaoePoZWOMS8fjoZeJxP4SSn1wgVMyKHaLkdXqEPhb7/NaNdGQr3NeycIgGhG5SRJrkhhxwtDHjiQ4BA3dAT0GjgL8ngOs9rp6YCSKYIvh6kcVjcVgkZJuGusbltL4x6kAnVjkDgVdnxFFF4f2QpcS9eV9tKNTQEArV7tvspmU7/OXPznTRjQWB8/2dmWJmZ//5QMFG2jXzbLkfVj+1cD+5KJSC/4Bn3mjdxzh26I7TIX6cLVgETDYDp546tEP44Dt7cR+8gEt9AheUQSISAbhoDjABBtOBT4VFJOOqtmA0HReq4aDh1KDg4G9QcKL16cjceVlkOG83kj/Qt+kZ2MM2HvfXWy1MwPCMYHyDB5PjcRcMs7OgwQSyGvRdlskIG6DGhZgWCPowjannEXghxeSmS0+3B1ZUW10e80B0Svur8Q8eT35++EpPQV5+yR602TyfIzwE/JNDmuXGBAdhQZYo9uLGHsMcCcEcSYLmSvUScpROn5eU4Qm6oi7JH05L9MQeOnZzzemRM/GEz5ujo03XXQd35fwrBP826yNHq+unMHbsuZtvqj0zfCbO4NQ+NRU9fpyf50fV8/wsMqWd56v+N3eyuRiNgaIcOO/hLhXGwuiEJ30k5ybeBc00pn7GhKFJcNDVKlpbvMpRitj8LynHwyd2WG+jn/bW1Hh91dXfjbUpZ+oLW+hv2HmSh/xqs5jhlnbMFkCwhEzRz7ME6kk/RlnDaNBcjpxsSY+nSfFkARaMplWJOuy0oz7aEu3ZMr19x6aZnqiaNKg03X1vzh1799xjue8eUxVPHlBSBjjZ2VdIIWmRm7TI28WrYCQKjqYAbsk2zcnmlZ/8hG5EN2hBt9bm96G3a0vYVAhlHX6HXXIoxVPLYcMiN+zferRrpHRlfdmXv9xMu7JjdU35Q0P0nfG9061NK7qG+zZvLBK3Ttuahwb6YL8ySS8LsFl+jn+FXJwv6SC6JXkOE/jpAjhwmSJwUL+ekl5bFqPgE4Zw00SMUxmd1Q45JgVe5QcaA8g6B5+i8MOLJv3gChe4vUXuQEGg3KfDAkruhQBrOe1Yc8gTQWEMUaNhWtfIj8DtzsGx2p6uurXyGp9/VF4b6eyOrJXXeovX0MyGpqaGxuZmNjtWVLRWHm24JbpGHi0shI/ruzsb1sYebz+0cuWhdtxVoHk1uwBeI0iDqNhOSjKoqCPidiPVGahe0um3oWUaxhP8EWkQzxKV8mWbJcdk8oC9VoyfgNRWyxPBjfAP73zy9Fnx9hNP7j59+vTNp06dolN0XeyHtDT2md7B3ptu6h1UzlYSelbCU3BCwFkB+m1LYm4s/xKG+FmcBM6rLuksLmIRuPo9dIg+R3fG7rv4Mv7G+3YtPEJfB34qJXV4XyNwTl1lkSuD6QVayP14XqsCu6vxFB30V/l5MY9NSwikemdqFVLyuUajWnwU7lrVsH9y+5q6Zb2hyqq+4f7BxoObdg/VtnWX1FYOjPQfbJorWjZHW1ZFyuTuddHBcFF+YTA3v2t5f235yu7xpuHyovwif25+x1X9AX/AFwj5EQc3u5WeFOxAGQup4Frbi0k8Qsex0B10NEONvdpoMGcaLEaLLUenZm6tGCjXOe0utfTZrp9vLS1tLbnPU1bmKSopYbeWLispWVaq/ObGbIDsYS+z/wDfsRBkcRtfbX167lCCwBQLsNU6HwPlBRF0zkhFvV4chxdRP51B9aJ+dXGR00FJKFBUVlzmznMUOgvVDKOd2k2qJaFLVQq44izuSiqmoucqQiXNPaunZvq7G8v9oWBl/xVnz16x6447dt367LO33vLMM7TV21K3feP6HVVN7mXLD525++V773357s5nTsFnt5x6BnGcAHD/HWL3POIjIbJaHnQCIziA3wqA5fXg56VkpyWil/QzWpL6igGDlqTeBdFEfigY8Bd58n1un98fCBuzeKL6EnnqRJoaM+ovFuUP5EWGO0f2ztWXVFV3esYGH/lqxB9eVkt9sQP0LNv8SDijX4q0DLR2DtiDHtdQUexsZMjrWx67cZrLTCXxMj/zQ+ybRQyPZRp1jNWA1pDCDdEihr9dnz+26oknVl15bNWTT66ivhfrfrD25ch3lBdem3yQvkr3Eh0Jyj5U78cFrpXGMERAc8e4h6MjOtVv5vWV9NU9se/TvX++Z/tfViMsgg/yUzbA3gT75yBeUkK2ci6bzKU6I+3HSkcGLutRgpErFXADDEbJMAdf14lG3TYT6AXCxuGFkWnMB5LVmAwuCQX93qJCT4E7P8+SneEwOZS0cGbcXdFkIKwWrKJA2+xYSe/nB8CSciRM2/d/6EP79z3wwL6x/fvH1h048LUVI4OdeSvX3dSxLM/d9NMHfn7u3M8faLlmfOLaayfGr6GmZsehnTupe11gkJ+NPESXswWgh3pGw7ikjqHyVKmS5DRy7sdS4eWxn7KFDRsUXRiln6F3AH9mgBTW87ugXsT0L5gNPKQc14qdCQPXzJKTaQJcM2iG5prZVNlx2Aupav8d9l/5Kip83oqK7afn5k7P0f+uGq6sDJdWrd4w0D+5vn+A18kR+iozExOENpVyWVK5rVp7NIraXz9F9PoR/aDWvoL2lmr6PuKIWHjp3N1777ln791YPEdz9u7deu5c7DZ+hlUGFniG/Q4wgxVyQO6yqVL+LPQnREyLH3aq5c9ZSvlzZFH589rVm75kiv34ylVFuWWBthXrO1az/ZG5VYMdszPBPE9FTV8P7zugjeCw/+791D5fET/O3hWvfc7KV6oT3rX2eWrD0KaW5pI6f7gvbHK7/cXu6rK6lWu6V5eESurpl5oHVtaX+wpau/LzcvNCjc1tNUW1GYK+OelsrS1xlmgLR10rQ99qYUfbb1Trx1cvhFkOxF8FSEMs2HPkZAkYcRe4wW/rSQTcauahxKqUbWBM7XJGGzGo5joKy+rCPr3f6aHS6nmfxRUNz+cdypGcK32NHvS7DkPM99wWi0EUWuh1sb8bn8guaAyWl9D2nqksBZZBgOUUP0culj2gMMFu96BLcRw5mTuKZDBg48feOszqSRalCsDLTh2YOXBo/uRhuuw7JqHqnZ+Y6G/pVRunDir3rSbvgI/8ETxDQudYKySdxnuvVpoJbOk1rHSIl4lWV/M+EYE6wL+3kiYuQZXgntFsYGazYvTjaW1gunE1GSSw1cBu3HFGKXLBzkYjjkRCJlL3aHmVabC2bmh5W6230B+9w5FzfaeuNlTXUtCWo8AdBf4uYq+BTgYPXQSHhZd8UroDmXonGbTnsCwn1iVgmwAt2ryh8v5huKSjTh7nemESD9FB9nVg6x28wwGcMJ04oyU2r4hv7C4BguuA32rhjFmfktkE28O17umnn469eGBmy/79W2b30XPcrNjOnLn99tkjN2zdfvj62NrpRXYkK0MvgB0JYoeLQ1JfqOfmm8GIxL4CL088MfridyIvr/1BnfLC4Y4uPCycYH+CvzLArq7mNO+0WbG5hlALiBkDn5L2YmU98ge49aBW9DpBPyaBc48RGIRaej2GMHphiBf1W+x21C24FUYaNmo0U1QNmDmlyv+F2K4Rem/sIU5Jtr1u+vHDa7YPm0br2Lff+VmJ4I15OXEvfnj9epnmFv5h69Y4vCdVeIvICIe3G6CFSNANGiIfGNkKCkFMgho2AizQnBp2bUsPu4B17HZea5MO8VKqKw3u9YsVWQr4sUPpag0gd8dpbiVRcpDjsLOCZpjKqTGjnhqMeZkmQTLkgvsOBlLQAy4mxAUk1EQyjKYMtKkGyWjgTg641KD+BCqOLeqzEOlQdWVZSQB8HD/fGnsmuPwJNFN25D31h6jo04zEfl384VJqUx5V1KZKjovb4tv4+8voUZ4Lp69AjJ1PgmTs8Zxsliha96DoC3iGqNZdc2XJNsNWjqk5e/VzEUgrYn9k/NPJJ+xlaoU2Brh2s6gcOKv+6wohqtWv1Tl/Ea/Qblo7cVyp0D5d7fNWV3VW/4vHH24LYIW2L9C+csemzkqs0H5TDcqJoNQcC+d5zXE29sFkm7ME1vt+a4+jWJmRUn98NPSL1uQa5DfaN87G1/vCX7teNY26UtfbFHqhJXm9z7Yf2Rpf7+N8PStplCNWizkLj736IbbQHUtZVx9fNyc7vrKUurIJa1AiLil1cXozpmBqU2quFzAL1ETiMNzBYfBgHFDgZgbJZmU6PcMgR69DkTBkUB3Dk+ZkkIwqSFmZhOS5nPYcc6YnyxMHzpS+Db6QlipzqpmyFDgbfe2ZOc6s7tI1/nYT/lGeDPJzlXZX8Q7+C8sMVbhPcLid4EE3yQ0YogOY+kuASUhhQa7LZsnKjIOYkQZiKBFlORN/poI50lpa5iksfay1rKzQU5YM4mMlhZ6SEk9hifqaBOc/czixj2afcuwbJgYgrUGfAFWSuNM1MZACtBuMn/ZNHZGYTloauUnZSYinINdps2abL4kfw5P7+hA2/moCmopcnbvC7a64t6e5qadnX28ycrS6zuOpc9dHursjtd3dvCfgDWAgJ6/Ts5FWuRlNg0HUbQOAid4AilNLk2FZAp0ySto+WPFYIVv1nTNMbgVGTCW6Ig4//PCOga/63mi+DczmH7JjP6/871erfh2LXP3USoRpy1e2vLCFdcf+gbar9WsCr9MPkxtkNx7mubLAj8mlouAGExageuKnOr0eVJ8ZSO+HbYFQYR+Yep1eN5tSiasV17jlgPIt/dHLfW1SzvCHbAF/yIo9cDr0ldLrOyNKQjDZgaJ7yquNe25MFP8PDnW3DV/LXao6X6GvCVyqGceT98W7AZYNr9KF4i4WU+r0QS+ilqqWK1BL6Xr/gnp9TKUl1ex3g1bU6vbnUSOSv+FaQXChktaK/QpUorbYClSH8bU+zrUhyDPXhjo9aEO9jp83XnpNJQ+Xg7uQjiDqw8S631SUobbyBzU9qK59IqFNjFQChcK13+VWLiywB9QgMIPPMEisHlhamyQR4dUUXaIB1bNYjzDwhAnNhX3A3GCe7ASXUuCFFov7AtDcvXLiRBvuZmIfMd+f956uR/MF1z+IG6RuDcj6q3B9P+wN+oo+uSjDqEePFfYGfKljSfexK+X8eCOV+nCvdpXqCXov/ALuNwT0hmAEfGV+XingDTH+TNwtgMTlvIQ3XFo9w/3vSqXjYgoygoMusB/FCrvL43os2ACNlFQvjn1ZU8q6XoulFH74BAWqNNRgOSo21Ui80YbvMpblz4bb1m9oeKan5xHeXHOGd9ycO9cxto1O8QYb2riOhrHHZhTbbp5f99298d6eYbC72QBPl9xeXMQkvcvJRB3vOeAFrjoRTRlwocgkcS6lCcGS43Hn59qtOcBm2JBgXKIhIbzI3ia3KPzTImub2rSwJsXeCkr/AtcDNuLCXJnL6UAOer99DAIwRXovgxdYdVE/A9uisO7fcm3QQelr/zew+eK1ixW2j6/9cb52PtYS5Oc5HSJEA/04luDYkjA4EAje8nAJAoBUpMPxoCIii0G5ShWZOCx3cFiCpFfuCviBa9z5wDUslWEoMMzSoNm9ReAGOe1BRxChNF6KVIuZJw3gnXEGCsj8j/LFsNcnM5Gown9C9YRKUQ7BYcMWb90lwAX5tyKYihwu0RWzpEZIB/XNFPWwGMzSRQqXkg1kL/0+fR1g1V8wCrSmvI0C96iTLzZcfXXfwYN9/PeTBw/2HzrUz/+X79H1gGMTzyN48SypmFLBiIcTThueHvQXFTKhF2BkPUmzWxJjG0r8QbWfLyygr2B32WAnlJybcvKlHYjRiy23ZTs/Hnu69Qy80G9/7LQ7P7ij9M6Pnc4rwFe6/hONsaBIhYea6U+F2MXPPKs/UnDz2n/7zLO6wwU3rQMdxPs/QK5yiB2rPOw2K0jV++0DQagSvSACtzpp/SCKEfobrYfmKbHe97mVSltP8yeU9T4Od3ORWrnKBc5xQnJ1iXU3a+s67OrK+kthipIbX/wGzaylra9ZOZRZBYYTcF83CZGIXJPgeMMSmPu96MRbLSocxqXgWNoMJsD6Tpo1TINuCfcC7DvvWYG9wfP4Ujmkda1kZZpgj95D7wrfFq1/5XfKriT1sGh+BLd7y3lfEOcBrZo87mMlt6lhnxr3I+t5Q2uiT82Bee9Hbh1eu7LzzB3zYydO9N1yF525MfbO8r5DV13HLhzYq+aI32Rd7C1SRc4qdVgZuZQJLgqWtN+t/Y8I/xPvWlA1z5oBro14gSZ2LSgxmzvxsY6C8zegqSze2JCnnWov+mxSKfCsIlXV/mpe4BmxqJtmZg57oZBylFolNNSvYDxb5LCsvmrXxE5vibekqblk37r+aIXfHy4L1NcHioJFgeBGZt91cKy9uL4wbHeGA5X9NWMz3nW20nBxxBdoCvjqC8rzCkoPX/w18CHvRRGqeC9KCemXe5bqRikJhwSh93+gJ8XGI43L9KX8Ovyzlsv1prAN7VtnSRyPyv+v8OBRzGXwMJW8cHk88tqPJ+ER5HiUkzXy6vKycEgU9IvR0YFpF3j8k4aNlIJNaUkCH8P72RceIF0GpW031YGWq7ssVtdNNR071pTAK5Pj1UD+Xi6sjzCjobyM6aXFqOnVPo5I4qBZMkwTg2FiwET1euM0MRq5LKoYZyRhjMMWDETSG6Q5YoRvC0YeqaXRKPmKSdkdCnoKaqurKkrDwYZQQ4Jgme+ZYL74e2oO63Kk+4hvZaY7r6tsxL8SXaSusssSsa66wrujCpylneArJdOxgjSSu2T7Upyu0K9cQ9xkYHq9NA2xqzRxSbqVwsf4RUF6DxSrqvQURGorG6say0pDwb+AYovrLy5LMhcWZ5Te6yktxeKMy9KrvgRLNtT/SJxmw5xmVaSJPHApmhUDzWrAikl6o5QggcHAB+gNX5JwVfFL9MQg6A3vSj2XpyDaWFeL/JagnOk9U07ty/EnDeq7LO0a8521+S7nvb37eroP9FyWdv+rzl2fV9BQ191dF+nqUuRW8LJiTrl6enTgvA8r571UT4rBYQlngjmzYFZNBMu5+G2DiDY0Ay4JmrCCAY+U57IygBmV9qzJgUwDQyJh9fM4L+rL5LNVjPDtcROWucIV2y5/hfn93N76vm/v44Kk49fMgd9Pmenyl8gNl/02iX93IJMaDPHrJvEf2V1THQrW1VbX19SXlwarQlXAGj6/1+41Y6ijeAdSvHnuEpU0IbWUxidFqij9RHR21zVC7FHTNe1t0XU7b2xbcXjdzE3Xa1xy7anu0ozcdd30ns0ZL7Fa+t2h24+6HR+oWd01MQEcMllcWwocEqsaLGkorRmmB2/r7ub9kwLvnwxquVUHcoGTikIeJaIPGMH77rnVyfeWW51cnFv1XSq3ytspFmVWl5VXGTfOak2Z19ZHWzrW1UZWJY6qt1jPXql2aZaubdSHdHVB7eBaUHoewUfCnkc3zkRLdD268/PQo/ib9D7y86gl+x894AWl9UC+qvo9CmyV/9Ow8bOrJWH7B/Bs0mD7uOrLKLAFOWyFmJco9OTngS+jgSioHowKoXQJCAvcCRgNl4FRzaAsDeas4q2kQUqZ4qCIKqyZHNYiUkpulTMSlNSsqQpoijXNWBLqNGuqXrj0d0HovcV2WyhQXOot9RTk5SbQzbw0ulV0sQFdEvNHUyxnGgGeSbWVDCwZodm8Xz81Hzy6ZD75W/PzHcCbzHI/Z0e4PgOuzwF+fPfrkaXg+nPAP8yyjrMMxJuvwPVtwDN6JZ+s1zGIxHgjPyPHlEY5pXfCZsN8suqoCnC/25QdXjk/z77Bd/XivcyC8ruATf0rYW8lXjcypOxmrh67G+k0lolOYMtPoj3YCe/hpzosgkl8MClbjAacTqyVkkqAyWI3BmFpSaH5EIB0czKhLx7F3k/en2cW7CC3JXiGkosFhv1unLqKEaaRaucpc8mZr5JANa9XCkdx9jBmfFRNp6WAQmFbfTh+ytT4/dH22pr8dct6upo3jJ7YN3fqurUj9ULBqmuE8r7q5ua6plaWE+6xGSdy8gZaly1//uyNHz151W7w63csi10IeJcN9q9ardbe8d5GoGMO8ZKvyPbiImaQXE6m02t9jqLa11RCUD6IIh46HXfd1wwkNT8ateZHZS8qlv5+altk/Bq4ffL5s2DgjtZSXwV7mmcFHsCkuMNm8Vq9Wjulaal2SmGRE5/UX/nhRT57SsMlm0946aruYx6QIz3nuaAMhsmGNQPvswcTTUJqH+Z1GBEnN2MyvyJ72pqVf+WaPJZNWfNBDF6Tl6S/UMQ1vmaQr5mLefBcl90mMp5NY+KxJdd24OLKoKFFi6s6PGX9/1YjzRSsV6qhZRyGTA6Dj9woZ3qLmaTPdfH8t8JhZSDH3Iuf4DXKnNnWDCwJnVsOLTpkWfKLk7LNZi0scOc5IZix+RAp49K7uIivUre0ZhFrpRD77eT4LxnXPOInMwp+PoOeYXkmdjtPXAqvYvgUv8d0l8TI4s4vLsz3u/02q4JP/hL4LBG6pSD06dRYLQWZd1IMjkAGSQF9lW2Av7CTuEIuxWoBCMpSS8nG1UiKCavtdrtNPUbGKr4lpnaqsyl/lTy8kxq3x2JqBRF9TiuF5LxzPfOwu/gpjlotwojHCb6slQ81kfSM9ILRoj1aPpZ7o1oOL1hW4lPaIbT0uyOeko8qOXqXkrEvP3nQnBuaKbnq+NXOHHg9eDy4w2A5+Hpge2bmAWo8ck68puBwz8Pz94uHC27oemR3Ce2lj20vjT3NiJqzpv8O+gRz5KvlnEQnKWbLSe/ftp8U1U5yTykd5kY+ubGUuVDraHBV/r8DF6qmZLhOcN8hGSz6fa6ZNLiCPMe/UbbwHD/RaeAJ8anzOqI7thR07uRP0kGUjQ4OpDJzPB1IRYUlw/k9RYGlUbBB0WCCCiva1VzQX/cv7hMuMkoM9ZeBogJbAlxFCfiX+loa7G7ZCx/jF8GEzl0Cv0nZmp9X5Mnz5ftsVo4pVuMswnSxHkhG+niKFkjbpj+k+528Nxf4yAweOGgBpTvXaskB7/F99ejyQCWtT/d5ziZpvbrc49TmGChzjdrkVqA5AWkXWCaXfpyn0psFeqhHpEuJf3xGQQDbilzKpBFlQoHDhtMJeKJm9XzTBB9QcEVrVaB1X+RHwrNmdSzRsv9kt/X8Pvr4zDqssuc0yATcnKSYbJVNST3Kyg7nG3QMQ2EM5iYGpGSauMGjpSJ+DjH4XMpHk7Ir14VekKs4FwKNnGyFesbF1Ast1uxptPxa2q6mUXV/2r4u/HlBz27n/XNunN1tBq7OBgBZP/A47cNxcFRPtvNaUnGWF4VJOq0eLD8PLnP5gxaLxYAzHNWKNX1KWWlj1EST5shu9HgCBZ7aZnmgvvrl+EjZhm5XQXZ7XltjqDtPLXXkc7j0rJIVkzISIWPymhCYnSAVxEqql5x2gJH7tZkYBWIPhAShnDLji85qrRCTAyhrWiBXUV5TVR6piGA2z1/CbSfP5+nVpIQK73uZ09W3zA9YNK3sj9YFs5t3pGX15FBlb5uaxyvtinDMSrrzbMGlpncpMyYjwnnwCfPIcnlZWsdaXq4LncS/Ym4t1k8sMbu2OPRCS9r8Wnavdt7H52+BvGPlxmKYsJAjAdP7n8PFfdj0WVwCqIGUeVzMrOgAhT4PAX0KsOYmDRYIyF288Rnd2TiVdCkQufMTdNJfmk5qL/RiUnUr7dhp1BL6lK7sBL2C3E9ZDGM+ECwdxsk0GPNyE3TTX4JuGoTppPMo/dqp1PuW0rOtzGnezHvWc0kRau+iAnd+vFd8qenEeTieWIkAlhhPrAKx5JTiWJ9CqqWmFdM/avQS+Jy1rwvNHKYycrPsKDVnCXpdyrw1LVwtBluvhzB2m8RbxwxLjFwLLPmVRaPX8ni3XdjjTh2/Zrzc+DXFsXY5JbMo+aOhpaaxfajUkx/CRIXBmpkvdrgLlpzP9oOCsBcAMHnCebWGgy4lZv//W30b7stqsLcSKSRPy3bsUcQcD3FRCbyynGwmqj5jQE+xmhJPzYcHjJzqGdrGSLABvNUaHJ8A5hsu+V34Fl7AMwrjBozt4Et6bF4Rtl3ui+ACeYwGSvJzledR4TA4Q6GxEEyxRCUT388cbTd5d59LmU6dNFRvp7KL99wz39eHO7l99iB9LnYn37ada1aZ5TUXP9u2Cif54HxhsEV+2Kd8fLaTGWDMpmD3+8G8gJWMF0FAWKrDwFuaAoB5QUS849DhDyR1HCrFpmmGJzGKewOYl4Lq5pX99VWxryhTub+1pb4nEreRFxSdY+Cz/nwkTAblPsyHOiF8pGbKxGzeAATbSKiEQRrGZrNoDFW7mCQWAX8o6A8HwgH47c1Bs6ilNFMtY/TS0wBXuIYQ4orW5jWb8jy7DqdMBiw3t7YC5K7mpqEG/YevwdSm9AROCUzUDj8U76TINmeJ+t53rxx2LF05rI3TSCrWfVQdpaFW6b6Z0EGL8t+JjHKhOz+Pw/Ee8t+egveY/1ZhWzIL/KqiwdPz35u1uRt8frpwH3gIQbJJ3rB4grrfV+gRpV4iGYEllZz2UhPVDcpEdXc+Jd6i/KA7mDpZPeOyk9UFn/I8tajLTJecsn6qZ1QasLd32gcNo4snrgtsYoW5t9e8YkLJTfG5i0Iun7vYTb4jO51UyIhPXxT6OzvaVogmdQBjuzqAMTN9imIWzcgwTROTCTB8t1mMHdosxr/iLpOyv7WFkna5pbu1e+nxjOa/bjxjNInM73lU4xSS3il3OAeksfc8tvFHm1aa16wxy0pPPnaH/Bp4DJ9j55Hz433FiRoymy0xZ6xReSpd3SsnTmRVdldWdrMLT2qzCymPAb/FLPE5+IvPF741P8/z/6DHcM48+L868AaK5AKjQYrXuF9q3jz6j8rM+dhWXrR28YvshOa76nG+ofAtkqlMyFYmHOZkmw2S7t2GHHJXOT7o8J/g1knDDtljuAJT5+I/DfC6yOBjTipSbM9zA5M6+bQ8gabBzp+Qhm+pCmRd8oeTT+T71UcoKMgJaQ6Hgufj3McAYdZ8DI5zFvoUGaZUnwLnO94iLMP5jlgT6DHgiGykAtMem7gtiQr5/pAy8DyZDrY0GOIkMaa7Osn0+Wg6NCzpGQLZfLa9SNC2z6Xvrj+VBCw+KFPF3l4Z8FdW+gOINA1rbKbieo7PsnRix3F8mqXQm8S+8WlxS6GaGMqZwPIT6nJJyNEGdVXK7cFF3jcekv34FD58Bp+BKc3SKWg5HCrTNkhhzMuAAXB46RuxQzXV0yfO1vwDtb/l6W+hE7G3J/quwaO1hQXApx/wseO945yrPuwvI4V9q5LYdzmmBAEfXABndTo4JuU1G+blmn3qxM573QNRutMceznc3/XL0ngvw3neBxaQvepTE8CbgtjuPT07AZuDkpsTYo+hLKb0I2g1vcrZlJKH3Kd4kDmJ8ZuYjGS97vS3BG0u9d98MCeKedLhUewVPEJJPTCaU89QNDo9BHRy4nMLVDo5gVBaTJdKLSSX+lCLVHIpDkAKxY6o3kkK0d5MxJUK3ZQ86VbZkqCPCwgk6rRh1ErjaYJI+jiRCohO0B1Lo5Q+TimIP5wOjVbSkrRS3ZZkcj2szgdLoZgQVJwVkugZ+JHa++FG2QSXCpwN/V/WAFJEl2gCealnclNT18zU4taA6qKnyh/xf6maw6KcyYyq5255CEtergviBv1fcvjGIUk9UPlk77pNrd2bplKPUt4seqb8gu/pamVu8cKbwkH2FXA3isi/Kpvmxawa+G/bMMtrmDZSgwHzFpTqpyXKgwY1b9yQ+kWC38M/jVPgqgwrl/Awg//J/ZRxHns5eI0m1qJe8mI8d1OuJUmXyrXaVSR+ERDpctdgcZS5qDDgtVgtVqvXx7vqkJVwA6nXiS2iegmc9EROw0v/q2/oQx9a3UOviP1LxPiP/6hvos2x/rK6Uw9+/ER9Of08XX/62otvX0uPdR7dcqx3S/bTD3/6uez4uaYwDbFPPo9+7lfKwLLtVC+iE5+hZ1i+4ubvGJLemVS+6ON1FEayLQNLRcRpjEyxMBfdehQgXiFSEf8S7Iz2HXKJr0/KNi2O8gV9WBKWg08ECy4qBVPGGAM36eqVaigbjw02xoOCG5tbrj547MSBw01Ne3dfE4tetX//Va/Gp6xv2nTPsaMPzMzcfjSDPfbY4/QAD6SUHM8U6HJ8tkoudk0oT1fJdTmVGqO/6BkrvPFq0XNWXsLWq/RnrdAjim/E592Cns8CWdutlPNZkybeWnKyDSIOvXWkDb2FD8AC/M1G3yLkKeNvB/gZgzICl/aiatdo9hCnmRvPFhWauYFoSbHf0pRzKKTj8edSpFO15mLqLRA1QZZOQVajzXjEeVa3gM7PArhuUCjiBHKJSeSyA73A+Lj5B2zxByohnUqz22Jq5iupyCVJ+oQTaYoGLI2mCkopZL1OMQQaZZlei1f5c3eAH70Qr9bLtWlP3gkG/Ck57b/o+TvcIlzmGTyxh4FRL/0gHvqSFi/wecjAs1hFy3PdKRORA35fUtPiXzkX2QIwX3I2MrDopccjM5fqj+AzjQT+TKMI5qJcQNlcCSgbDunxwY5UR6qpqNPxMUFKhRQO4ZmNE1sYjNRWVfjLglZ0jXiBZuiydFbHniSVazaXVxlPjnGqN63euyVO9aax7dsP7KirW9Uqa4WbUxmjnPzVef6ZFPKvn9iXUaKrDdW2xucPZS8IfC51HeLFOQbxCgURr2rAq+pyeE0Kg3U1leX+0qXxCr0HtKzY39/V3jlQHqlade7A5l2DDS1doYrq3pHR7auVNn9vsU/Bqq2vwe8pLnKUwlZFV4dxq+yuvu6eMY6UVpuqycFDfFZci9yUJgclIAiLzy6SpKEAxQFF8T2Ig6pxLicRZxTdc2mhYMc11zMuF0GQi7ByppEiF2EQDA57UjvtZGK+OpeOUDAhH/r3Ih+qjrmkiAQVfXMZMfm+5oQy5TlbQHuJmNHnM0MMpZ16LHrqliPxGEPlsVuas648fSt2reqnK0/h0hx0xueVf1joxHgNu0aDpgxBQgdd6eyVmF7adonR5fl+ZXg5ZoSXHF6engdInWVelJ4PSB9uzj69ODeg9TX+M69l8JMdioMZwKmYIk7FRO+G4Nn14iZHN3hN2tdEfMCzfolOyEnZTojP63FjmdllmyEXjzRJdEJ+LmWcyaJOyC+njzSJ12gMw5I46fZji2s0AvF5LOrEluGlCzWKeX3kpb67qFojlDzmheikS5dsZNpt/gAv1jDymbPpxRpLdI0kl2s8lNIkklaqMp3aFhLf5x/xeDsXn8cCTg1EjPq/qHFXCb7i2/OMGnYt2pghLepS9uOPEHMp66+RbYn9UCH5Hyg+4nAmE+12NTBLq255TYvMBLV/9gS4+naIzBrkOq2Dlj+1PFGrkeiiLciHmD7blKF00xpSumkv0eKr9de+lt7hm9Rpu8TsC2XWuNLbi3OF47O+sbtX6H2Pz5DjE1zSxot/D/M02mzxeI+vMlu88t3We5cZ+Xy91HHiv8bsijZLfF08r6Lgdx+sZ8EO66Rp/MrZxdySGNpsuCbGLAkcQ2ouOg3PM0peWkP0yaS8oYKr8lyfaTkjsbaiEYu0CpKJgSXRdsuedCBTPp+UjaDeU+H0czi1XGMKha5U841xIv1UATV13nwjNlwuOe99KTopw95Nf/mw+SQ6Bd/b+qOXW/99D5tXZ4reSOeFWrCl+XxGYDbvOOCPyj1oo+oYWrWk7zvY13+6hn13bfTw4agCv5vtp/nCDGhpKynjdyjS5tESPo6WxKfRgn6Oz8+0KuYpWRlfkV/hTihggdW53XVJKpfDejc9IhQCN6vPJ8jJZgLDCtXLP58gy5RhEBmxUIs2BJcunrnGfErxcalWhVzK7k6Z9UJJDuj8AvYWYJonO4FOpNcKu6QQq4MMWmiGozxqi1SBliyk4HThw1zDfiHnc5WurgHL0RsK6voab6prKxBvMDNTS1PmBsvua//5e8vLur7797HlAHkp3H8W4g4rcOUyOYr9fAblVAE8cpHotmnHotGBeDdTk6D0MOXacwM2n1Uy8tHkXnz8AqBXrB5+6eqi3kJaKtLPiaOrNvS3z9KCex44eeudtOC2jNiL4iBd7Qjt3SYPjV/4/Oe+/Pia7+/fmjq/maTNaf7LP8uHz954DzOh34hV0O8lrmEL734NW7joZq+p15TRX5BvsAWSQeofM/I0v6J4TJoErUGPKydxt2k+GWHyUXV+LFd4bTQiOZ8rl8tdK7sCHlZaVFq6ovqWD+MzFyroa+SbAp7k1T+WQZUBksr91eBiDeX3j0+nVZ4QMfmoI3k+bTYFxzNSIZfn8gWeggWKPLW4AkJTsbCZfJMchTXwmcva8zxT7qfcLbrU3RqTbsaQHvQMp4eTtD7uMLIESbLQF6BTeOjEiWJTBsiPKQPkcTgm0OVxhyPpsREKZVTZTaXS8xVymXNld7AwQa4wQlJYc8uH7YrOANrR2zntXACLM4MlyJcVX1QhoA0/A4zjICINARaHVa06j+O9JA2+WoFQITAJ0nJoCuo4NAxpTG/jNM7FMxqXAswSqzqCyprR1DUjSy1aVKzQIrEF4cKy0qLiKoV3Wsj/oT30X0Bnavw8nuBAO+fnRlUp2v98cHDw4OD/GWpeNjB4ECSgGnTES+Qublc9fI6w0sbFx7aM00E7/mPlD2yKNwQs9RdVGwMWiPLK1Nd2X3W1T20USH5F2CqJl9bxWcD6C2AltHny6iR5bYa8YleSv6uPzwlySJXJQ4LxubWATxh0ng8rUI0QveOzVPOpQXJTo0HsFzFjyAcCZ5qYPoNKBgj4kiJ5g4EPQxg3opPtg8iouLDAh5UrfvidhXFAgz8aWUG1HBvEfhj/4TNpog7UjGF/9Iox20Du2R1TffX1Tde4f2r9/vO2v8/sautv7x268qR9o5XWD/defVPtqO/u3uG+1b01Vwbnr+/j9bO0VOhSnjON+jo3xyAYUEbhFzHQoxIeAt0MdoI/MRhfBTLF0CYNOSAy5RGxUe+JR8QuvxMYycaf5GTzh/nz2unuA7PX0g2HwFeWNuTMD4odJ82bcCry4DDbGvsabVm9fnn18/T022/HDn01siz230j7LeA0+NhZJSqXuPIzGhjtRZPVk64/y3OYHvWn5CyikhFsll5yeQXfxXdoacfa8diPaWB8bUcp5kDtgqd/Yz/tol3w4hGUfb4ecMtgz8JaDtlq5qeogkTw2OegheodWEBnCeuzcRSwFA6F6cL1grt/YoD20t6BG/yFjF2Mgftf0jU8QktiL48cKC5X7pvAgT+ZI/4MRVNGKg5cPQ3hczCJmZoFvZ2bgig27BqB4xqjbPvFdwB4/+DIOA3Efjx+VXUhtV8h5I5O9Meeij3VfyRi43gs/BLweBDWA5nKNOJsaiqRHtSEB5Vye4b3trga26jLSKMupytqoQtCXt+GgdiTsScHbihzCezBiwu0VB4dib1CwyP7S/yU4TMIioBZLPyM3oR3xyoWplNmfxOKp4oHrU7chGAkGvZjqhvHkjrFa64Rr3nuzGOPnXlky3/+13/FPkUn6frYp9Tnc1uZFRjJIpv5E57hZgctfCMtXouXWS++gT/qc2KZCD6Li0zJGdlUr8uhoj7xnFi1Xm3NAOpdcUriz/BTU/BKE4he1Onnlvh0UjbZsKpArbnzciZWHwqbeL6Ol4k3fmp+dHTr3Ngq2I36EA2BH4qPhm0amgqN5flKGpX9NnHf5y3iJU8qYWu2p4BRSaL84QgGftaU9I5oELTpRD7tkCztWbcGA/cAeWpFQTd0iW/yuUT4dS0Rg/kayqTFj8dN/hqmHAKcAHxenCde9bD4IbnYGoWlEKzXXV61rDMUqQ1cad4MZNk2W9+1pzBz0wZrZwfLyvKXNCrPzW0a3GSzXPwAPnbl/wGOnsOvAAAAAAEAAAACAEJusQvBXw889QAfA+gAAAAAzg7u4QAAAADWN/0Z/9b/AwPCA9oAAAAIAAIAAAAAAAB42mNgZGBgkfrHw8DA/Of/tf9TmA8xAEWQAaMmAJgFBoEAAAB42m2UzUtUYRTGn3NeEs0pUxmYZgwza1KnaSYShRQpUGc0B/uYaCQiCgQXbVq0qHamtQoGFxa0MfAPaFXYNvoXglr1hauKNhapdHvO671i5sBvnnvfz3Pe57xXbqIN/EmJf6sbCJCTZRQ1jyQ56GZw2tVhUNIoyhBaSEpeYR/7xji2Qx6j2+ZoLSps6yAnSSeJk8MkHb7323rW5veAHzto65jKLxxw6zilpWBNb6GsA8hrlRpHWb5S7/N9gc9ZciJY0SnqOsouieO6yP4X7L8Q6iQ1h73ahJjOY1TPo8YVGXM/oAPBH66ZYB55i5l6VPcz1lrskX6ktB2tXGdcPiCjl5DVNDJyFfXagiYtsD2BPkkEnzTB5yMouMsYt3Yd4XjOszkyi5J8RoPcQZ2ewaj8huoyYvIjWJNVqLxGM/dtlBk8pLYx/x4fE9sjD8Kz6SIxIjaWOiTPkHLtOKsVnvc44zMf6IFOo0cqjD+PXt9WRRdp8TkNM64171dO8vSvyjEVTNh89xy9ISl6kPXnvwMuH3z3nsQ3PImgH42kWbLBF/JR59Cw6cd28rji1TzZinlykXMmGKed/w64EbR6T9L/Qj/qyG568o68pceZTT+2Y7VmSk+2Yp54z00tX9uTufr9Iq36+LI+v2tUy99iiNTqkzXCsxhmPGOszQzro8ZqVG6j4HUWBY1hlxSDwJ+RxRmpnQtjcwvocw+43qQfXwr1kNWz1dR/yhqXR6yz+TCfSKM6Z01tV3lKr7vJE9ZGnPdiDp3yDXDvWXuRFvk9+EkWQ+6RN6SHfXbnQ3hvkryDSaygixwzZIm1t0R9SaaZjyBnc4XnJteRtXXt++Cm6esMbpC7kbK9lTlBz/HOTaH+L6hoz3V42mNgYNCCwxCGEoZHjBaM05iEmLSYfJhymJYw3WFmYpZhtmL2YW5iXsf8gsWOpYBlBysXqx5rA+sxNjY2P7Y0ti62RWwf2NvYt3AwcDhwVHAs4TjFKcZpxxnCWcK5hPMA5y8uNa4Iri6uM9xs3AHcBdzzuPdwf+CR4XHjKeGZxrOC5xTPB14+XgXeKt5HfHJ8dXyH+CX49/C/E1ATSBGYILBDkE8wRLBJ8JaQm9AEoXvCYsIRwnXCm4TviPCJWIm0iCwQeSOqJ5onug4If4jZiLWJfRO3EE8RPyb+RyJP4pLEJ0kRST3JOZL7JH9J6UilSe2ROictIu0gnSA9R3qP9DcZCZkCmUuyCbIHZH/IGcgVyZ2TV5KfIH9FwUehSWGHwjdFN8U0xTbFdYrPlPSU2pSOKDMpeyivUP6nIqVSoLJC5YGqkmqZ6irVB2ppaqfU9dRnadhp3NAs02rS+qHtpj1F+5VOnk6fzjqdG7oqujV6Qno+em16J/Tt9JfpPzOwMmgzuGSoYbjK8JmRjtE0oyfGEcaLjF+YWJl0mFwyDTOdZ6ZlVmJ2zVzEPMv8isUci0MWNywZLA0sGyyPWX6zMrCKs5pidcpawzrN+pANh42XzSfbKtt9diJ2CXaH7CXsC+zvOLg5LHFkcTRz7HP85dTkdMhZzDnFeY7zFRchlzSXZS7PXNlcbVxrXNe4fsEO3ZjcBNzk3Czcgtya3La43XJXcE9zX+C+z/2P+x8PIQ81IGzxuODJ5mnkmeU5w/OA5zUvLa8dAEIzwdEAAQAAASkARwAFAAAAAAACAHIAhACLAAABoAF+AAAAAHjalVTLbtNQED1+8KgoUVmAUFdeoAqkYtJEohCxqSCpkApIJAIJsXFbN5g2cXESEFnxASxY8Qks+BIorNjBJ/AVnBmPoyRK1KCre33ueObM3OO5BnDZceHB8ZcAfOHMsYM17nLsooSfhj18wB/DPm47LwyfwarzyfBZBM5Xw+fQdU4Mn0fLvWN4CQ33o+ELuOf+MryMda9k+CJeejXDJbS8z4ZXcNX7a/gSlv2i/m+44hex31H2rxk+ob1l+AdW/Nc5/u1h1R/iARK0OfucQ8TYR8AZcR8R7SHFMd4jU69XtAa4TusNPisoY4PrTUNVrNPaolfM5yNGDhl1xCFM97nPyCVrpNlSdGmPuO5rXEzPGAdqT5hDopoIscXZoCUzi0T0iJ4wRvJIzQkG6OApcZtIMmbMKGtGvoT+0/ljbGOXEWuoMz5WzmN6xjjkzMgmebrMvo0a8yxWQW2kS3XBiGCq6meavTfSp8LTl5Wx4CvYhGucaX6+RLG86auHnLej2Q5pS6n5/363cErdYIa+gSkcUOPgFJUD1XkRztO5pEv7fFPDLY53OkLVaX5MqJ3emRO7N1FX4bujXZpz5vdmoL0svKJ0rucW2SL65bvJGLkvs7/37DqiMa5QVWnz7dEEZ4+WHTykdnU8ZifU9X4K57z+GO+h58S7dgflrm9oZFNPFpAvxVu13tVKK6yvyp2sm6PO39TaD5hjwGfKahNl66lumeo/4K4xytLEG1oS1Zh/gX/xR+EOAAB42m3QV2xbVRzH8e+vdezGrbv33m06bSdO4m4ntjsIKaQNI8xb27FNnetw40to2AJatkBI8ARivQBibxDwAIi9xEaCB/Yq4gEQs+D4XBCVONI9n3P////533MPI6iNQweJ8j9DDdVnhEbKx0h81OEnwCjqCTKaMYQYyzjGM4GJTGIyU5jKNKYzg5nMYjZzmMs85rOAhSxiMUtYyjKW08AKVrKK1axhLWEi1a830kSMZlpoJc461rOBjWxiM1tI0EY7SVKk2co2trODI+jgSDrZyVEcTRe72E03x3Asx3E8PZzAiZzEyZzCqViqk18BbuUiLuZJruMr9nMVl3MDt3ObRnEZH3Ih16peQa7kei7hGT7WaG7kDn7iR37mFu7iRZ7nbvaQ4WqyvEyOF3iJ13mFV3mNr+nlLd7gTe4hzw9cw7u8zTsU+JaDXMppFNlLHyVsbqLM6fTjMIBLhTMY5BvOZIh9nMU5nM2j3Mx5nMv5XMB3fM/jGqMQf3KIv4TGapzGS5qgiZqkyfzCr/zGe5qiqZqm6ZqhmXzCp5ql2ZqjuZqn+dzLfVqghVqkxVqipfzOH3zG51qm5WrQCq3UKp7Qaq3RWoX5gi95n4/4QBFF1agmxdSsFrUqrnVarw3aqE3arC3czwM8zCM8y4M8xHMc4E4leIqn1aZ2rlBSKaW1lce0Tdu1w58v7esvRAzRgGsXw+Fw0tiaMsY9E2FPL9/m1bc1esYDiXK+bOf2BiyjP5mxnLLtzxqSGadsVQIpryjnFaVMNmfosDJuJecvGTpMsFTD15EtV3yl6uTvNGnb0Gmq7BqhnQXXzluO21ey3Eqo/N83f5fZ4Bi6zD7HsMsEBwy7TbBSo67bKdr5Ond4DnUf1t89rH+P2TxUI9hTPaqVyeTsSnDo32X11/r2ZK3anTUlW4eNVi/dM+IZ9Wz0bPKMeTZ7tnj+0yfumTBGvL6RSLC3mHedXNYaKJhQNG2MpX0p1ynXW45THizleiuB2srtD9Z0ivlCxSSz5UG7tieWbh823WaOWzX6N88BNdMAeNpj8N7BcCIoYiMjY1/kBsadHAwcDMkFGxnYnRw4GRgiPS21GdgZtMB8gTSWOBY/DjsOA3Y1VjkWdg6ocBZTElMYmxubOas2sxITWJjPyZFT8oD4AeED/Ad4HDgPsB8AmsIJlBAFSjA4oECwBDODy0YVxo7AiA0OHREbmVNcNmqAeDs4GEBcBpdI6Y3qIIFdHA0MjCwOHckhEGEQcBDIYEpgCmBzYDNi1WBWYGLn0drB+L91A0vvRiYGl82sKWwMLi4ABPo1hQAAAVoSTJkAAA==') format('woff'); +} + + + +@font-face { +font-family: Fira; +font-style: italic; +font-weight: 300; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} +@font-face { +font-family: Fira; +font-style: italic; +font-weight: 400; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} + + +@font-face { +font-family: Fira-Mono; +font-style: normal; +font-weight: normal; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} +@font-face { +font-family: Fira-Mono; +font-style: normal; +font-weight: 500; +font-stretch: normal; +src: url('data:application/font-woff;charset=utf-8;base64,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') format('woff'); +} + + + +/************* Start Fira license ******************* +Digitized data copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A. +with Reserved Font Name < Fira >, + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +http://scripts.sil.org/OFL + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. + +************** End Fira license *********************/ + + diff --git a/docs/manual-racket.css b/docs/manual-racket.css new file mode 100644 index 0000000..dc00431 --- /dev/null +++ b/docs/manual-racket.css @@ -0,0 +1,324 @@ +/* See the beginning of "manual.css". */ + +/* Monospace: */ + +.RktIn, .RktRdr, .RktPn, .RktMeta, +.RktMod, .RktKw, .RktVar, .RktSym, +.RktRes, .RktOut, .RktCmt, .RktVal, +.RktBlk, .RktErr { + font-family: 'Fira-Mono', monospace; + white-space: inherit; + font-size: 1rem; + line-height: 1.5; + +} + +/* this selctor grabs the first linked Racket symbol +in a definition box (i.e., the symbol being defined) */ +a.RktValDef, a.RktStxDef, a.RktSymDef, +span.RktValDef, span.RktStxDef, span.RktSymDef +{ + font-size: 1.1rem; + color: black; + font-weight: 500; +} + + +.inheritedlbl { + font-family: 'Fira', sans-serif; +} + +.RBackgroundLabelInner { + font-family: inherit; +} + +/* ---------------------------------------- */ +/* Inherited methods, left margin */ + +.inherited { + width: 95%; + margin-top: 0.5em; + text-align: left; + background-color: inherit; +} + +.inherited td { + font-size: 82%; + padding-left: 0.5rem; + line-height: 1.3; + text-indent: 0; + padding-right: 0; +} + +.inheritedlbl { + font-style: normal; +} + +/* ---------------------------------------- */ +/* Racket text styles */ + +.RktIn { + color: #cc6633; + background-color: #eee; +} + +.RktInBG { + background-color: #eee; +} + + +.refcolumn .RktInBG { + background-color: white; +} + +.RktRdr { +} + +.RktPn { + color: #843c24; +} + +.RktMeta { + color: black; +} + +.RktMod { + color: inherit; +} + +.RktOpt { + color: black; +} + +.RktKw { + color: black; +} + +.RktErr { + color: red; + font-style: italic; + font-weight: 400; +} + +.RktVar { + position: relative; + left: -1px; font-style: italic; + color: #444; +} + +.SVInsetFlow .RktVar { + font-weight: 400; + color: #444; +} + + +.RktSym { + color: inherit; +} + + + +.RktValLink, .RktStxLink, .RktModLink { + text-decoration: none; + color: #07A; + font-size: 1rem; +} + +/* for syntax links within headings */ +h2 a.RktStxLink, h3 a.RktStxLink, h4 a.RktStxLink, h5 a.RktStxLink, +h2 a.RktValLink, h3 a.RktValLink, h4 a.RktValLink, h5 a.RktValLink, +h2 .RktSym, h3 .RktSym, h4 .RktSym, h5 .RktSym, +h2 .RktMod, h3 .RktMod, h4 .RktMod, h5 .RktMod, +h2 .RktVal, h3 .RktVal, h4 .RktVal, h5 .RktVal, +h2 .RktPn, h3 .RktPn, h4 .RktPn, h5 .RktPn { + color: #333; + font-size: 1.50rem; + font-weight: 400; +} + +.toptoclink .RktStxLink, .toclink .RktStxLink, +.toptoclink .RktValLink, .toclink .RktValLink, +.toptoclink .RktModLink, .toclink .RktModLink { + color: inherit; +} + +.tocset .RktValLink, .tocset .RktStxLink, .tocset .RktModLink, .tocset .RktSym { + color: black; + font-weight: 400; + font-size: 0.9rem; +} + +.tocset td a.tocviewselflink .RktValLink, +.tocset td a.tocviewselflink .RktStxLink, +.tocset td a.tocviewselflink .RktMod, +.tocset td a.tocviewselflink .RktSym { + font-weight: lighter; + color: white; +} + + +.RktRes { + color: #0000af; +} + +.RktOut { + color: #960096; +} + +.RktCmt { + color: #c2741f; +} + +.RktVal { + color: #228b22; +} + +/* ---------------------------------------- */ +/* Some inline styles */ + +.together { /* for definitions grouped together in one box */ + width: 100%; + border-top: 2px solid white; +} + +tbody > tr:first-child > td > .together { + border-top: 0px; /* erase border on first instance of together */ +} + +.RktBlk { + white-space: pre; + text-align: left; +} + +.highlighted { + font-size: 1rem; + background-color: #fee; +} + +.defmodule { + font-family: 'Fira-Mono', monospace; + padding: 0.25rem 0.75rem 0.25rem 0.5rem; + margin-bottom: 1rem; + width: 100%; + background-color: #ebf0f4; +} + +.defmodule a { + color: #444; +} + + +.defmodule td span.hspace:first-child { + position: absolute; + width: 0; + display: inline-block; +} + +.defmodule .RpackageSpec .Smaller, +.defmodule .RpackageSpec .stt { + font-size: 1rem; +} + +/* make parens ordinary color in defmodule */ +.defmodule .RktPn { + color: inherit; +} + +.specgrammar { + float: none; + padding-left: 1em; +} + + +.RBibliography td { + vertical-align: text-top; + padding-top: 1em; +} + +.leftindent { + margin-left: 2rem; + margin-right: 0em; +} + +.insetpara { + margin-left: 1em; + margin-right: 1em; +} + +.SCodeFlow .Rfilebox { + margin-left: -1em; /* see 17.2 of guide, module languages */ +} + +.Rfiletitle { + text-align: right; + background-color: #eee; +} + +.SCodeFlow .Rfiletitle { + border-top: 1px dotted gray; + border-right: 1px dotted gray; +} + + +.Rfilename { + border-top: 0; + border-right: 0; + padding-left: 0.5em; + padding-right: 0.5em; + background-color: inherit; +} + +.Rfilecontent { + margin: 0.5em; +} + +.RpackageSpec { + padding-right: 0; +} + +/* ---------------------------------------- */ +/* For background labels */ + +.RBackgroundLabel { + float: right; + width: 0px; + height: 0px; +} + +.RBackgroundLabelInner { + position: relative; + width: 25em; + left: -25.5em; + top: 0.20rem; /* sensitive to monospaced font choice */ + text-align: right; + z-index: 0; + font-weight: 300; + font-family: 'Fira-Mono', monospace; + font-size: 0.9rem; + color: gray; +} + + +.RpackageSpec .Smaller { + font-weight: 300; + font-family: 'Fira-Mono', monospace; + font-size: 0.9rem; +} + +.RForeground { + position: relative; + left: 0px; + top: 0px; + z-index: 1; +} + +/* ---------------------------------------- */ +/* For section source modules & tags */ + +.RPartExplain { + background: #eee; + font-size: 0.9rem; + margin-top: 0.2rem; + padding: 0.2rem; + text-align: left; +} diff --git a/docs/manual-racket.js b/docs/manual-racket.js new file mode 100644 index 0000000..203d6d3 --- /dev/null +++ b/docs/manual-racket.js @@ -0,0 +1,98 @@ +/* For the Racket manual style */ + +AddOnLoad(function() { + /* Look for header elements that have x-source-module and x-part tag. + For those elements, add a hidden element that explains how to + link to the section, and set the element's onclick() to display + the explanation. */ + var tag_names = ["h1", "h2", "h3", "h4", "h5"]; + for (var j = 0; j < tag_names.length; j++) { + elems = document.getElementsByTagName(tag_names[j]); + for (var i = 0; i < elems.length; i++) { + var elem = elems.item(i); + AddPartTitleOnClick(elem); + } + } +}) + +function AddPartTitleOnClick(elem) { + var mod_path = elem.getAttribute("x-source-module"); + var tag = elem.getAttribute("x-part-tag"); + if (mod_path && tag) { + // Might not be present: + var prefixes = elem.getAttribute("x-part-prefixes"); + + var info = document.createElement("div"); + info.className = "RPartExplain"; + + /* The "top" tag refers to a whole document: */ + var is_top = (tag == "\"top\""); + info.appendChild(document.createTextNode("Link to this " + + (is_top ? "document" : "section") + + " with ")); + + /* Break `secref` into two lines if the module path and tag + are long enough: */ + var is_long = (is_top ? false : ((mod_path.length + + tag.length + + (prefixes ? (16 + prefixes.length) : 0)) + > 60)); + + var line1 = document.createElement("div"); + var line1x = ((is_long && prefixes) ? document.createElement("div") : line1); + var line2 = (is_long ? document.createElement("div") : line1); + + function add(dest, str, cn) { + var s = document.createElement("span"); + s.className = cn; + s.style.whiteSpace = "nowrap"; + s.appendChild(document.createTextNode(str)); + dest.appendChild(s); + } + /* Construct a `secref` call with suitable syntax coloring: */ + add(line1, "\xA0@", "RktRdr"); + add(line1, (is_top ? "other-doc" : "secref"), "RktSym"); + add(line1, "[", "RktPn"); + if (!is_top) + add(line1, tag, "RktVal"); + if (is_long) { + /* indent additional lines: */ + if (prefixes) + add(line1x, "\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0", "RktPn"); + add(line2, "\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0", "RktPn"); + } + if (prefixes) { + add(line1x, " #:tag-prefixes ", "RktPn"); + add(line1x, "'", "RktVal"); + add(line1x, prefixes, "RktVal"); + } + if (!is_top) + add(line2, " #:doc ", "RktPn"); + add(line2, "'", "RktVal"); + add(line2, mod_path, "RktVal"); + add(line2, "]", "RktPn"); + + info.appendChild(line1); + if (is_long) + info.appendChild(line1x); + if (is_long) + info.appendChild(line2); + + info.style.display = "none"; + + /* Add the new element afterthe header: */ + var n = elem.nextSibling; + if (n) + elem.parentNode.insertBefore(info, n); + else + elem.parentNode.appendChild(info); + + /* Clicking the header shows the explanation element: */ + elem.onclick = function () { + if (info.style.display == "none") + info.style.display = "block"; + else + info.style.display = "none"; + } + } +} diff --git a/docs/manual-style.css b/docs/manual-style.css new file mode 100644 index 0000000..074addb --- /dev/null +++ b/docs/manual-style.css @@ -0,0 +1,770 @@ + +/* See the beginning of "scribble.css". + This file is used by the `scribble/manual` language, along with + "manual-racket.css". */ + +@import url("manual-fonts.css"); + +* { + margin: 0; + padding: 0; +} + +@media all {html {font-size: 15px;}} +@media all and (max-width:940px){html {font-size: 14px;}} +@media all and (max-width:850px){html {font-size: 13px;}} +@media all and (max-width:830px){html {font-size: 12px;}} +@media all and (max-width:740px){html {font-size: 11px;}} + +/* CSS seems backward: List all the classes for which we want a + particular font, so that the font can be changed in one place. (It + would be nicer to reference a font definition from all the places + that we want it.) + + As you read the rest of the file, remember to double-check here to + see if any font is set. */ + +/* Monospace: */ +.maincolumn, .refpara, .refelem, .tocset, .stt, .hspace, .refparaleft, .refelemleft { + font-family: 'Fira-Mono', monospace; + white-space: inherit; + font-size: 1rem; +} + +/* embolden the "Racket Guide" and "Racket Reference" links on the TOC */ +/* there isn't an obvious tag in the markup that designates the top TOC page, which is called "start.scrbl" */ +/* nor a tag that designates these two links as special */ +/* so we'll use this slightly tortured sibling selector that hooks onto the h2 tag */ +h2[x-source-module='(lib "scribblings/main/start.scrbl")'] ~ table a[href="guide/index.html"], +h2[x-source-module='(lib "scribblings/main/start.scrbl")'] ~ table a[href="reference/index.html"] { + font-weight: bold; +} + + +h2 .stt { + font-size: 2.3rem; + /* prevent automatic bolding from h2 */ + font-weight: 400; +} + +.toptoclink .stt { + font-size: inherit; +} +.toclink .stt { + font-size: 90%; +} + +.RpackageSpec .stt { + font-weight: 300; + font-family: 'Fira-Mono', monospace; + font-size: 0.9rem; +} + +h3 .stt, h4 .stt, h5 .stt { + color: #333; + font-size: 1.65rem; + font-weight: 400; +} + + +/* Serif: */ +.main, .refcontent, .tocview, .tocsub, .sroman, i { + font-family: 'Charter-Racket', serif; + font-size: 1.18rem; +/* Don't use font-feature-settings with Charter, +it fouls up loading for reasons mysterious */ +/* font-feature-settings: 'tnum' 1, 'liga' 0; */ +} + + +/* Sans-serif: */ +.version, .versionNoNav, .ssansserif { + font-family: 'Fira', sans-serif; +} + +/* used mostly for DrRacket menu commands */ +.ssansserif { + font-family: 'Fira', sans-serif; + font-size: 0.9em; +} + +.tocset .ssansserif { + font-size: 100%; +} + +/* ---------------------------------------- */ + +p, .SIntrapara { + display: block; + margin: 0 0 1em 0; + line-height: 1.4; +} + +.compact { + padding: 0 0 1em 0; +} + +li { + list-style-position: outside; + margin-left: 1.2em; +} + +h1, h2, h3, h4, h5, h6, h7, h8 { + font-family: 'Fira', sans-serif; + font-weight: 300; + font-size: 1.6rem; + color: #333; + margin-top: inherit; + margin-bottom: 1rem; + line-height: 1.25; + +} + +h3, h4, h5, h6, h7, h8 { + border-top: 1px solid black; +} + + + +h2 { /* per-page main title */ + font-family: 'Cooper-Hewitt'; + margin-top: 4rem; + font-size: 2.3rem; + font-weight: bold; + line-height: 1.2; + width: 90%; + /* a little nudge to make text visually lower than 4rem rule in left margin */ + position: relative; + top: 6px; +} + +h3, h4, h5, h6, h7, h8 { + margin-top: 2em; + padding-top: 0.1em; + margin-bottom: 0.75em; +} + +/* ---------------------------------------- */ +/* Main */ + +body { + color: black; + background-color: white; +} + +.maincolumn { + width: auto; + margin-top: 4rem; + margin-left: 17rem; + margin-right: 2rem; + margin-bottom: 10rem; /* to avoid fixed bottom nav bar */ + max-width: 700px; + min-width: 370px; /* below this size, code samples don't fit */ +} + +a { + text-decoration: inherit; +} + +a, .toclink, .toptoclink, .tocviewlink, .tocviewselflink, .tocviewtoggle, .plainlink, +.techinside, .techoutside:hover, .techinside:hover { + color: #07A; +} + +a:hover { + text-decoration: underline; +} + + +/* ---------------------------------------- */ +/* Navigation */ + +.navsettop, .navsetbottom { + left: 0; + width: 15rem; + height: 6rem; + font-family: 'Fira', sans-serif; + font-size: 0.9rem; + border-bottom: 0px solid hsl(216, 15%, 70%); + background-color: inherit; + padding: 0; +} + +.navsettop { + position: absolute; + top: 0; + left: 0; + margin-bottom: 0; + border-bottom: 0; +} + +.navsettop a, .navsetbottom a { + color: black; +} + +.navsettop a:hover, .navsetbottom a:hover { + background: hsl(216, 78%, 95%); + text-decoration: none; +} + +.navleft, .navright { + position: static; + float: none; + margin: 0; + white-space: normal; +} + + +.navleft a { + display: inline-block; +} + +.navright a { + display: inline-block; + text-align: center; +} + +.navleft a, .navright a, .navright span { + display: inline-block; + padding: 0.5rem; + min-width: 1rem; +} + + +.navright { + height: 2rem; + white-space: nowrap; +} + + +.navsetbottom { + display: none; +} + +.nonavigation { + color: #889; +} + +.searchform { + display: block; + margin: 0; + padding: 0; + border-bottom: 1px solid #eee; + height: 4rem; +} + +.nosearchform { + margin: 0; + padding: 0; + height: 4rem; +} + +.searchbox { + font-size: 0.9rem; + width: 12rem; + margin: 1rem; + padding: 0.25rem 0.4rem ; + vertical-align: middle; + background-color: white; + font-family: 'Fira-Mono', monospace; +} + + +#search_box { + font-family: 'Fira-Mono', monospace; + font-size: 1rem; + padding: 0.25rem 0.3rem ; +} + +/* Default to local view. Global will specialize */ +.plt_global_only { display: none; } +.plt_local_only { display: block; } + +/* ---------------------------------------- */ +/* Version */ + +.versionbox { + position: absolute; + float: none; + top: 0.25rem; + left: 17rem; + z-index: 11000; + height: 2em; + font-size: 70%; + font-weight: lighter; + width: inherit; + margin: 0; +} +.version, .versionNoNav { + font-size: inherit; +} +.version:before, .versionNoNav:before { + content: "v."; +} + + +/* ---------------------------------------- */ +/* Margin notes */ + +/* cancel scribble.css styles: */ +.refpara, .refelem { + position: static; + float: none; + height: auto; + width: auto; + margin: 0; +} + +.refcolumn { + position: static; + display: block; + width: auto; + font-size: inherit; + margin: 2rem; + margin-left: 2rem; + padding: 0.5em; + padding-left: 0.75em; + padding-right: 1em; + background: hsl(60, 29%, 94%); + border: 1px solid #ccb; + border-left: 0.4rem solid #ccb; +} + + +/* slightly different handling for margin-note* on narrow screens */ +@media all and (max-width:1340px) { + span.refcolumn { + float: right; + width: 50%; + margin-left: 1rem; + margin-bottom: 0.8rem; + margin-top: 1.2rem; + } + +} + +.refcontent, .refcontent p { + line-height: 1.5; + margin: 0; +} + +.refcontent p + p { + margin-top: 1em; +} + +.refcontent a { + font-weight: 400; +} + +.refpara, .refparaleft { + top: -1em; +} + + +@media all and (max-width:600px) { + .refcolumn { + margin-left: 0; + margin-right: 0; + } +} + + +@media all and (min-width:1340px) { + .refcolumn { + margin: 0 -22.5rem 1rem 0; + float: right; + clear: right; + width: 18rem; + } +} + +.refcontent { + font-family: 'Fira', sans-serif; + font-size: 1rem; + line-height: 1.6; + margin: 0 0 0 0; +} + + +.refparaleft, .refelemleft { + position: relative; + float: left; + right: 2em; + height: 0em; + width: 13em; + margin: 0em 0em 0em -13em; +} + +.refcolumnleft { + background-color: hsl(60, 29%, 94%); + display: block; + position: relative; + width: 13em; + font-size: 85%; + border: 0.5em solid hsl(60, 29%, 94%); + margin: 0 0 0 0; +} + + +/* ---------------------------------------- */ +/* Table of contents, left margin */ + +.tocset { + position: absolute; + float: none; + left: 0; + top: 0rem; + width: 14rem; + padding: 7rem 0.5rem 0.5rem 0.5rem; + background-color: hsl(216, 15%, 70%); + margin: 0; + +} + +.tocset td { + vertical-align: text-top; + padding-bottom: 0.4rem; + padding-left: 0.2rem; + line-height: 1.1; + font-family: 'Fira', sans-serif; +} + +.tocset td a { + color: black; + font-weight: 400; +} + + +.tocview { + text-align: left; + background-color: inherit; +} + + +.tocview td, .tocsub td { + line-height: 1.3; +} + + +.tocview table, .tocsub table { + width: 90%; +} + +.tocset td a.tocviewselflink { + font-weight: lighter; + font-size: 110%; /* monospaced styles below don't need to enlarge */ + color: white; +} + +.tocviewselflink { + text-decoration: none; +} + +.tocsub { + text-align: left; + margin-top: 0.5em; + background-color: inherit; +} + +.tocviewlist, .tocsublist { + margin-left: 0.2em; + margin-right: 0.2em; + padding-top: 0.2em; + padding-bottom: 0.2em; +} +.tocviewlist table { + font-size: 82%; +} + +.tocviewlisttopspace { + margin-bottom: 1em; +} + +.tocviewsublist, .tocviewsublistonly, .tocviewsublisttop, .tocviewsublistbottom { + margin-left: 0.4em; + border-left: 1px solid #99a; + padding-left: 0.8em; +} +.tocviewsublist { + margin-bottom: 1em; +} +.tocviewsublist table, +.tocviewsublistonly table, +.tocviewsublisttop table, +.tocviewsublistbottom table, +table.tocsublist { + font-size: 1rem; +} + +.tocviewsublist td, +.tocviewsublistbottom td, +.tocviewsublisttop td, +.tocsub td, +.tocviewsublistonly td { + font-size: 90%; +} + +/* shrink the monospaced text (`stt`) within nav */ +.tocviewsublist td .stt, +.tocviewsublistbottom td .stt, +.tocviewsublisttop td .stt, +.tocsub td .stt, +.tocviewsublistonly td .stt { + font-size: 95%; +} + + +.tocviewtoggle { + font-size: 75%; /* looks better, and avoids bounce when toggling sub-sections due to font alignments */ +} + +.tocsublist td { + padding-left: 0.5rem; + padding-top: 0.25rem; + text-indent: 0; +} + +.tocsublinknumber { + font-size: 100%; +} + +.tocsublink { + font-size: 82%; + text-decoration: none; +} + +.tocsubseclink { + font-size: 100%; + text-decoration: none; +} + +.tocsubnonseclink { + font-size: 82%; + text-decoration: none; + margin-left: 1rem; + padding-left: 0; + display: inline-block; +} + +/* the label "on this page" */ +.tocsubtitle { + display: block; + font-size: 62%; + font-family: 'Fira', sans-serif; + font-weight: bolder; + font-style: normal; + letter-spacing: 2px; + text-transform: uppercase; + margin: 0.5em; +} + +.toptoclink { + font-weight: bold; + font-size: 110%; + margin-bottom: 0.5rem; + margin-top: 1.5rem; + display: inline-block; +} + +.toclink { + font-size: inherit; +} + +/* ---------------------------------------- */ +/* Some inline styles */ + +.indexlink { + text-decoration: none; +} + +pre { + margin-left: 2em; +} + +blockquote { + margin-left: 2em; + margin-right: 2em; + margin-bottom: 1em; +} + +.SCodeFlow { + border-left: 1px dotted black; + padding-left: 1em; + padding-right: 1em; + margin-top: 1em; + margin-bottom: 1em; + margin-left: 0em; + margin-right: 2em; + white-space: nowrap; + line-height: 1.5; +} + +.SCodeFlow img { + margin-top: 0.5em; + margin-bottom: 0.5em; +} + +/* put a little air between lines of code sample */ +/* Fira Mono appears taller than Source Code Pro */ +.SCodeFlow td { + padding-bottom: 1px; +} + +.boxed { + margin: 0; + margin-top: 2em; + padding: 0.25em; + padding-top: 0.3em; + padding-bottom: 0.4em; + background: #f3f3f3; + box-sizing:border-box; + border-top: 1px solid #99b; + background: hsl(216, 78%, 95%); + background: -moz-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 62%, 95%) 100%); + background: -webkit-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 62%, 95%) 100%); + background: -o-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 62%, 95%) 100%); + background: -ms-linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 62%, 95%) 100%); + background: linear-gradient(to bottom left, hsl(0, 0%, 99%) 0%, hsl(216, 62%, 95%) 100%); +} + +blockquote > blockquote.SVInsetFlow { +/* resolves issue in e.g. /reference/notation.html */ + margin-top: 0em; +} + +.leftindent .SVInsetFlow { /* see e.g. section 4.5 of Racket Guide */ + margin-top: 1em; + margin-bottom: 1em; +} + +.SVInsetFlow a, .SCodeFlow a { + color: #07A; +} + +.SubFlow { + display: block; + margin: 0em; +} + +.boxed { + width: 100%; + background-color: inherit; +} + +.techoutside { text-decoration: none; } + +.SAuthorListBox { + position: static; + float: none; + font-family: 'Fira', sans-serif; + font-weight: 300; + font-size: 110%; + margin-top: 1rem; + margin-bottom: 2rem; + width: 30rem; + height: auto; +} + +.author > a { /* email links within author block */ + font-weight: inherit; + color: inherit; +} + +.SAuthorList { + font-size: 82%; +} +.SAuthorList:before { + content: "by "; +} +.author { + display: inline; + white-space: nowrap; +} + +/* phone + tablet styles */ + +@media all and (max-width:720px){ + + + @media all and (max-width:720px){ + + @media all {html {font-size: 15px;}} + @media all and (max-width:700px){html {font-size: 14px;}} + @media all and (max-width:630px){html {font-size: 13px;}} + @media all and (max-width:610px){html {font-size: 12px;}} + @media all and (max-width:550px){html {font-size: 11px;}} + @media all and (max-width:520px){html {font-size: 10px;}} + + .navsettop, .navsetbottom { + display: block; + position: absolute; + width: 100%; + height: 4rem; + border: 0; + background-color: hsl(216, 15%, 70%); + } + + .searchform { + display: inline; + border: 0; + } + + .navright { + position: absolute; + right: 1.5rem; + margin-top: 1rem; + border: 0px solid red; + } + + .navsetbottom { + display: block; + margin-top: 8rem; + } + + .tocset { + display: none; + } + + .tocset table, .tocset tbody, .tocset tr, .tocset td { + display: inline; + } + + .tocview { + display: none; + } + + .tocsub .tocsubtitle { + display: none; + } + + .versionbox { + top: 4.5rem; + left: 1rem; /* same distance as main-column */ + z-index: 11000; + height: 2em; + font-size: 70%; + font-weight: lighter; + } + + + .maincolumn { + margin-left: 1em; + margin-top: 7rem; + margin-bottom: 0rem; + } + + } + +} + +/* print styles : hide the navigation elements */ +@media print { + .tocset, + .navsettop, + .navsetbottom { display: none; } + .maincolumn { + width: auto; + margin-right: 13em; + margin-left: 0; + } +} diff --git a/docs/pict.png b/docs/pict.png new file mode 100644 index 0000000000000000000000000000000000000000..ca59973e369129421bd9d30f8605ea5bf95e708c GIT binary patch literal 2348 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 literal 0 HcmV?d00001 diff --git a/docs/racket.css b/docs/racket.css new file mode 100644 index 0000000..b44fef5 --- /dev/null +++ b/docs/racket.css @@ -0,0 +1,249 @@ + +/* See the beginning of "scribble.css". */ + +/* Monospace: */ +.RktIn, .RktRdr, .RktPn, .RktMeta, +.RktMod, .RktKw, .RktVar, .RktSym, +.RktRes, .RktOut, .RktCmt, .RktVal, +.RktBlk { + font-family: monospace; + white-space: inherit; +} + +/* Serif: */ +.inheritedlbl { + font-family: serif; +} + +/* Sans-serif: */ +.RBackgroundLabelInner { + font-family: sans-serif; +} + +/* ---------------------------------------- */ +/* Inherited methods, left margin */ + +.inherited { + width: 100%; + margin-top: 0.5em; + text-align: left; + background-color: #ECF5F5; +} + +.inherited td { + font-size: 82%; + padding-left: 1em; + text-indent: -0.8em; + padding-right: 0.2em; +} + +.inheritedlbl { + font-style: italic; +} + +/* ---------------------------------------- */ +/* Racket text styles */ + +.RktIn { + color: #cc6633; + background-color: #eeeeee; +} + +.RktInBG { + background-color: #eeeeee; +} + +.RktRdr { +} + +.RktPn { + color: #843c24; +} + +.RktMeta { + color: black; +} + +.RktMod { + color: black; +} + +.RktOpt { + color: black; +} + +.RktKw { + color: black; +} + +.RktErr { + color: red; + font-style: italic; +} + +.RktVar { + color: #262680; + font-style: italic; +} + +.RktSym { + color: #262680; +} + +.RktSymDef { /* used with RktSym at def site */ +} + +.RktValLink { + text-decoration: none; + color: blue; +} + +.RktValDef { /* used with RktValLink at def site */ +} + +.RktModLink { + text-decoration: none; + color: blue; +} + +.RktStxLink { + text-decoration: none; + color: black; +} + +.RktStxDef { /* used with RktStxLink at def site */ +} + +.RktRes { + color: #0000af; +} + +.RktOut { + color: #960096; +} + +.RktCmt { + color: #c2741f; +} + +.RktVal { + color: #228b22; +} + +/* ---------------------------------------- */ +/* Some inline styles */ + +.together { + width: 100%; +} + +.prototype, .argcontract, .RBoxed { + white-space: nowrap; +} + +.prototype td { + vertical-align: text-top; +} + +.RktBlk { + white-space: inherit; + text-align: left; +} + +.RktBlk tr { + white-space: inherit; +} + +.RktBlk td { + vertical-align: baseline; + white-space: inherit; +} + +.argcontract td { + vertical-align: text-top; +} + +.highlighted { + background-color: #ddddff; +} + +.defmodule { + width: 100%; + background-color: #F5F5DC; +} + +.specgrammar { + float: right; +} + +.RBibliography td { + vertical-align: text-top; +} + +.leftindent { + margin-left: 1em; + margin-right: 0em; +} + +.insetpara { + margin-left: 1em; + margin-right: 1em; +} + +.Rfilebox { +} + +.Rfiletitle { + text-align: right; + margin: 0em 0em 0em 0em; +} + +.Rfilename { + border-top: 1px solid #6C8585; + border-right: 1px solid #6C8585; + padding-left: 0.5em; + padding-right: 0.5em; + background-color: #ECF5F5; +} + +.Rfilecontent { + margin: 0em 0em 0em 0em; +} + +.RpackageSpec { + padding-right: 0.5em; +} + +/* ---------------------------------------- */ +/* For background labels */ + +.RBackgroundLabel { + float: right; + width: 0px; + height: 0px; +} + +.RBackgroundLabelInner { + position: relative; + width: 25em; + left: -25.5em; + top: 0px; + text-align: right; + color: white; + z-index: 0; + font-weight: bold; +} + +.RForeground { + position: relative; + left: 0px; + top: 0px; + z-index: 1; +} + +/* ---------------------------------------- */ +/* History */ + +.SHistory { + font-size: 82%; +} diff --git a/docs/scribble-common.js b/docs/scribble-common.js new file mode 100644 index 0000000..1ec7da5 --- /dev/null +++ b/docs/scribble-common.js @@ -0,0 +1,170 @@ +// Common functionality for PLT documentation pages + +// Page Parameters ------------------------------------------------------------ + +var page_query_string = location.search.substring(1); + +var page_args = + ((function(){ + if (!page_query_string) return []; + var args = page_query_string.split(/[&;]/); + for (var i=0; i= 0) args[i] = [a.substring(0,p), a.substring(p+1)]; + else args[i] = [a, false]; + } + return args; + })()); + +function GetPageArg(key, def) { + for (var i=0; i= 0 && cur.substring(0,eql) == key) + return unescape(cur.substring(eql+1)); + } + return def; + } +} + +function SetCookie(key, val) { + try { + localStorage[key] = val; + } catch(e) { + var d = new Date(); + d.setTime(d.getTime()+(365*24*60*60*1000)); + try { + document.cookie = + key + "=" + escape(val) + "; expires="+ d.toGMTString() + "; path=/"; + } catch (e) {} + } +} + +// note that this always stores a directory name, ending with a "/" +function SetPLTRoot(ver, relative) { + var root = location.protocol + "//" + location.host + + NormalizePath(location.pathname.replace(/[^\/]*$/, relative)); + SetCookie("PLT_Root."+ver, root); +} + +// adding index.html works because of the above +function GotoPLTRoot(ver, relative) { + var u = GetCookie("PLT_Root."+ver, null); + if (u == null) return true; // no cookie: use plain up link + // the relative path is optional, default goes to the toplevel start page + if (!relative) relative = "index.html"; + location = u + relative; + return false; +} + +// Utilities ------------------------------------------------------------------ + +var normalize_rxs = [/\/\/+/g, /\/\.(\/|$)/, /\/[^\/]*\/\.\.(\/|$)/]; +function NormalizePath(path) { + var tmp, i; + for (i = 0; i < normalize_rxs.length; i++) + while ((tmp = path.replace(normalize_rxs[i], "/")) != path) path = tmp; + return path; +} + +// `noscript' is problematic in some browsers (always renders as a +// block), use this hack instead (does not always work!) +// document.write(""); + +// Interactions --------------------------------------------------------------- + +function DoSearchKey(event, field, ver, top_path) { + var val = field.value; + if (event && event.keyCode == 13) { + var u = GetCookie("PLT_Root."+ver, null); + if (u == null) u = top_path; // default: go to the top path + u += "search/index.html?q=" + encodeURIComponent(val); + u = MergePageArgsIntoUrl(u); + location = u; + return false; + } + return true; +} + +function TocviewToggle(glyph, id) { + var s = document.getElementById(id).style; + var expand = s.display == "none"; + s.display = expand ? "block" : "none"; + glyph.innerHTML = expand ? "▼" : "►"; +} + +// Page Init ------------------------------------------------------------------ + +// Note: could make a function that inspects and uses window.onload to chain to +// a previous one, but this file needs to be required first anyway, since it +// contains utilities for all other files. +var on_load_funcs = []; +function AddOnLoad(fun) { on_load_funcs.push(fun); } +window.onload = function() { + for (var i=0; i + .techinside doesn't work with IE, so use both (and IE doesn't + work with inherit in the second one, so use blue directly) */ +.techinside { color: black; } +.techinside:hover { color: blue; } +.techoutside:hover>.techinside { color: inherit; } + +.SCentered { + text-align: center; +} + +.imageleft { + float: left; + margin-right: 0.3em; +} + +.Smaller { + font-size: 82%; +} + +.Larger { + font-size: 122%; +} + +/* A hack, inserted to break some Scheme ids: */ +.mywbr { + display: inline-block; + height: 0; + width: 0; + font-size: 1px; +} + +.compact li p { + margin: 0em; + padding: 0em; +} + +.noborder img { + border: 0; +} + +.SAuthorListBox { + position: relative; + float: right; + left: 2em; + top: -2.5em; + height: 0em; + width: 13em; + margin: 0em -13em 0em 0em; +} +.SAuthorList { + font-size: 82%; +} +.SAuthorList:before { + content: "by "; +} +.author { + display: inline; + white-space: nowrap; +} + +/* print styles : hide the navigation elements */ +@media print { + .tocset, + .navsettop, + .navsetbottom { display: none; } + .maincolumn { + width: auto; + margin-right: 13em; + margin-left: 0; + } +} diff --git a/docs/sudoku.png b/docs/sudoku.png new file mode 100644 index 0000000000000000000000000000000000000000..8f77a8f070ab21ca9c052bf0dd4a38c0e033bd02 GIT binary patch literal 3211 zcmd6qdpOg5AIHZKX~eptIjqozYveGN(wvqN8I_RO$S4%<p`5~G6Omh+Q%;$Cbjr%y080r{`mgB*Y|tmk39Zq^R(E;8t#=a1uFx1ZxQ>Y*(HXF2wvS4qFIsqDz1E5*Mze zf^FQ+0{}9NZ$pF`l`CW=?tWUBpkRPkSG89GODZ9)>aRq=Rf zJ4i#Xbz{wp4Wo@@6=8>b=;_OoY3j73QiYZ)3U0ot#~YeaPDrGqA60<3d|ed*PNjhe zRt%e5dC~0%@Rq>Sic-#&4OAkP0s^UL9+Gq|w%04p^wKycB_f?FC1H$Ax~RR2&}h)u zaOqNt<8Cp8D@?J!Q&0Z!MY1?c45$RLw!FEum~e;ir-DWr#6?HWzhykS=hy3RW};e) z@5D!leiv$5mGsX@JNZ=Z66i!--}#kj=!R+pbQfr7Ve!ef-_w%D@%1G4q>ix1W~la- z-D@{ifj=HSO$d2whHjn1uCDE`CjRO~RAVJ7RgVcaGMhnPN9vgrsh7;f9I6jZzHqM;M^ z7K!q`eq7QL%JFK)T+E)h{?=PXxc(5eUy6liGY8I1IjE4w-!|rl_JQZRwCcLqRpnDO zO@dV|Jww8m5r15TdSM`El)TvZqfnV3#5ue|9dltd>-A+b6_4kjNZ_lDHa4wxc9MzS zQvYzje`ca!y!Cyl?3SzGu(W=_-|VxW>HbIasu$CX=3Xw$*7JP}*zH~QOjrCToTyx_ zrBMx^jTI$ucn@gJ)BLQySiq*&*hrq+2tv77?hV$2B&d{ONW5k?H^t4JoY(V>hj%xm z`f^7zJjJUV=4R&d)(?4Y3KW~ykG7R%eL3@NV9DKN_22G(57){T+uyW$y(*l<#-DwK zF+mrIhw47jnJ>Hbw3xU~oY-!@j^3Vq!<6ZkZMbBED(JOc-cyMPxc zUidOl0QNKzoH5UgFpwPDd9U?gccT8|TDK$_6wb>%`anrLw!Mj?861GSj&8e`<(UL6 z_fFErwV{~KYF}1e{CYad?e}W2dOWAO9(npFJ7u_)J$20w zEyI&&J45pE$Jk$2J^kOO0KXGS-!`;&C=`m zJFX8fqNrAh1$`*m11*)b`68o6gw?bUy27qAeSen7>Vsphg1>5P4UMI3zNp@)SH3*t z21qq1tXX5ZJnPcf=qlNHb; zUp0A$V$8nOxWZmY@i-MTV_rG2cw}_vXOAsGK>Pzq7RDcmJ?@`{szfSPK@6>Hq9@>q7iCN0&-P55G=@YO$O@16QXa;Qw zv8fXqW}}9!mZx@{O)9a+$ak90?&g2KTB2&4`rHl1 zhqD5z-{|>}V_Ao3f=9f7o44K+OO`%6Ub z9`y{$2cg8GEvK40X)7rDu$(l8Myz5;?09&X2JG)R#Ifi&7Mh(l4u_O38v z@;~un{#jf9zd&sP4JV!OisG!k52sX0x+c7A;)X?Z1(=b^TdU2w09F4#ysxh z7PJH`g15bld^Q_Xu|g1IH4ShEJopu|-x!_XQnEea8r>kI!P*=;R+F_4Gb{JTfTNk2 z^#jjcm8xxnPo8}wFEDzb{ru0_X}!1$0}9}k0v&L`tHRk6*8Np!+Cc*N)?MioXQ0wB z2?6GBTJoHF1hLjDzNQOK>HB&tvQ(h$)PFfkhXUfE5nwy?d`)!Z^TD>%BAksfeCe2s z8jwRy7E^yWa2{*I!72DF1cf+PMZC|MqTQ!<PpP9Xe&0N5UMz!X{%sDA+7?ua1( literal 0 HcmV?d00001 diff --git a/scrbl/amb.scrbl b/scrbl/amb.scrbl new file mode 100644 index 0000000..fcb9cd8 --- /dev/null +++ b/scrbl/amb.scrbl @@ -0,0 +1,201 @@ +#lang scribble/manual + +@(require "util.rkt") + +@title{Ambiguousness} + +@intro-para["6-booleans.rkt"] + +@para{ + Now that we have continuations, we will add continuations. +} +@para{ + We want to add support for the new forms @(racket amb) and @(racket require). + An @(racket amb) with multiple expressions, @(racket (amb exps ...)) is a form that evaluates to the value of one of its expressions. + A @(racket require) with an expression, @(racket (require exp)), succeeds if the expression evaluates to true (@(racket #t)) and fails if it evaluates to false (@(racket #f)). + If a @(racket require) fails, + the evaluator should backtrack to the last @(racket amb) and try to continue from there with the value of one of the ``remaining'' expressions of that @(racket amb). +} +@para{ + For taking care of the backtracky bits, we will use a @(racket fail)-continuation in addition to the @(racket continue)-continuation. +} + +@section[#:tag "amb-tests"]{Some tests} + +@(racketblock + (check-equal? + (eval-require primitives + (λ (x f) #t) + (λ () #f) + '(< 3 6)) + #t)) +@(racketblock + (check-equal? + (eval-require primitives + (λ (x f) #t) + (λ () #f) + '(> 3 6)) + #f)) + +@(racketblock + (check-equal? + (evaluate + '(begin + (define a (amb 1 (- 5 3) 6 8)) + (require (> a 5)) + a)) + 6)) + +@(racketblock + (check-equal? + (evaluate + '(begin + (define a (amb 1 3 5 7)) + (define b (amb 2 4 3 6)) + (require (= (+ a b) 9)) + (list a b))) + '(3 6))) + +@(racketblock + (check-equal? + (evaluate* + '(begin + (define a (amb 1 (- 5 3) 6 8)) + (require (> a 5)) + a)) + '(6 8))) + +@(racketblock + (check-equal? + (evaluate* + '(begin + (define a (amb 1 3 5 7)) + (define b (amb 2 4 3 6)) + (require (= (+ a b) 9)) + (list a b))) + '((3 6) (5 4) (7 2)))) + +@section{Some stuff will have a @(racket fail)-parameter} + +@para{ + The functions we use as @(racket continue)-continuations, as well as all functions that have @(racket continue)-parameters, should also have @(racket fail)-parameters. + Like, we will change continuation-lambdas like @(racket (λ (value) #,(emph "stuff"))) to ones like @(racket (λ (fail value) #,(emph "stuff"))), + and things like @(racket (eval-exp env continue exp)) to things like @(racket (eval-exp env continue fail exp)). + For now, the different functions will just pass their @(racket fail)s along. +} + +@para{ + The @(racket evaluate)-function should work like before. Just, it's @(racket continue)-argument should accept a failure-continuation in addition to the result, + and it should pass some @(racket fail)-argument to @(racket eval-exp): +} +@(racketblock + (define (evaluate input) + (eval-exp primitives + (λ (fail res) res) + (λ () (error 'ohno)) + input))) + +@section{@(racket require)} + +@para{ + In @(racket eval-exp) we will add a clause: +} +@(racketblock + [(list 'require x) + (eval-require env + continue + fail + x)]) +@para{ + And make the function @(racket (eval-require env continue fail exp)). + In @(racket eval-require) we will evaluate @(racket exp).} + +@para{The continuation we pass along to @(racket eval-exp) should carry on with @(racket continue) if @(racket x) evaluated to true, + or use @(racket fail) if it evaluated to false. + The @(racket fail)-continuation should not take any arguments. +} + +@para{ + The two tests that use @(racket eval-require) should pass after this. +} + + +@section{@(racket amb)} + +@para{ + To @(racket eval-exp) we add: +} + +@(racketblock + [(list 'amb exps ...) + (eval-amb env + continue + fail + exps)]) + +@para{ + And we make the function @(racket (eval-amb env continue fail exps)). +} + +@para{ + In @(racket eval-amb) we will @(racket match) the @(racket exps)-list. + If @(racket exps) is empty, we @(racket (fail)). + If @(racket exps) has at least one element, we will evaluate that expression with @(racket eval-exp): +} +@para{ + We can pass our @(racket continue)-continuation along. +} +@para{ + But we need to make a new failure-continuation, @(racket (λ () #,(emph "your code here"))). + We will make it so that if anything fails later in the program, we will @(racket eval-amb) with the remaining elements of the @(racket exps)-list. + (When we run out of elements in @(racket exps), we will invoke our ``original'' @(racket fail)-continuation, as per our first @(racket match)-clause.) +} + +@section{Btw let's add a @(racket list)-function to our @(racket primitives)} + +@para{ + Just, it would be nice to return multiple values now, so we will add Racket's @(racket list)-function to the @(racket primitives) list. +} + +@section{@(racket evaluate*)} + +@para{ + So @(racket evaluate) should work mostly like before, and it will return the first solution, or throw an error if there aren't any. +} + +@para{ + It would be neat to have an evaluation-function that could return a list of solutions instead. So we will make one. + In @(racket evaluate*), we, uh, ``replace failure with a list of successes,'' maybe: +} + +@(racketblock + (define (evaluate* input) + (eval-exp primitives + (λ (fail res) (cons res (fail))) + (λ () '()) + input))) + +@para{ + Now we can, say, make a program for finding numbers that add up to 10: +} + +@(racketblock + (define adds-up-to-10 + '(begin + (define a (amb 1 2 3 4 5 6 7 8 9)) + (define b (amb 1 2 3 4 5 6 7 8 9)) + (require (= (+ a b) 10)) + (list a b)))) + +@para{ + And we can get one solution with @(racket (evaluate adds-up-to-10)), or several solutions with @(racket (evaluate* adds-up-to-10)). +} + +@section[#:tag "amb-done"]{Done?} + +@@outro-test-para + +@para{ + Next: Maybe @secref{It_s_puzzle_time}, or we can go @secref{Towards_zebras}. We should be equipped for either. + We can keep using the Racket-file we're working with, or skip to @tt{7-amb.rkt}.. +} \ No newline at end of file diff --git a/scrbl/bools.scrbl b/scrbl/bools.scrbl new file mode 100644 index 0000000..81d294c --- /dev/null +++ b/scrbl/bools.scrbl @@ -0,0 +1,91 @@ +#lang scribble/manual + +@(require "util.rkt") + +@title{Booleans} + +@intro-para["5-continuation-passing-style.rkt"] + +@para{ + Add booleans. Go blind. +} + +@section[#:tag "bool-tests"]{Some tests} + +@(racketblock + (check-equal? + (evaluate '(if #f 3 5)) + 5)) + +@(racketblock + (check-equal? + (evaluate '(if (< 8 4) 1 0)) + 0)) + +@(racketblock + + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 1)) + 3)) + +@(racketblock + (check-equal? + (evaluate '((λ (a b) + (if (> a (+ b b)) 3 6)) + 9 5)) + 6)) + +@section{Literals} + +@para{ + We want to have two boolean literals: @(racket #t) (true) and @(racket #f) (false). + In @(racket eval-exp) these can be matched and handled quite the same way as number-literals. + We can use Racket's @(racket boolean?)-function to match booleans, the way we use the @(racket number?)-function to match numbers. +} + +@section{@(racket if)} + +@para{ + And we want some kind of if-then-else. + In @(racket eval-exp) we add a clause: +} +@(racketblock [(list 'if x then else) #,(emph "your code here")]) +@para{ + If it matches, we will evaluate the @(racket x)-expression, + then choose @(racket then)-expression or @(racket else)-expression depending on the value we got, + and then evaluate the expression we chose. +} + +@section{Some functions} + +@para{ + And also we probably want some functions, like @(racket =) and @(racket <) and so on. + Since our numbers are Racket-numbers and our booleans are Racket-booleans we can add them the same way we have added the other ``primitives,'' + like @(racket +) and @(racket -) and such. +} +@para{ + We will add at least @(racket =), @(racket <), @(racket <=), @(racket >) and @(racket >=). + We can add more later if we need more... +} + +@section{Maybe: @(racket and), @(racket or), ...} + +@para{ + We can totally skip this part. It isn't necessary for any of the stuff we will do later. But it's maybe like nice or something. +} + +@para{ + We can implement stuff like @(racket and) by matching on it in @(racket eval-exp) and then kind of rewriting to an @(racket if)-expression and evaluating that rewritten expression instead: +} + +@(racketblock [(list 'and a b) + (define rewritten-exp (list 'if #,(emph "your code here"))) + #,(emph "your code also here")]) + +@section[#:tag "bool-done"]{Done?} + +@outro-test-para +@outro-para["Ambiguousness" "6-booleans.rkt"] + diff --git a/scrbl/cps-refactor.scrbl b/scrbl/cps-refactor.scrbl new file mode 100644 index 0000000..f59d35b --- /dev/null +++ b/scrbl/cps-refactor.scrbl @@ -0,0 +1,168 @@ +#lang scribble/manual + +@(require "util.rkt") + +@title{Refactoring to CPS} + +@intro-para["4-functions.rkt"] + +@para{ + CPS, besides being weird, is kind of neat. + If you're implementing a function, + and the ``continuation'' ---everything that is to happen after--- is made available to you as a function, + then, uh, that's a thing you're in control of. +} +@para{ + You can decide not to invoke the continuation. + Or you can try to invoke the continuation several times, with different values. + Later on we want to use an @(racket amb)-form for expressions that can have multiple possible values: + We want to ``continue'' with some value, and if that turns out to be no good, we want to try some other value instead. + CPS seems like a good fit. +} + +@section{Some stuff will have a @(racket continue)-parameter} + +@para{ + We will rewrite a few functions so they have a @(racket continue)-parameter, + and so that, instead of returning a result, they apply @(racket continue) to a result. + We will put @(racket continue) just after @(racket env) in the parameter lists. + E.g. @(racket eval-application) will go like @(racket (eval-application env continue fun args)). +} + +@subsection{@(racket (eval-exp env continue exp))} + +@para{ + @(racket eval-exp) isn't too bad. In most of the @(racket match)-clauses we return a value pretty directly. + In those cases we will pass the values along to @(racket continue) instead. + In the case where we call @(racket eval-application), we will pass our @(racket continue) along to @(racket eval-application) and put it in front of the other arguments... +} + +@subsection{@(racket (eval-sequence env continue exps))} + +@para{ + The cases where we have some @(racket rest)-expressions are a little trickier. + In, say, the @(racket 'define)-case, we must make a continuation-function to use with @(racket eval-exp). Like: +} + +@(racketblock + (eval-exp env + (λ (value) + #,(emph "your code here")) + exp)) + +@para{ + Within this continuation-function, we will do the stuff we previously did @emph{after} the call to @(racket eval-exp): + Extend the environment and call @(racket eval-sequence) again. We will pass our ``original'' @(racket continue) to @(racket eval-sequence). +} + +@subsection{@(racket (eval-application env continue fun args))} + +@para{ + Maybe the trickiest. We must evaluate the @(racket fun)-expression with @(racket eval-exp), with a continuation that deals with the arguments. + For every argument in the list, there will be a call to @(racket eval-exp) with a continuation that deals with + the rest of the arguments and performing the function application. Along the way we must keep track of the arguments we have evaluated. + Finally, the function we are going to apply will take a @(racket continue)-argument before the evaluated @(racket args): + We will pass our @(racket continue)-parameter along to it. +} +@para{ + It is likely that evaluating the arguments is the hardest bit. We probably want this: +} +@(racketblock + (define (eval-arguments env continue args) + (match args + ['() #,(emph "your code here")] + [(list arg rest ...) #,(emph "your code here")]))) +@para{ + In @(racket '())-case: Evaluating all the arguments in the empty list is maybe not @emph{too} hard? +} +@para{ + In the @(racket (list arg rest ...))-case: + We want to @(racket eval-exp) the @(racket arg), + then @(racket eval-arguments) the @(racket rest) of the arguments, + and then @(racket cons) the evaluated argument onto the evaluated rest-of-the-arguments. + Like, we're really ``just'' trying to map @(racket eval-exp) over @(racket args). Having to work out what needs to go in which continuation makes things more confusing though. +} + +@subsection{Our ``primitives''} + +@para{ + Instead of e.g. the @(racket +)-function we want a function that has a @(racket continue)-argument first: +} + +@(racketblock + (define (my-plus continue . args) + #,(emph "your code here"))) + +@para{ + When this function is applied, all the arguments after the @(racket continue) are collected in @(racket args), as a list. + We can use the @(racket apply)-function to apply the original @(racket +)-function to the @(racket args). + (And we want to apply @(racket continue) to the result rather than just returning it.) +} + +@para{ + It is pretty possible, while not exactly necessary, to make a helper-function for this. + One that takes a regular function as its argument and returns a more CPS-compliant function. + Something along the lines of +} +@(racketblock + (define (primitive function) + (λ (continue . args) + #,(emph "your code here")))) + +@para{ + could be convenient. +} + + +@subsection{@(racket (make-function env parameters body))} + +@para{ + We're not adding a @(racket continue)-parameter to @(racket make-function) function, + but we need to add it to the function returned by @(racket make-function). + That @(racket continue) should be passed in as the second argument to @(racket eval-sequence). +} + +@subsection{@(racket (evaluate input))} + +@para{ + For now, we want @(racket evaluate) to work the same way as before, so we are not adding a @(racket continue)-parameter to it. + But it does use @(racket eval-exp) so we need to add a @(racket continue)-argument there. + We will use Racket's @(racket identity)-function. +} + +@section{So that did nothing} + +@para{ + So, if we got things right then we have kind of made no changes. + Under the hood things work differently, + but there are no new features and all the expressions in the language we're making should @(racket evaluate) to the same values. +} + +@para{ + How dull? On the plus side we didn't have to write any new tests... +} + +@section{Couple of tips, maybe} + +@para{ + Okay so this stuff is like not straightforward. + Because CPS. + Also because we have to change a bunch of of interdependent functions: We change one and everything breaks. + So. Two tips: +} +@para{ + One tip: + Use Racket's @(racket identity)-function for stuff. + If you pass @(racket identity) in as the @(racket continue)-argument to a function, then @(racket identity) should just return the result we're intersted in. +} +@para{ + Another tip: + Maybe change @(racket eval-exp) so that it handles the simplest expression, the literals, correctly first, and let everything else break. + Then, when rewriting each ``feature'' to CPS, we can test them with expressions where all the subexpressions are just literals. + E.g. when working on @(racket eval-arguments), just use a list of numbers for the @(racket args) to begin with. +} + +@section[#:tag "cps-done"]{Done?} + +@outro-test-para +@outro-para["Booleans" "5-continuation-passing-style.rkt"] diff --git a/scrbl/cps.scrbl b/scrbl/cps.scrbl new file mode 100644 index 0000000..ed7b9f0 --- /dev/null +++ b/scrbl/cps.scrbl @@ -0,0 +1,66 @@ +#lang scribble/manual + +@title{Continuation-passing style} + +@para{ + (Not really working with in this part. Can play with stuff in the Racket REPL.) +} + +@para{ + Say we want a function that adds two to its argument. +} + +@section{Not CPS} + +@para{ + A reasonably normal way to go about things could be: +} +@(racketblock + (define (add2 x) + (+ x 2))) +@para{ + If we wanna appply it to the number three and display the result, then we can apply it to @(racket 3) and @(racket display): +} +@(racketblock + (display (add2 3))) +@para{ + Chances are the number @(racket 5) will be displayed. +} + +@section{CPS} + +@para{ + A less normal way to go about things could be: + Instead of @(racket add2)-function taking just one argument, + it could take two arguments and the second argument could be a ``continuation''-argument. + And instead @(racket add2) returning the result of the addition, + it could apply its ``continuation'' to the result. +} +@(racketblock + (define (add2 x continue) + (continue (+ x 2)))) +@para{ + Now, if we wanna display the result, we do not apply @(racket display) to the result. + Instead we pass in @(racket display) as @(racket add2)'s @(racket continue)-argument. +} +@(racketblock + (add2 3 display)) +@para{ + If we don't exactly have exactly the exact functions we want at hand, we can make them with lambdas. +} + +@(racketblock + (add2 3 + (λ (result) + (add2 result + (λ (final-result) + (printf "it's ~a" final-result)))))) + +@para{ + So that's weird. + Anyway we're passing continuations. That style of programming is called continuation-passing style (CPS). +} + +@para{ + Next is @secref{Refactoring_to_CPS}. +} \ No newline at end of file diff --git a/scrbl/definitions.scrbl b/scrbl/definitions.scrbl new file mode 100644 index 0000000..ec77650 --- /dev/null +++ b/scrbl/definitions.scrbl @@ -0,0 +1,154 @@ +#lang scribble/manual + +@(require "util.rkt") + +@title{Definitions} + +@intro-para["2-lookup-in-environment.rkt"] + +@para{ + Passing an unchanging environment around is @emph{pretty cool}. + Maybe it would also be cool if the environment could also be extended with more stuff. + Will try to. +} + +@para{ + We will use ``definitions'' to bind a names to a values, so that they can be referred to by their names. + When we encounter a definition we will extend the environment with a new binding. +} + +@section[#:tag "def-tests"]{Some tests} + +@(racketblock + (check-equal? + (extend-environment (list (cons 'd 2) (cons 'e 1)) + (list 'a 'b 'c) + (list 5 4 3)) + (list (cons 'a 5) (cons 'b 4) (cons 'c 3) (cons 'd 2) (cons 'e 1)))) + +@(racketblock + (check-equal? + (evaluate + '(begin + (define a 2) + (define b 3) + (+ a b))) + 5)) + +@(racketblock + (check-equal? + (evaluate + '(begin + (define a 2) + (define a 3) + (+ a a))) + 6)) + + +@section{@(racket define) in Racket} + +@para{ + Our defintions are going to work rather like the regular Racket ones. + Try out the following lines of code in the REPL: +} + +@(racketblock (define a 2)) + +@(racketblock a) + +@(racketblock (define b +)) + +@(racketblock (b a 3)) + +@(racketblock + (begin + (define a 3) + (+ a 3))) + +@section{@(racket extend-environment)} + +@para{ + We would like a helper-function for extending an environment with new bindings. + We want to use this for definitions, and also for adding arguments to the environment when functions are called. + Functions can have multiple parameters, so we will make @(racket extend-environment) take a list of @(racket names) + and a list of @(racket values), in addition to the @(racket env)ironment it should extend: +} + +@(racketblock + (define (extend-environment env names values) + #,(emph "your code here"))) + +@para{ + The function should return a new list where the new pairs of name and value are appended to @(racket env). + The Racket function @(racket append) will be useful. + Also useful: Racket's @(racket map)-function can take multiple lists of same length as arguments. Like: +} +@(racketblock + (map cons (list 'a 'b 'c) (list 1 2 3))) + +@para{ + When done, the test that uses @(racket extend-environment) should pass. +} + +@section{@(racket eval-sequence) and @(racket define)} + +@para{ + Definitions are not ``expressions'' in our language: We do not evluate a definition in order to get some value. It only extends the environment. + That kind of means that evaluating a program that is only a definition is not an incredibly meaningful thing to do. + Like, we, uh, we want results. +} +@para{ + So, we're going to add support for evaluating multiple terms, on after another. + Typically one or more definitions and then an expression at the end. +} + +@para{We make function:} + +@(racketblock + (define (eval-sequence env exps) + (match exps + [(list x) #,(emph "your code here")] + + [(list ('define name exp) rest ...) #,(emph "your code here")] + + [(list x rest ...) #,(emph "your code here")]))) + +@para{ + In the @emph{first} match-clause: + The list only consist of only one element. + The one element in a one-element list is its final element. + The final term in a sequence is the expression we want to evaluate in order to get its result value. + We can use @(racket eval-exp). +} + +@para{ + In the @emph{last} match-clause: + Since the middle clause did not match, @(racket x) is not a @(racket define)-form. + We will evaluate it with @(racket eval-exp), throw away its result, and use @(racket eval-sequence) on the @(racket rest) of the terms. + (Yea so throwing away the results seems possibly wasteful. Maybe side effects though?) +} + +@para{ + In the @emph{last} match-clause: + A @(racket define)-form. This is more trickier. + First we should evaluate the @(racket exp)ression part of the defintion, + and create a new environment with @(racket extend-environment). + Then we can call @(racket eval-sequence) on the @(racket rest) of the list and the new environment. +} + +@section{@(racket begin)} + +@para{ + We use @(racket begin)-forms to create expressions out of lists of terms. + We add a new match-clause in @(racket eval-exp):} + +@(racketblock [(list 'begin terms ...) #,(emph "your code here")]) + +@para{ + And we will use @(racket eval-sequence) to deal with the @(racket terms). +} + +@section[#:tag "def-done"]{Done?} + +@outro-test-para +@outro-para["Functions" "3-definitions.rkt"] diff --git a/scrbl/fix-calc.scrbl b/scrbl/fix-calc.scrbl new file mode 100644 index 0000000..d1e43b4 --- /dev/null +++ b/scrbl/fix-calc.scrbl @@ -0,0 +1,221 @@ +#lang scribble/manual + +@(require "util.rkt") + +@(require (only-in images/icons/control play-icon) + (only-in images/icons/misc stop-sign-icon) + (only-in images/icons/style run-icon-color)) + +@title{Fixing the calculator} + +@para{ + Should open the @tt{0-start-calculator.rkt}-file in DrRacket. +} + +@section{Working with a file in DrRacket} + +@para{ + Click the @(play-icon #:color run-icon-color)-button, or press @tt{F5}. + DrRacket runs the file and the window kind of splits in two. +} + +@(itemlist + @item{ + The bit above is the Definitions bit. + The contents of the file goes in Definitions; if we save the file it's the stuff in Definitions that will be saved. +} + @item{ + The bit below is the Interactions bit. + This is like a REPL. We can write Racket expressions here and have them evaluated. + The Definitions are made available for Interactions whenever we Run the file. + }) + +@para{ + There's a failing test. We'll get back to that. +} + +@para{ + For now, try to run some expressions in Interactions. Maybe some of these: +} + +@(racketblock + (+ 2 3) + ) + +@(racketblock + (evaluate '(+ 2 3)) + ) + +@(racketblock + (repl) + ) + +@section{The calculator-code} + +@para{ + There's some stuff going on... +} + +@(racketblock + (define (eval-exp exp) + (match exp + [(? number?) exp] + + [(list '+ args ...) (apply + (map eval-exp args))] + + [(list '- args ...) (apply - (map eval-exp args))] + + [(list '* args ...) (apply * (map eval-exp args))] + + [(list '/ args ...) (apply * (map eval-exp args))] + + [_ (error 'wat (~a exp))]))) + +@(racketblock + (define (evaluate input) + (eval-exp input))) + +@(racketblock + (define (repl) + (printf "> ") + (define input (read)) + (unless (eof-object? input) + (define output (evaluate input)) + (printf "~a~n" output) + (repl)))) + +@subsection{@(racket define)} + +@para{ + The first @hyperlink["https://docs.racket-lang.org/reference/define.html"]{@(racket define)}-form defines a function called @(racket eval-exp) that takes one argument, @(racket exp). + For now, the @(racket eval-exp)-function is the most important piece of code. It is for evaluating and expression and returning the result. +} + +@subsection{@(racket read) and quotes} + +@para{ + The following is a regular Racket-expresssion: +} + +@(racketblock (+ 1 2)) + +@para{ + It is the application of the function @(racket +) to the arguments @(racket 1) and @(racket 2). +} +@para{ + We can @hyperlink["https://docs.racket-lang.org/reference/quote.html"]{``quote''} a term: +} +@(racketblock '(+ 1 2)) +@para{ + This is not a function application. It evaluates to a list with three elements: + The symbol @(racket '+), the number @(racket 1), and the number @(racket 2). + We can ``quote'' a term in order to get the syntax of the term as a data object. +} + +@para{Try out the following expressions in the REPL, and notice the differences.} + +@(racket + (+ 1 2)) + +@(racket + '(+ 1 2)) + +@(racket + (list + 1 2)) + +@(racket + (list '+ 1 2)) + +@para{If you would like to check if two values are equal to each other, the function @(racket equal?) is handy.} + +@para{ + The programs we will evaluate with our evaluator are data objects like the ones we get by quoting Racket terms. + So we can write terms that are like regular Racket terms, quote them and pass them to our evaluator: +} +@(racketblock (evaluate '(+ 1 2))) + +@(racket + (equal? '(+ 1 2) (list '+ 1 2))) + +@para{ + The @(racket repl)-function is a Read-Eval-Print-Loop. + It uses the @(racket read)-function to read a Racket term. + @(racket read) reads a Racket term and returns a data object, same as we would get if that term was quoted in a regular Racket program. + @(racket repl) then @(racket evaluate)s, @(racket printf)s the result, and, by calling itself recursively, loops. +} + +@para{ + So we can use the @(racket repl)-function to get a repl for the language we are making. + Nice to have, can be fun to play around with. + (But we will usually call @(racket evaluate) directly, with quoted Racket terms, when testing the evaluator during the workshop.) +} + +@subsection{@(racket match)} + +@para{ + Inside the @(racket eval-exp)-function there is a @hyperlink["https://docs.racket-lang.org/reference/match.html"]{@(racket match)}-form. + @(racket match) is used for pattern matching. + It matches @(racket exp) against a series of patterns, and evaluates some ``body''-code for the first pattern that matches. + Each ``clause'' consists of a pattern and some ``body''-code. So: +} +@(itemlist + @item{ + The pattern @(racket (? number?)) matches if @(racket exp) is a number (if the @(racket number?)-function returns true when applied to @(racket exp). + If it matches, @(racket eval-exp) will return (the number) @(racket exp). +} + @item{ + The pattern @(racket (list '+ args ...)) matches if @(racket exp) is a list where the first element is the symbol @(racket '+). + If it matches, @(racket (apply + (map eval-exp args))), with @(racket args) bound to the rest of the @(racket exp)-list, will be evaluated. + @(racket eval-exp) will return result. +} + @item{ + The pattern @(racket (list '- args ...)) matches if the @(racket exp) is a list where the first element is the symbol @(racket '-). + If it matches, @(racket (apply - (map eval-exp args))), with @(racket args) bound to the rest of the @(racket exp)-list, will be evaluated. + @(racket eval-exp) will return result. +} + @item{ + And so on. +} + @item{ + @(racket _) matches whatever. If none of the patterns above match, this one will, and we will throw an error. + }) + +@subsection{@(racket apply)} + +@para{ + In most of the pattern matching clauses, we use the @hyperlink["https://docs.racket-lang.org/reference/procedures.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._apply%29%29"]{@(racket apply)}-function. + @(racket apply) is a function application function. + If a function takes several arguments, and we have the arguments we want to apply it to in a list, we can use @(racket apply). +} + +@para{ + Like, normally we apply the @(racket +)-function like so: +} +@(racketblock (+ 1 2 3)) +@para{ + If we have a list @(racket lst) with numbers: +} +@(racketblock (define lst (list 1 2 3))) +@para{ + Then we cannot apply @(racket +) directly to the @(racket lst)-list. + @(racket +) can be applied to severl number-arguments, not one list-with-several-numbers-argument. + But we can use @(racket apply): +} +@(racketblock (apply + lst)) + +@section{Making the test pass} + +@para{ + Lets's make the failing test pass: +} + +@(itemlist + @item{Quickest way to get back to the failure is to run (@tt{F5}) the file again.} + @item{DrRacket should highlight the failing test in the definitions window, or we can click on the @(stop-sign-icon) in the REPL to highlight it again.} + @item{We can stare at the failing test and at the @(racket eval-exp)-code for a little while.} + @item{And then fix.}) + +@section[#:tag "fix-calc"]{Done?} + +@outro-para["Lookup_in_the_environment" "1-fixed-calculator.rkt"] + diff --git a/scrbl/functions.scrbl b/scrbl/functions.scrbl new file mode 100644 index 0000000..0f82452 --- /dev/null +++ b/scrbl/functions.scrbl @@ -0,0 +1,95 @@ +#lang scribble/manual + +@(require "util.rkt") + +@title{Functions} + +@intro-para["3-definitions.rkt"] + +@para{ + Functions are good for parameterizing pieces of code. +} + +@para{ + A function in our language wil be built from a list of parameter names and a list of terms for the function body. + When called, the function should extend its environment with its parameters bound to the arguments supplied by the caller, + and then evaluate the body. +} + +@section[#:tag "fun-tests"]{Some tests} + +@(racketblock + (check-equal? + (evaluate '((λ () (+ 2 3)))) + 5)) + + +@(racketblock + (check-equal? + (evaluate '((lambda (x y) (+ x y)) 3 4)) + 7)) + + +@(racketblock + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b 3) + (+ a b)))) + 5)) + +@(racketblock + (check-equal? + (evaluate + '((lambda () + (define a 2) + (define b (lambda (c) (define a 5) (+ a c))) + (b a)))) + 7)) + + +@section{Make a function} + +@para{ + When @(racket eval-exp) encounters a ``lambda'' we want to make a real Racket function. +} + +@para{ + We make @(racket make-function) function: +} + +@(racketblock + (define (make-function env parameters body) + (λ arguments + #,(emph "your code here")))) + +@(itemlist + @item{@(racket env) is the environment the function @emph{was defined in.}} + @item{@(racket parameters) is a list of parameter names (symbols).} + @item{@(racket body) is a list of terms. Maybe an expression. Maybe some @(racket define)s and then an expression.}) + +@para{ + @(racket make-function) returns a Racket-function (made with the @(racket λ)). + That function should extend the environment it was defined in with each parameter name bound to the corresponding argument-value, + and then @(racket eval-sequence) its @(racket body). +} + + +@section{New match clauses in @(racket eval-exp)} + +@(racketblock + [(list 'λ parameters body ...) #,(emph "your code here")]) + +@para{ + When the @(racket 'λ) matches we want to make a function with @(racket make-function). +} + +@para{ + Also, we will add a very similar match-clause, for when people use @(racket lambda) instead of @(racket λ). +} + +@section[#:tag "func-done"]{Done?} + +@outro-test-para +@outro-para["Continuation-passing_style" "4-functions.rkt"] diff --git a/scrbl/images/cars.png b/scrbl/images/cars.png new file mode 100644 index 0000000000000000000000000000000000000000..85e911f07a69453941a2412c6de273436353e3bc GIT binary patch literal 21139 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 a{@ATE%5Qw4ZUPUIWbkzLb6Mw<&;$U;f0D-l literal 0 HcmV?d00001 diff --git a/scrbl/images/circles.png b/scrbl/images/circles.png new file mode 100644 index 0000000000000000000000000000000000000000..59bcf8bef14216eaff07fdc5ec983aad9ec99c72 GIT binary patch literal 22888 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 E0#O;^`v3p{ literal 0 HcmV?d00001 diff --git a/scrbl/images/sudoku.png b/scrbl/images/sudoku.png new file mode 100644 index 0000000000000000000000000000000000000000..8f77a8f070ab21ca9c052bf0dd4a38c0e033bd02 GIT binary patch literal 3211 zcmd6qdpOg5AIHZKX~eptIjqozYveGN(wvqN8I_RO$S4%<p`5~G6Omh+Q%;$Cbjr%y080r{`mgB*Y|tmk39Zq^R(E;8t#=a1uFx1ZxQ>Y*(HXF2wvS4qFIsqDz1E5*Mze zf^FQ+0{}9NZ$pF`l`CW=?tWUBpkRPkSG89GODZ9)>aRq=Rf zJ4i#Xbz{wp4Wo@@6=8>b=;_OoY3j73QiYZ)3U0ot#~YeaPDrGqA60<3d|ed*PNjhe zRt%e5dC~0%@Rq>Sic-#&4OAkP0s^UL9+Gq|w%04p^wKycB_f?FC1H$Ax~RR2&}h)u zaOqNt<8Cp8D@?J!Q&0Z!MY1?c45$RLw!FEum~e;ir-DWr#6?HWzhykS=hy3RW};e) z@5D!leiv$5mGsX@JNZ=Z66i!--}#kj=!R+pbQfr7Ve!ef-_w%D@%1G4q>ix1W~la- z-D@{ifj=HSO$d2whHjn1uCDE`CjRO~RAVJ7RgVcaGMhnPN9vgrsh7;f9I6jZzHqM;M^ z7K!q`eq7QL%JFK)T+E)h{?=PXxc(5eUy6liGY8I1IjE4w-!|rl_JQZRwCcLqRpnDO zO@dV|Jww8m5r15TdSM`El)TvZqfnV3#5ue|9dltd>-A+b6_4kjNZ_lDHa4wxc9MzS zQvYzje`ca!y!Cyl?3SzGu(W=_-|VxW>HbIasu$CX=3Xw$*7JP}*zH~QOjrCToTyx_ zrBMx^jTI$ucn@gJ)BLQySiq*&*hrq+2tv77?hV$2B&d{ONW5k?H^t4JoY(V>hj%xm z`f^7zJjJUV=4R&d)(?4Y3KW~ykG7R%eL3@NV9DKN_22G(57){T+uyW$y(*l<#-DwK zF+mrIhw47jnJ>Hbw3xU~oY-!@j^3Vq!<6ZkZMbBED(JOc-cyMPxc zUidOl0QNKzoH5UgFpwPDd9U?gccT8|TDK$_6wb>%`anrLw!Mj?861GSj&8e`<(UL6 z_fFErwV{~KYF}1e{CYad?e}W2dOWAO9(npFJ7u_)J$20w zEyI&&J45pE$Jk$2J^kOO0KXGS-!`;&C=`m zJFX8fqNrAh1$`*m11*)b`68o6gw?bUy27qAeSen7>Vsphg1>5P4UMI3zNp@)SH3*t z21qq1tXX5ZJnPcf=qlNHb; zUp0A$V$8nOxWZmY@i-MTV_rG2cw}_vXOAsGK>Pzq7RDcmJ?@`{szfSPK@6>Hq9@>q7iCN0&-P55G=@YO$O@16QXa;Qw zv8fXqW}}9!mZx@{O)9a+$ak90?&g2KTB2&4`rHl1 zhqD5z-{|>}V_Ao3f=9f7o44K+OO`%6Ub z9`y{$2cg8GEvK40X)7rDu$(l8Myz5;?09&X2JG)R#Ifi&7Mh(l4u_O38v z@;~un{#jf9zd&sP4JV!OisG!k52sX0x+c7A;)X?Z1(=b^TdU2w09F4#ysxh z7PJH`g15bld^Q_Xu|g1IH4ShEJopu|-x!_XQnEea8r>kI!P*=;R+F_4Gb{JTfTNk2 z^#jjcm8xxnPo8}wFEDzb{ru0_X}!1$0}9}k0v&L`tHRk6*8Np!+Cc*N)?MioXQ0wB z2?6GBTJoHF1hLjDzNQOK>HB&tvQ(h$)PFfkhXUfE5nwy?d`)!Z^TD>%BAksfeCe2s z8jwRy7E^yWa2{*I!72DF1cf+PMZC|MqTQ!<PpP9Xe&0N5UMz!X{%sDA+7?ua1( literal 0 HcmV?d00001 diff --git a/scrbl/lookup.scrbl b/scrbl/lookup.scrbl new file mode 100644 index 0000000..739dc46 --- /dev/null +++ b/scrbl/lookup.scrbl @@ -0,0 +1,180 @@ +#lang scribble/manual + +@(require "util.rkt") + +@title{Lookup in the environment} + +@intro-para["1-fixed-calculator.rkt"] + +@para{ + We see that most of the match-clauses in @(racket eval-exp) look quite similar. + We will do some steps of refactoring in order to not repeat ourselves, and also to be prepared for things to come. + Later the users of the program will be able to define their own variables with names they choose themselves, + so we do not want to continue to match on the names (@(racket '+), @(racket '-) and so on) as we currently do in @(racket eval-exp). + Instead we will look up the values of variables in some lookup-table that can be extended dynamically. +} + +@section[#:tag "lookup-tests"]{Some tests} + +@(racketblock + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'a) + 1)) + +@(racketblock + (check-equal? + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'b) + 2)) + +@(racketblock + (check-equal? + (lookup (list (cons 'a 0) + (cons 'a 1) + (cons 'b 2)) + 'a) + 0)) + +@(racketblock + (check-exn + exn:fail? + (λ () + (lookup (list (cons 'a 1) + (cons 'b 2)) + 'c)))) + + +@section{@(racket primitives)} + +@para{ + A name (a symbol) together with a value (e.g. the number 2, or a function) is a binding. + We will put bindings in a list. + When the evaluator encounters a name it will look it up in this list so that it can return the value bound by that name. +} + +@para{ + We will start off by making a list called @(racket primitives) containing our four primitive operators, + and look up in this list every time the function @(racket eval-exp) sees a symbol. + We will use @(racket list) to construct the list of bindings. + Each binding will be a pair, constructed with @(racket cons). +} +@(racketblock + (define primitives + (list (cons '+ +) + #,(emph "more bindings")))) + + +@section{@(racket lookup)} + +@para{ + We will implement this as a recursive function. + If the first binding in the list is equal to the symbol we are looking for then we return the corresponding value, + otherwise we call lookup on what remains of the list. + If the list is empty it doesn't have the binding we're looking for, and we will raise an exception. +} + +@para{ + We will make the @(racket lookup)-function: +} +@(racketblock + (define (lookup env s) + (match env + #,(emph "your code here")))) + +@para{ + It should have a couple of match-clauses: +} + +@para{ + One should match the empty list (e.g. @(racket (list)) or @(racket '())), and throw an exception. + We can use Racket's @(racket error)-function to raise an exception + (see the function @(racket eval-exp) for an example of use of @(racket error)). +} +@para{ + The more difficult part is to match a list with a binding (a @(racket cons)-pair) as its first element. + We can use a clause like: +} +@(racketblock [(list (cons name val) rest ...) #,(emph "your code here")]) +@para{ + If this matches it will pick out the parts we need: + @(racket name) will be bound to a variable name and @(racket val) to its value, + and @(racket rest) will be bound to the rest of the list. + We then want to check @(racket if) @(racket name) is @(racket equal?) to @(racket s), + and return @(racket val) if it is, + or else call lookup on @(racket s) and the @(racket rest) of the list. +} + +@para{ + The tests we added should pass when we're done. +} + +@section{Environment as input to @(racket eval-exp)} + +@para{ + We will pass @(racket primitives) as an argument to @(racket eval-exp), and make @(racket eval-exp) use it to look up values. + So, in the definition of @(racket eval-exp), instead of +} + +@(racketblock (eval-exp exp)) + +@para{ + we will have have +} + +@(racketblock (eval-exp env exp)) + +@para{ + @(racket env) will be the list of bindings we will use for looking up stuff. +} + +@para{ + We should modify the @(racket evaluate)-function so that it passes @(racket primitives) along to @(racket eval-exp). +} + +@subsection{Looking up} + +@para{ + Now that @(racket eval-exp) has an @(racket env)ironment we can use it for when there are symbols: +} +@(racketblock [(? symbol?) #,(emph "your code here")]) + +@para{ + When this matches we want to apply our @(racket lookup)-function to @(racket env) and @(racket exp). +} + +@subsection{@(racket eval-application)} + +@para{ + Now, instead of having different match-clauses for @(racket '+) and @(racket '-) and so on, + we can have one clause for function application: +} + +@(racketblock [(list fun args ...) (eval-application env fun args)]) + +@para{ + We should be able to evaluate the @(racket fun)-expression to get the correct function. + We're using a helper function: +} + +@(racketblock + (define (eval-application env fun args) + #,(emph "your code here"))) + +@para{ + It should evaluate the @(racket fun)-expression and all the expressions in the @(racket args) list, + and @(racket apply) the evaluated @(racket fun) to the evaluated @(racket args). +} + +@para{ + Should be pretty similar to what we used to do when we matched e.g. @(racket '+), + only we don't use a hardcoded function (like @(racket +)), + and we need to pass the @(racket env)ironment along whenever we call @(racket eval-exp). +} + +@section[#:tag "lookup-done"]{Done?} + +@outro-test-para +@outro-para["Definitions" "2-lookup-in-environment.rkt"] diff --git a/scrbl/meta-eval.scrbl b/scrbl/meta-eval.scrbl new file mode 100644 index 0000000..5ba1501 --- /dev/null +++ b/scrbl/meta-eval.scrbl @@ -0,0 +1,84 @@ +#lang scribble/manual + +@title{Meta-circular what?} + +@para{ + The idea for this workshop comes from the classic book + @hyperlink["https://mitpress.mit.edu/sites/default/files/sicp/index.html"]{Structure and Interpretation of Computer Programs} (SICP). + It is a good book, you should read it! +} + +@section{Programming languages and evaluators} + +@para{A programming language is a language with a certain syntax and given rules, + that makes you able to write programs that hopefully do what you expect them do do.} + +@para{ + There are different strategies for how an implementation of a programming language executes programs. One approach is to make an evaluator. + An @emph{evaluator} (or interpreter) for a language is a program that rather directly executes expressions written in that language. + In order to execute the program, the evaluator needs to parse the expressions to something meaningful for the evaluator, and then evalute the expressions. +} + +@para{ + When making a new language we can implemented an evaluator in more or less any kind of language, + but we will typically have to spend quite some time working on lexing and parsing before we have something meaningful or fun. + We will use a subset of Racket's syntax for our language, and we will implement the evaluator in Racket. + Reusing bits of our ``host language'' like that is what we do when we're making @emph{meta-circular evaluator}. +} + +@para{ + But wait, why would we write (something very similar to) Racket in Racket when we already have a Racket? + Well: +} +@(itemlist + @item{Is fun.} + @item{ + It can be easier to modify and experiment with a tiny language we have made ourselves. + Easier to do things like, changing the evaluation order of things so that it's more lazier, + or, as we will do in this workshop, add support for ``nondeterministic'' computaion. +} + ) + +@section{@(racket amb) and logic programming} + +@para{ + The way we will make Racket nondeterministic is by extending it with the form @(racket amb), which takes multiple expressions and returns one of them, + and with @(racket require), which will allow us to specify constraints that must be satisfied. + With those extensions we can write programs where the evaluator must search for solutions by choosing different values for the different @(racket amb)-expressions. +} + +@para{ + This is a step towards logic programming where a problem is defined in terms of facts or rules, that might result in more than one answer. + Unknown values are represented by variables, + and @hyperlink["https://en.wikipedia.org/wiki/Unification_(computer_science)"]{unification} is used for solving the "equations" and determine the valid values. +} + +@section{Outline} + +@para{ + What we will do in this workshop is to start with a simple calculator evaluator, which allows us to calculate the value of expressions with the four basic operators +, -, * and /. + And then gradually, through several steps, extend it until we have our notdeterministic evaluator @(racket amb). +} + +@para{ + We will go through the steps of implementing + @secref{Lookup_in_the_environment}, @secref{Definitions}, @secref{Functions}, @secref{Booleans}, @secref{Continuation-passing_style} and @secref{Ambiguousness}, + before we move @secref{Towards_zebras}, our ultimate goal. + It is possible to skip familiar steps: Every step has a corresponding Racket file that can be used as a starting point. +} + +@section{Goals for the workshop} + +@para{Our goals for this workshop is that you hopefully learn something new about} + +@itemlist[#:style 'compact + @item{The Racket programming language} + @item{How evaluators work} + @item{Continuation-passing style} + @item{Logic programming}] +@para{but most of all, we hope you will } +@itemlist[#:style 'compact + @item{Get inspiration and new ideas} + @item{Have fun!} + ] + diff --git a/scrbl/puzzles.scrbl b/scrbl/puzzles.scrbl new file mode 100644 index 0000000..d6bc35f --- /dev/null +++ b/scrbl/puzzles.scrbl @@ -0,0 +1,45 @@ +#lang scribble/manual +@(require scriblib/figure + "util.rkt") + +@title{It's puzzle time} + +@intro-para["7-amb.rkt"] + +@para{Now that we have our great evaluator with @(racket amb) and @(racket require), let us see what it can do! } + +@section{Find the missing number} + +@centered{@image[#:scale 0.5 "scrbl/images/cars.png"]} + +@para{Do you ever see pictures like this one in your social media feeds? Well, now you have a language to solve them for you.} + +@para{Write a program in our new language that solves this puzzle by the use @(racket amb) to define possible values 1 - 9 for the car colors, and @(racket require) to define the restrictions.} + +@para{What happens if you allow the green car to also have the value -2?} + +@section{Find the digits} + +@centered{@image[#:scale 0.7 "scrbl/images/circles.png"]} + +@para{Find the digits symbolized by the blue, red and white circles that fits into the calculation.} + +@section{Sudoku} + +@centered{@image[#:scale 1.0 "scrbl/images/sudoku.png"]} + +@para{Our evaluator can also solve sudokus!} + +@para{The easiest way is to require that the sums vertically, horizontally and inside each square are equal to 10. + But then we might get more than one solution and manually select the one that follows the rules, + because we have not incorporated the rule that the digits in same row, column or square should be distinct.} + +@para{If we want to do it properly our program has to define a function that takes a list and decides if the elements in the list are unique. +One way to do that would be to loop through the list and check if the first element is contained in the rest of the list, if it is, the elements are not unique, +otherwise call the function with the rest of the list. (This function will also be useful for solving the Zebra puzzle).} + +@para{The sudoku in the picture is from @hyperlink["http://www.minisudoku.com/"]{minisudoku.com}. There are more sudokus there, and you can check your solution.} + +@section[#:tag "puzzles-done"]{Done?} + +@para{@secref{Towards_zebras}, then.} \ No newline at end of file diff --git a/scrbl/racket.scrbl b/scrbl/racket.scrbl new file mode 100644 index 0000000..5d60804 --- /dev/null +++ b/scrbl/racket.scrbl @@ -0,0 +1,84 @@ +#lang scribble/manual + +@title{Some Racket} + +@para{ + We'll mostly introduce things when we're going to use them, but we'll mention a few things here... +} +@para{ + We are going to implement an evaluator for a language. + We will write the evaluator in Racket. Racket is pretty lispy and schemey. + The language we will make evaluator for will also be pretty lispy and schemey. + On the whole: Lispy and schemey. +} + +@section{Maybe use DrRacket} + +@para{ + The Racket installation comes with DrRacket, which you can use for writing and running programs and so on. + It's pretty nice. +} +@para{ + Some things: +} +@(itemlist + @item{@tt{Ctrl+L} inserts a λ-character} + @item{@tt{F1} searches for the name of the identifier your cursor is on in the Racket documentation.} + @item{@tt{F2} makes a blue box appear! (or disappear)}) + +@section{@(racket (function argument ...))} + +@para{ + There will be stuff like: +} +@(racketblock (+ 1 2)) +@(racketblock (string-append "zeb" "ra")) +@(racketblock ((λ (n) (+ n 1)) x)) + +@para{ + These are function application-forms. + Each form is a pair of parentheses with some elements between them. + The first element is the function. The other elements are the arguments. +} +@para{ + Okay. +} + +@section{@(racket (something-else other-stuff ...))} + +@(racketblock (if (< 7 x) "lessthan" "notlessthan")) +@(racketblock (define x (+ x 2))) +@(racketblock (λ (n) (+ n 1))) + +@para{ + These are not function application-forms, but some other forms. + Good to know. +} +@para{ + Anyway, the first element is usually kind of important. + Like if you wanna know what the @(racket (define x (+ x 2))) bit does, + it's probably better to press F1 with the cursor at @(racket define) and not like at @(racket x) or something. + Also, in the evaluator we are going to implement, we will totally look at the first element of a form when deciding what to do. +} + +@section{A very subsetty subset of Racket btw} + +@para{ + We will try to write code in a style that isn't very far away from like, modern Racket, but without introducing like a ton of Racket. + We get most of the work done by working with lists/pairs and simpler data types like symbols and numbers, and then pattern matching lots. +} +@para{ + So like, people who are familiar with Racket-or-Scheme-or-Lisp might read some code and think something like: +} + +@(itemlist + @item{``This would be prettier with @hyperlink["https://docs.racket-lang.org/reference/quasiquote.html"]{quasiquotes and unquoting}.''} + @item{Or ``can we please use @hyperlink["https://docs.racket-lang.org/reference/define-struct.html"]{structs} for this instead of just conses everywhere?''} + @item{Or ``maybe @hyperlink["https://docs.racket-lang.org/reference/require.html"]{use multiple files}?''} + @item{Or ``we should put these @hyperlink["https://docs.racket-lang.org/rackunit/index.html"]{checks} inside test cases and test suites.''} + @item{Or something else...}) + +@para{ + Anyway it's totally okay to use parts of Racket that don't mention in the workshop materials. + We don't have to, but like, we can, it's fine. +} diff --git a/scrbl/util.rkt b/scrbl/util.rkt new file mode 100644 index 0000000..ce01dae --- /dev/null +++ b/scrbl/util.rkt @@ -0,0 +1,21 @@ +#lang scribble/manual + +@(provide intro-para + outro-test-para + outro-para) + +@(define (intro-para filename) + @para{ + If we've been through the previous part, we can keep using the same file. Or we can use @tt[filename] as our starting point. + }) + +@(define outro-test-para + @para{ + Run and see that all the tests pass. + }) + +@(define (outro-para section filename) + @para{ + Next is @secref[section]. + We can keep using the Racket-file we're working with, or skip to @tt[filename]. +}) \ No newline at end of file diff --git a/scrbl/zebra.scrbl b/scrbl/zebra.scrbl new file mode 100644 index 0000000..ac3eea1 --- /dev/null +++ b/scrbl/zebra.scrbl @@ -0,0 +1,197 @@ +#lang scribble/manual + +@(require "util.rkt") + +@title{Towards zebras} + +@intro-para["7-amb.rkt"] + +@para{ + If we add a few more things to our language, we can use amb to figure out who owns the zebra. +} + +@section{What, if anything, is a zebra?} + +@para{ + There exists multiple variations of the + @hyperlink["https://en.wikipedia.org/wiki/Zebra_Puzzle"]{Zebra Puzzle}. + We will use the one we find on Wikipedia: +} +@(itemlist + #:style 'ordered + @item{The Englishman lives in the red house.} + @item{There are five houses.} + @item{The Spaniard owns the dog.} + @item{Coffee is drunk in the green house.} + @item{The Ukrainian drinks tea.} + @item{The green house is immediately to the right of the ivory house.} + @item{The Old Gold smoker owns snails.} + @item{Kools are smoked in the yellow house.} + @item{Milk is drunk in the middle house.} + @item{The Norwegian lives in the first house.} + @item{The man who smokes Chesterfields lives in the house next to the man with the fox.} + @item{Kools are smoked in the house next to the house where the horse is kept.} + @item{The Lucky Strike smoker drinks orange juice.} + @item{The Japanese smokes Parliaments.} + @item{The Norwegian lives next to the blue house.}) + +@para{ + Now, who drinks water? Who owns the zebra? +} + +@section{Adding stuff to our language} + +@para{ + There's a few things that are necessary, or at least convenient, for solving the zebra puzzle. +} + +@subsection{More list/pair functions} + +@para{ + Can add some primitives: +} + +@(itemlist + @item{@(racket cons) for constructing a list or pair} + @item{@(racket car) for getting the first element of a list or pair} + @item{@(racket cdr) for getting the tail of a list or the second element of a pair} + @item{@(racket null?) for checking if something is the empty list}) + +@subsection{Quotes} + +@para{ + In Racket, e.g. @(racket 'a) is translated to @tt{(quote a)} by the reader. + If we want to support quotes in the language we're making, we can match on @(racket (list 'quote x)) + and @(racket continue) with the quoted syntax, @(racket x). +} + +@para{ + Quoting can be convenient for list-laterals, like @(racket '()) and @(racket '(1 2 3)). + Also for for symbols, like @(racket 'foo). +} + +@subsection{Strings} + +@para{ + Maybe we want strings, for values such as @(racket "red") and @(racket "zebra"). + (If we have added quotes to the language, we can choose to use values like @(racket 'red) and @(racket 'zebra) instead, and skip the strings.) +} +@para{ + If we're adding strings, we want to recognize string-literals in @(racket eval-exp), + We can use @(racket string?) for this, same way we use @(racket number?) and @(racket boolean?) for other literals. +} +@para{ + We don't really need to do any fancy string-operations in order to find the zebra. + We can totally add some string-functions to our @(racket primitives), + like @(racket string-append) and, say, @(racket string-upcase), + but we don't have to. +} + +@subsection{@(racket equal?)} + +@para{ + If we add @(racket equal?) to the @(racket primitives) we can use it for checking if things + (e.g. strings, symbols) are equal. +} + +@subsection{Recursive functions} + +@para{ + The list is a recursive data structure. We might need recursive functions. + Since our lists are Racket lists, our strings are Racket strings, and so on, + we can probably get away with writing the recursive functions in Racket and just adding them as primitives. + But it would be neat to add support for recursive functions to our language. +} +@para{ + One way to go is to combine it with adding support for more rackety function definitions, + the ones that go. + We can add a clause to the @(racket match) in @(racket eval-sequence): +} +@(racketblock + [(list (list 'define (list name params ...) body ...) rest ...) #,(emph "your code here")]) + +@para{ + Here we must extend the environment with the function definition. + To make the possibly recursive function, we make a helper-function: +} +@(racketblock + (define (make-named-function env name parameters body) + (λ (continue fail . arguments) + #,(emph "your code here")))) + +@para{ + This should behave mostly like @(racket make-function), + only the function should add ``itself'' to the environment before adding the arguments to the environment. + It can create a copy of ``itself'' by applying @(racket make-named-function) again. + (We're really using Racket's support for recursive functions to build our own support for it.) +} + +@section{Writing a zebra-program} + +@para{ + One way to go about this: +} + +@subsection{Some lists} +@para{ + We make a list of colours, a list of nationalities, and so on. + Each element in the each list is an @(racket amb)-expression with the possible values. + (We can optimize a bit: E.g. since the puzzle tells us that the norwegian lives in the first house, + we don't need an @(racket amb) for the first element in the list of nationalities, + and we don't need to include norwegian as a possible value for the other elements.) +} + +@subsection{Some helper functions} + +@para{We probably want some helper functions for stuff like:} + +@(itemlist + @item{ + Checking that a list contains no duplicate elements + (we won't allow e.g. two red houses) +} + @item{Getting the index of an element in a list} + @item{ + Checking that one element in one list has the same index as another elemnt in another list + (for things like ``the Englishman lives in the red house'') +} + @item{@(racket abs) (or we can just include Racket's @(racket abs) in the @(racket primitives)} + @item{ + Checking that one element has an index that is off by one from the index of another element in another list + (for things like ``the Norwegian lives next to the blue house'') + }) + +@subsection{The requirements} + +@para{ + With the lists and the helper functions we can specify the different requirements. +} + +@para{ + In order to make the program go faster, we should add the different requirements as soon as possible: +} + +@(itemlist + @item{After defining a list, we immediately require that it has no duplicate elements.} + @item{ + After defining a list, we add all the requirements that we have the necessary lists for. + Like, once we have defined a list of nationalities and a list of colours, + we will add the requirements for + ``the Englishman lives in the red house'' and ``the green house is immediately to the right of the ivory house'' + before defining more lists. + }) + +@subsection{Return a list with all the lists} + +@para{Return a list with all the lists.} + +@section{Running the zebra-program} + +@para{ + We can run the program with @(racket evaluate) to find one solution, + and maybe run it with @(racket evaluate*) to check that there is only one solution. +} + +@section[#:tag "zebra-done"]{Done?} + +@para{OMG.} \ No newline at end of file