1 / 30

Comprehensive Overview of L2Scm Scheme Language

Explore the Syntax, Semantics, and Data Types of L2Scm Scheme, including Procedure Calls, Lists, Vectors, and more within the Scheme Framework. Understand the concepts of Expressions, Variables, Equivalence Testing, and Variable Arity Procedures.

ryo
Télécharger la présentation

Comprehensive Overview of L2Scm Scheme Language

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Introduction to Scheme L2Scm

  2. Language Syntax(BNF) Semantics Pragmatics Data Control Abstract Data Types Denotational AxiomaticOperational (interpreter-based) Attribute Grammar Framework L2Scm

  3. Scheme • Meta-language for coding interpreters • “clean” semantics • Scheme = LISP + ALGOL • simple uniform syntax; symbols and lists • block structure; static scoping • statement : evaluated for its effect • expression : evaluated for its value • Dynamic type checking • flexible but inefficient (rapid prototyping) L2Scm

  4. Expressions Literals Variables Procedure calls • Literals • numerals(2), strings(“abc”), boolean(#t), etc. • Variables • Identifier represents a variable. Variable reference denotes the value of its binding. x 5 ref L2Scm

  5. Expressible vs Denotable values • Booleans are expressible in (early) FORTRAN, but not denotable. • Functions are denotable in C/Pascal, but are not expressible. • In (functional subset of) Scheme, both values spaces are identical. • In (full) Scheme, variable references (pointers) are denotable but not expressible. L2Scm

  6. Scheme Identifiers • E.g., y, x5, +, two+two, zero?, etc • (Illegal) 5x, y)2, ab c, etc • Identifiers • reserved keywords • variables • pre-defined functions/constants • ordinary • functions = procedures L2Scm

  7. Procedure Call (application) • (operator-expr operand-expr ...) • prefix expression (proc/op arg1 arg2 arg3 ...) • Order of evaluation of the sub-expressions is “explicitly” left unspecified by Scheme. • cf. C is silent about it. • cf. Java specifies a left to right processing. (+ x (p 2 3)) ((f 2 3) 5 6) L2Scm

  8. Special Forms • Definition • (define <var> <expr>) • Conditional • (if <test> <then> <else>) (define false #f) (if (zero? 5) 0 #t) L2Scm

  9. Data Types • values, operations, canonical representation • Type-checking • static : compile-time : efficient • dynamic : run-time : flexible • numbers: +, -, *, number?, = etc • booleans: #t, #f, boolean?, etc • strings: string?, string->list, etc L2Scm

  10. Symbols • Identifiers treated as primitive values. Manipulated at run-time. • Distinct from identifiers that name variables in the program text. • Distinct from strings (sequence of characters). • Meta-programming quote symbol? L2Scm

  11. Lists • Ordered sequence of elements of arbitrary types (Heterogeneous) • operations • car, cdr, cons, null?, ... • list, append, ... • first, second, ..., ninth L2Scm

  12. Pairs (cons ’a ’b) (cons ’a (cons ’b nil) ) b a nil () a b L2Scm

  13. Equivalence Test (eq? (cons 3 ()) (cons 3 ())) #f (define a (cons 3())) (define b (cons 3 ())) (eq? a b) #f (define c a) (eq? a c) #t L2Scm

  14. Vectors • Both records and arrays provide random access to components. However, records are heterogeneous, while arrays are homogenoeus. • Vectors are heterogeneous structures that provide random access to components using a computable index. L2Scm

  15. Constructors and accessors (define v (vector 1 (+ 1 2))) #(1 3) (vector-ref v 0) 1 (vector-length v) 2 • Index is 0-based. L2Scm

  16. Procedures • In Scheme, procedures are first-class objects. That is, they may be passed to or returned from procedures or stored in a data structure. (if (procedure? 3) car cdr) #<procedure> (procedure? append) #t L2Scm

  17. ( (if (procedure? procedure?) car cdr) (cons cdr car)) ’(list append)) = ( (car (cons cdr car)) ’(list append)) = (cdr ’(list append)) = (append) L2Scm

  18. Apply-function (apply cons ’( x (y z))) = (cons ’x ’(y z)) = (x y z) (apply f ’(a1 a2 ... an)) = (f ’a1 ’a2 ... ’an) (apply <func> <list-of-args>) L2Scm

  19. (apply apply (list procedure? (list apply))) = (apply apply [ proc-fn [ apply-fn ] ] ) = (apply proc-fn [apply-fn] ) = #t L2Scm

  20. Anonymous Fucntions (lambda <formals> <body-expr>) E.g., ( (lambda (n) (+ n 2)) 5) = 7 • Evaluate actual argument expressions • Bind these values to formals • Evaluate body expression (static scoping) L2Scm

  21. Variable Arity Procedures (+ 1 2 3) (append ’(1 (p q)) () ’(a b c)) (list 1 2 3 4 5) (lambda <formal> <body>) • <formal> is bound to the list of actual argument values supplied in a call. L2Scm

  22. (define mul (lambda x (if (null? x) 1 (* (car x) (apply mul (cdr x)) ) )) ; 1 is identity w.r.t * ) ; assuming * is binary (mul 1 (+ 2 3) 5) L2Scm

  23. Binding constructs in Scheme • define • binds value to a name. • l-function application • binds formal parameters to actual argument values. • let-constructs • introduces local bindings • let • let* • letrec L2Scm

  24. let-construct ( let ( (var1 exp1) … (varn expn)) exp ) • exp1 to expn are evaluated in the surrounding context. • var1,…,varn are visible only in exp. • (let ( (x 2) (y 7) ) y) • 7 L2Scm

  25. (let ( (x y) (y 7) ) y) • *error* “y” undefined • (define y 5) • (let ( (x y) (y 7) ) y) • 7 • (let ( (x y) (y 7) ) x) • 5 • (let ( (y 7) (x y) ) x) • 5 (not 7) L2Scm

  26. (define y 5) • (let ( (y 7) (x y) ) x) • 5 • (let ( (y 7) ) (let ( (x y) ) x) ) • 7 • (let* ( (y 7) (x y) ) x) • 7 • let* abbreviates nested-lets. • Recursive and mutually recursive functions cannot be defined using let and let*. L2Scm

  27. letrec-construct ( letrec ( (var1 exp1) … (varn expn)) exp ) • var1,…,varn are visible in exp1 to expn in addition to exp. • (letrec ( (x (lambda() y) (y (lambda() x) ) x ) L2Scm

  28. letrec-construct • (letrec ( (f (lambda(n) (if (zero? n) 1 (f (- 1 n)) )) ) ) (f 5) ) • 1 • (letrec ( ( f (lambda () g) ) ( g 2) ) ( f ) ) • 2 L2Scm

  29. boolean connectives (or test1 test2 … testn) (and test1 test2 … testn) • or and and are not Scheme procedures. • They use short circuit evaluation rather than traditional call-by-value. L2Scm

  30. (cond (test1 exp1) (test2 exp2) … (testn expn) (else exp) ) (case key (keylist1 exp1) (keylist2 exp2) … (keylistn expn) (else exp) ) Branching constructs L2Scm

More Related