translating glossary for EuroPython 2022

Author: ramalho

references/sicp/instructors-manual/concrete2-test.rkt

@@ -0,0 +1,56 @@
+#lang racket/base
+
+(require rackunit
+         "concrete2.rkt")
+
+(check-false (ASSQ 'x '()) "Empty bindings")
+(check-equal? (ASSQ 'x '([x . 8])) '(x . 8) "First binding")
+(check-equal? (ASSQ 'x '([y . 7] [x . 8])) '(x . 8) "Older binding")
+(check-equal? (ASSQ 'z '([x . 8])) #f "No binding")
+
+(check-equal? (MAKE-FRAME '(a) '(1)) '([a . 1]) "Smalest frame")
+(check-equal? (MAKE-FRAME '(x y z) '(21 22 23)) '((x . 21) (y . 22) (z . 23)) "3 bindings")
+
+(check-equal? (EXTEND-ENVIRONMENT '(a b) '(1 2) '()) '(([a . 1] [b . 2])))
+(check-equal? (EXTEND-ENVIRONMENT '() '() '()) '(()) )
+
+(check-equal? (EXTEND-ENVIRONMENT '(a b) '(1 2)
+                                  (EXTEND-ENVIRONMENT '(c d) '(3 4) '()))
+              '(((a . 1) (b . 2))
+                ((c . 3) (d . 4))) "Two frames, each with two bindings.")
+
+(check-exn (regexp "Unbound variable 'x") (lambda ()
+    (LOOKUP-VARIABLE-VALUE 'x '())))
+
+(check-equal? (LOOKUP-VARIABLE-VALUE 'x '(([x . 8]))) 8)
+
+(check-equal? (EVAL 1 '()) 1)
+(check-equal? (EVAL '(QUOTE symbol) '()) 'symbol)
+(check-equal? (EVAL '(QUOTE (1 2 3)) '()) '(1 2 3))
+(check-equal? (EVAL 'x (EXTEND-ENVIRONMENT '(x) '(8) '())) 8)
+(check-equal? (EVAL '(+ 3 4) (MAKE-BUILTINS)) 7)
+
+; WIP: replace MAKE-BUILTINS with MAKE-BUILTIN-ENVIRONMENT
+(check-equal? (car (MAKE-BUILTIN-ENVIRONMENT)) '(+ . +))
+(check-equal? (caar (MAKE-BUILTIN-ENVIRONMENT)) '+)
+;(check-equal? (EVAL '(+ 3 4) (MAKE-BUILTIN-ENVIRONMENT)) 7)
+
+(check-equal? (EVAL '(+ (* 3 4) (* 5 6)) (MAKE-BUILTINS)) 42)
+(check-equal? (EVAL '((LAMBDA (x) (* x x)) 111) (MAKE-BUILTINS)) 12321)
+(check-equal? (EVAL '(((LAMBDA (x)
+                               (LAMBDA (y) (+ x y)))
+                       3)
+                      4)
+                    (MAKE-BUILTINS)) 7)
+
+(check-equal? (EVAL '((LAMBDA (x y)
+                               ((LAMBDA (y) (+ x y))
+                                (* x y)))
+                       3 4)
+                    (MAKE-BUILTINS)) 15)
+
+(check-equal? (EVAL '((LAMBDA (x) (IF (< x 0) (- 0 x) x)) 2)
+                    (MAKE-BUILTINS)) 2)
+
+(check-equal? (EVAL '((LAMBDA (x) (IF (< x 0) (- 0 x) x)) -3)
+                    (MAKE-BUILTINS)) 3)

references/sicp/instructors-manual/concrete2.rkt

@@ -0,0 +1,99 @@
+#lang racket/base
+
+; code adapted from the "evaluator with concrete syntax"
+; listed on pages 121-122 of the "Instructor's Manual to
+; accompany Structure and Interpretation of Computer Programs"
+; by Julie Sussman with Harold Abelson and Gerald Jay Sussman.
+
+; Tested with Racket 8.3.
+; This version adds DEFINE, not part of the code in the manual.
+
+(define (EVAL exp environ)
+  ;; dispatch on expression type
+  (cond [(number? exp) exp]                    ; self-evaluating
+        [(symbol? exp)                         ; variable?
+         (LOOKUP-VARIABLE-VALUE exp environ)]
+        [(eq? (car exp) 'QUOTE) (cadr exp)]    ; quoted?
+        ;; rule for procedure objects in the environment model
+        [(eq? (car exp) 'LAMBDA)               ; lambda?
+         (list 'procedure                      ; make-procedure
+               (cadr exp)                      ; lambda-parameters
+               (caddr exp)                     ; lambda-body
+               environ)]
+        [(eq? (car exp) 'IF)                   ; if?
+         (EVAL-IF exp environ)]
+        [else
+         (APPLY (EVAL (car exp) environ)       ; operator
+                (LIST-OF-VALUES (cdr exp)      ; operands
+                                environ))]))
+
+(define (APPLY procedure arguments)
+  ;; dispatch on procedure type
+  (cond [(and (list? procedure) (eq? (car procedure) 'procedure)) ; compoud-procedure?
+         (EVAL
+          (caddr procedure)       ; procedure-body
+          (EXTEND-ENVIRONMENT
+           (cadr procedure)       ; procedure-parameters
+           arguments 
+           (cadddr procedure)))]  ; procedure-environment
+  [else (apply procedure arguments)])) ; (apply ...) from host interpreter
+
+(define (LIST-OF-VALUES exps environ)
+  (if (null? exps)
+      '()
+      (cons (EVAL (car exps) environ)
+            (LIST-OF-VALUES (cdr exps) environ))))
+
+(define (EVAL-IF exp environ)
+  (if (EVAL (cadr exp) environ)      ; if-predicate
+      (EVAL (caddr exp) environ)         ; if-consequent
+      (EVAL (cadddr exp) environ)))  ; if-alternative
+
+(define (EXTEND-ENVIRONMENT vars values base-environ)
+  (cons (MAKE-FRAME vars values) base-environ))
+
+(define (MAKE-FRAME vars values)
+  (cond [(and (null? vars) (null? values)) '()]
+        [(null? vars) (error "Too many arguments" values)]
+        [(null? values) (error "Too few arguments" vars)]
+        [else
+         (cons (cons (car vars) (car values)) ; make binding
+               (MAKE-FRAME (cdr vars) (cdr values)))]))
+        
+(define (LOOKUP-VARIABLE-VALUE var environ)
+  (if (null? environ)
+      (error "Unbound variable" var)
+      (let ([binding (ASSQ var (car environ))]) ; look in first frame
+        (if (eq? binding #f)
+            (LOOKUP-VARIABLE-VALUE var (cdr environ))
+            (cdr binding)))))
+
+(define (ASSQ var bindings)
+  (cond [(null? bindings) #f]
+        [(eq? var (caar bindings)) (car bindings)]
+        [else (ASSQ var (cdr bindings))]))
+
+(define (MAKE-BUILTINS)
+  (EXTEND-ENVIRONMENT
+   '(+ - * / <)
+   (list + - * / <)
+   '()))
+
+(define (MAKE-BUILTIN-ENVIRONMENT)
+  (list '[+ . +]
+        '[- . -]
+        '[* . *]
+        '[/ . /]
+        '[< . <]
+     ))
+  
+
+
+; Needed to support rackunit tests in concrete-test.rkt.
+(provide ASSQ
+         LOOKUP-VARIABLE-VALUE
+         EXTEND-ENVIRONMENT
+         MAKE-FRAME
+         EVAL
+         MAKE-BUILTINS
+         MAKE-BUILTIN-ENVIRONMENT)

workshops/2022-01/GLOSSÁRIO.md

@@ -0,0 +1,59 @@
+# GLOSSARY
+
+Programming language terms used in this workshop:
+
+**AST**: Abstract Syntax Tree; a data structure that represents the program in
+a way that is suitable for processing by an _interpreter_ or _compiler_.
+Python's lists, dictionaries, and/or nested objects are useful to build an AST.
+Python's own internal AST is built from nested objects using classes defined in
+the [`ast` module](https://docs.python.org/3/library/ast.html) of the standard library.
+
+**compiler**: a program which reads source code and produces binary code that
+can be executed by a CPU or a virtual machine.
+CPython includes a compiler that generates Python bytecode which is then
+executed by a bytecode _interpreter_ at runtime.
+This is similar to the way Java works,
+but most Python users don't need to know about the compiler because
+it runs automatically, generating bytecode in memory or on disk—for imported modules.
+
+**host language**: the language in which an interpreter or compiler is written,
+as oposed to the language processed by the interpreter or compiler.
+The host language of `lis.py` is Python, and the host language of CPython is C.
+
+**infix notation**: expression syntax with operators used between operands: `a + b`.
+Contrast with _prefix notation_.
+
+**interpreter**: a program that executes code in memory,
+without generating a binary executable.
+Simple interpreters like `lis.py` read source code, produce an AST,
+and execute the user program by traversing the AST directly.
+Python's "interpreter" automatically compiles the AST to bytecode,
+and its runtime environment interprets the bytecode.
+See _compiler_.
+
+**parser**: function which transforms source code into an _AST_,
+built with objects in the _host language_.
+For example, the `lis.py` function transforms `(* 2 pi)` into `['*', 2, 'pi']`.
+
+**prefix notation**: expression syntax with operators preceding operands.
+For example `+ 1 2 3 4` is the sum of those four numbers.
+In Scheme, prefix expressions are delimited by parenthesis: `(+ a b c d)`
+Contrast with _infix notation_
+
+**prompt**: a symbol displayed by an interactive interpreter to indicate it
+is ready to accept input. In Python, the standard prompt is `>>>`;
+in the Bash shell, the default is `$`.
+
+**REPL**: Read-Eval-Print-Loop; an interactive program which reads user input,
+evaluates (i.e. executes), prints a result, and loops back to accept more
+input, often displaying a _prompt_.
+
+**variadic**: a function parameter that accepts zero or more arguments.
+For example: `def add(*p): return sum(p)` creates a Python function 
+accepting one or more arguments that are collected into the `p` parameter,
+so we can call it as `add()`, `add(3, 4)`, `add(1, 2, 3 4)`, or even
+`add(*range(1_000_000))`.
+In every case, the `p` parameter in `add` gets a tuple of zero or more values.
+The prefix notation of Scheme supports variadic operators,
+so `(+ 1 2 3 4)` evaluates to `10`.
+