1 / 40

Rules of Evaluation in Computer Science Lecture

Learn about the rules of evaluation in computer programming and how they differ from natural language. Understand the concepts of primitives, names, and application.

bmcmahon
Download Presentation

Rules of Evaluation in Computer Science Lecture

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. Lecture 3: Rules of Evaluation David Evans http://www.cs.virginia.edu/evans CS200: Computer Science University of Virginia Computer Science

  2. Menu • Language Elements • Why don’t we just program computers using English? • Evaluation • Procedures Scheduled Office Hours (Olsson 236A): Wednesdays 3:30-4:30 (after class) Thursdays 4:00-5:00 CS 200 Spring 2003

  3. When learning a foreign language, which elements are hardest to learn? Primitives There are a lot of them, and learning the real meaning is hard Means of Combination Complex, but, all natural languages have similar ones (Chomsky) SOV (45% of all languages) (Korean): Sentence ::= Subject Object Verb SVO (42%): English: Sentence ::= SubjectVerbObject VSO (9%): Welsh: Sentence ::= Verb Subject Object “Lladdodd y ddraig y dyn.” (Killed the dragon the man.) OSV (<1%): Tobati (New Guinea) Schemish: Expression ::= (VerbObject) Means of Abstraction Few of these, but tricky to learn differences across languages Language Elements CS 200 Spring 2003

  4. CS 200 Spring 2003

  5. CS 200 Spring 2003

  6. CS 200 Spring 2003

  7. Core language issues list has 389 items! CS 200 Spring 2003

  8. CS 200 Spring 2003

  9. Why don’t we just program computers using English? CS 200 Spring 2003

  10. Why don’t we just program computers using English? • Too hard and complex Non-native English speakers don’t need convincing. The rest of you have spent your whole life learning English (and first 5 years of your life doing little else) and still don’t know useful words like floccipoccinihilipilification! There are thoughts that even native speakers find it hard to express. By the end of today you will know enough Scheme (nearly the entire language) to express and understand every computation. By the end of the class, you will know enough to completely describe Scheme in terms of itself (try doing that in English!) CS 200 Spring 2003

  11. Why don’t we just program computers using English? • Not concise enough English: To find the maximum of two numbers, compare them. If the first number is greater than the second number, return the first number. Otherwise, return the second number. Scheme: (define (max a b) (if (> a b) a b)) CS 200 Spring 2003

  12. Why don’t we just program computers using English? • Limited means of abstraction There are only a few pronouns: he, she, it, they, these, … (English doesn’t even have a gender-neutral pronoun for a person!) Only Webster and Oxford can make up new ones. defineallows any programmer to make up as many pronouns as that programmer wants, and use them to represent exactly what the programmer wants. CS 200 Spring 2003

  13. Why don’t we just program computers using English? • Mapping between surface forms and meanings are ambiguous and imprecise The 500 words used most in the English language each have an average of 23 different meanings in the Oxford English Dictionary. http://www.vuse.vanderbilt.edu/~jgray/funny.html I said he thought secret users only may write secret data.(From Only His Only Grammarian Can Only Say Only What Only He Only Means, Peter Neumann) The exact meaning(s) of every Scheme expression is determined by simple, unambiguous rules we will learn today (and refine later in the course). CS 200 Spring 2003

  14. Evaluation

  15. Expressions and Values • (Almost) every expression has a value • Have you seen any expressions that don’t have values? • When an expression with a value is evaluated, its value is produced CS 200 Spring 2003

  16. Evaluation Rule 1: Primitives If the expression is a primitive, it is self-evaluating. > 2 2 > #t #t > + #<primitive:+> CS 200 Spring 2003

  17. Evaluation Rule 2: Names If the expression is a name, it evaluates to the value associated with that name. > (define two 2) > two 2 CS 200 Spring 2003

  18. Evaluation Rule 3: Application • If the expression is an application: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. (expression0 expression1 expression2 … ) CS 200 Spring 2003

  19. Rules for Application • If the procedure to apply is a primitive, just do it. • If the procedure is a compound procedure, evaluate the body of the procedure with each formal parameter replaced by the corresponding actual argument expression value. CS 200 Spring 2003

  20. Making Procedures • lambda means “make a procedure” Expression ::= (lambda(Parameters)Expression) Parameters ::= Parameters ::= Name Parameters CS 200 Spring 2003

  21. Lambda Example: Tautology Function make a procedure with no parameters with body#t (lambda () #t) > ((lambda () #t) 200) #<procedure>: expects no arguments, given 1: 200 > ((lambda () #t)) #t > ((lambda (x) x) 200) 200 CS 200 Spring 2003

  22. You’ve Already Used Lambda! (define (closer-color? sample color1 color2) Expr) is a shortcut for: (define closer-color? (lambda (sample color1 color2) Expr)) CS 200 Spring 2003

  23. Eval and Apply are defined in terms of each other. Without Eval, there would be no Apply, Without Apply there would be no Eval! Eval Apply CS 200 Spring 2003

  24. All of Scheme • Once you understand Eval and Apply, you can understand all Scheme programs! • Except: • We have special Eval rules for special forms (like if) Evaluation Rule 4: If it is a special form, do something special. CS 200 Spring 2003

  25. Evaluating Special Forms • Eval 4-if. If the expression is (ifExpression0 Expression1 Expression2) evaluate Expression0. If it evaluates to #f, the value of the if expression is the value of Expression2. Otherwise, the value of the if expression is the value of Expression1. • Eval 4-lambda. Lambda expressions self-evaluate. (Do not do anything until it is applied.) CS 200 Spring 2003

  26. More Special Forms • Eval 4-define. If the expression is (defineName Expression) associate the Expression with Name. • Eval 4-begin. If the expression is (beginExpression0 Expression1 …Expressionk) evaluate all the sub-expressions. The value of the begin expression is the value of Expressionk. CS 200 Spring 2003

  27. Scheme Expression ::= Primitive Eval 1: If the expression is a primitive, it is self-evaluating. Expression ::= Name Eval 2: If the expression is a name, it evaluates to the value associated with that name.Expression ::= (ExpressionExpressionList)Eval 3: If the expression is an application:(a) Evaluate all the subexpressions (in any order)(b) Apply the value of the first subexpression to the values of all the other subexpressions. ExpressionList ::= ExpressionList ::=ExpressionExpressionList CS 200 Spring 2003

  28. Special Forms Expression ::= (lambda (Parameters)Expression) Eval 4-lambda. Lambda expressions self-evaluate. Parameters ::= Parameters ::= NameParametersExpression ::= (defineNameExpression)Eval 4-define. If the expression is (defineName Expression) associate the Expression with Name. Expression ::= (ifExpression0 Expression1Expression2) Eval 4-if. Evaluate Expression0. If it evaluates to #f, the value of the if expression is the value of Expression2. Otherwise, the value of the if expression is the value of Expression1. Expression ::= (beginExpressionList Expression) Eval 4-begin. Evaluate all the sub-expressions. The value of the begin expression is the value of Expression. CS 200 Spring 2003

  29. Now, you really know all of Scheme! (Except for 3 more special forms you will learn for PS5.) CS 200 Spring 2003

  30. Example Evaluation (define square (lambda (x) (* x x))) (square 4) 16 CS 200 Spring 2003

  31. A Squarish Example (define square (lambda (x) (* x x))) (square 4) Its an application, use evaluation Rule 3: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. CS 200 Spring 2003

  32. (define square (lambda (x) (* x x))) (square 4) Its an application, use evaluation Rule 3: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. Evaluate: square It’s a name, use evaluation Rule 2: If the expression is a name, evaluate the expression associated with that name. (lambda (x) (* x x)) CS 200 Spring 2003

  33. (define square (lambda (x) (* x x))) (square 4) Its an application, use evaluation Rule 3: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. Evaluate: square (lambda (x) (* x x)) Evaluate: 4 Rule 1: If the expression is a primitive, it is self-evaluating 4 CS 200 Spring 2003

  34. (define square (lambda (x) (* x x))) (square 4) Its an application, use evaluation Rule 3: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. Apply: square (lambda (x) (* x x)) to 4 Application Rule 2. If the procedure is a compound procedure, evaluate the body of the procedure with each formal parameter replaced by the corresponding actual argument expression value. CS 200 Spring 2003

  35. Apply: square (lambda (x) (* x x) ) to 4 Body of the procedure Application Rule 2. If the procedure is a compound procedure, evaluate the body of the procedure with each formal parameter replaced by the corresponding actual argument expression value. CS 200 Spring 2003

  36. Apply: square (lambda (x) (* x x) ) to 4 Body of the procedure Application Rule 2. If the procedure is a compound procedure, evaluate the body of the procedure with each formal parameter replaced by the corresponding actual argument expression value. (* 4 4) CS 200 Spring 2003

  37. Evaluate: (* 4 4) Its an application, use evaluation Rule 3: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. Evaluate: * Rule 1: If the expression is a primitive, it is self-evaluating <primitive:*> Evaluate: 4 Rule 1: If the expression is a primitive, … 4 Evaluate: 4 Rule 1: If the expression is a primitive, … 4 CS 200 Spring 2003

  38. Evaluate: (* 4 4) Its an application, use evaluation Rule 3: • Evaluate all the subexpressions of the combination (in any order) • Apply the value of the first subexpression to the values of all the other subexpressions. Apply:<primitive:*> to 4 4 Application Rule 1: If the procedure to apply is a primitive, just do it. 16 CS 200 Spring 2003

  39. (square 4) Eval Rule 3a: Application square 4 Eval Rule 1: Primitive Eval Rule 2: Names Eval Rule 3b: Application (lambda (x) (* x x)) 4 Apply Rule 2: Compound Application (* 44) Eval Rule 3a: Application 4 4 * Eval Rule 1: Primitive Eval Rule 1: Primitive 4 4 Eval Rule 3b: Application #<primitive:*> Apply Rule 1: Primitive Application 16 CS 200 Spring 2003

  40. Charge • PS2 Due Monday 3 Feb • Less code to read than PS1, but now you should understand all of it! • Lots more code to write than PS1 • Reading for Friday: SICP, 1.2 • Reading for Monday: GEB, Ch 5 CS 200 Spring 2003

More Related