DOCSLIB.ORG

Introduction to Scheme { a Language Is Described by Specifying Its Syntax and Semantics { Syntax: the Rules for Writing Programs

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Introduction to Scheme { a Language Is Described by Specifying Its Syntax and Semantics { Syntax: the Rules for Writing Programs How do you describe them Introduction to Scheme { A language is described by specifying its syntax and semantics { Syntax: The rules for writing programs. z We will use Context Free Grammars. Gul Agha { Semantics: What the programs mean. z Informally, using English CS 421 z Operationally, showing an interpreter Fall 2006 z Other: Axiomatic, Denotational, … { Look at R5RS for how this is done formally CS 421 Lecture 2 & 3: Scheme 2 Context Free Grammars Example: English Language A (context-free) grammar consists of four { Terminals parts: 1. A set of tokens or terminals. These are the atomic symbols in the language. { Non-Terminals 2. A set of non-terminals. These represent the various concepts in the language 3. A set of rules called productions { Productions mapping the non-terminals to groups of tokens. { 4. A start non-terminal Main Non-Terminal CS 421 Lecture 2 & 3: Scheme 3 CS 421 Lecture 2 & 3: Scheme 4 Example: English Language Example: English Language { Terminals { Terminals z Words of the language z Words of the language { Non-Terminals { Non-Terminals z sentences, verbs, nouns, adverbs, complex, noun phrases, ..... { Productions { Productions { Main Non-Terminal { Main (Start) Non-Terminal CS 421 Lecture 2 & 3: Scheme 5 CS 421 Lecture 2 & 3: Scheme 6 1 Example: English Language Backus Naur Form { Terminals { BNF non-terminals are enclosed in the z Words of the language symbols < … > { Non-Terminals { < > represents the empty string z sentences, verbs, nouns, adverbs, { Example: complex, noun phrases, ..... <string> ::= < > | <char><string> { Productions <char> ::= a | b | c | ..... z Any guesses ::= should be read as can be { Main Non-Terminal | should be read as or z sentence Sometimes Æ is used for ::= CS 421 Lecture 2 & 3: Scheme 7 CS 421 Lecture 2 & 3: Scheme 8 A Grammar for Core Scheme Grammar continued <expression> Æ <constant> Æ <boolean> <constant> | <number> | <character> | <identifier> | <string> | (if <expression> <expression> <expression>) | (define <identifier> <expression>) <formals> Æ (<variable>*) | (quote <expression>) | <variable> | <(<variable >…<variable >. <variable>) | (begin <expression> ... <expression>) 1 n | (lambda <formals> <body>) <body> Æ <expression> | <procedure call> <procedure call> Æ (<operator> <operand>*) <operator> Æ <expression> <operand> Æ <expression> And productions for <boolean>, <number>, <character>, <string> CS 421 Lecture 2 & 3: Scheme 9 CS 421 Lecture 2 & 3: Scheme 10 Syntactic Keywords of Scheme An Overview of Scheme { Control: quote, lambda, if, define, { R-E-P begin. z Interacting via the Read-Eval-Print loop { Atomic Data { Predicates: equal? null? zero? z booleans, numbers, symbols, characters & ... strings ... { Expressions { Recognizers: integer? boolean? z What are they? and how are they evaluated. string? pair? list? procedure? ... { Conditionals { Lists: car cdr cons ... z if and syntactic sugar (macros): not, and, or, cond. { Recognizers & Predicates CS 421 Lecture 2 & 3: Scheme 11 CS 421 Lecture 2 & 3: Scheme 12 2 Overview of Scheme (Contd.) Overview of Scheme (contd.) { Functions { Recursive Definition z lambda, let, let* z what is it, some examples, and how it works. { Definitions { Recursion vs Iteration z what they are and what they look like. z translating a while into a recursive function (tail recursion) { Lists & quote z what they look like, including the empty list { List Processing z some world famous list functions { List Manipulation z Constructing and deconstructing lists: car, cdr, { Functionals cons z functions of function e.g., mapping & sorting CS 421 Lecture 2 & 3: Scheme 13 CS 421 Lecture 2 & 3: Scheme 14 Binding Functional Language { Pattern Matching Functions are first-class values in Scheme.. z what is it & how is it done. { Functions can be used as arguments { Notions of Equality { Functions can be returned as values z eq? and its many relations. { Functions can be bound to variables and { Data Mutation & Scheme Actors stored in data structures z setcar!, setcdr! and the sieve of erasthones Important Note: No mutations Scheme is not a strictly functional (assignments) may be used in the first language: bindings of variables can be couple of MPs mutated. We will avoid this for now. CS 421 Lecture 2 & 3: Scheme 15 CS 421 Lecture 2 & 3: Scheme 16 Talking to Scheme > (define cell (cons + *)) > 3434 > (+ 1 2 3 4) > cell 3434 24 (cons + *) > (integer? 2345) > + #t + #<primitive-procedure *> > (procedure? (car cell)) > (+ 1 2 3 4) > (lambda (x) (* x x)) true 10 (lambda (a1) …) #<CLOSURE (x) (* x x)> > (define + *) > ((cdr cell) 5 5) #<unspecified> ¾ ((lambda (x) (* x x)) 12) 144 25 CS 421 Lecture 2 & 3: Scheme 17 CS 421 Lecture 2 & 3: Scheme 18 3 Atomic Data Notes { Booleans { Characters & Strings { Booleans, numbers, characters are z the truth values: z #\a #f #t constants. ;lower case letter a { Numbers z #\space ; the preferred { Symbols (other than predefined z integer way to write a space functions) must be given a value. z rational z #\newline z real ; the newline { All these data types are disjoint, i.e. z complex number character nothing can be both a this and a { Symbols or z "this is a typical string“ identifiers that. z Used as variables to name values CS 421 Lecture 2 & 3: Scheme 19 CS 421 Lecture 2 & 3: Scheme 20 Expressions Examples { Constants, Symbols and Data > (* 3 4 (+ 2 3)) { Lists 60 z Special forms > (*) z Application of a function to given arguments 1 <exp> ::= (<exp> <exp> ... <exp>) > ((lambda (x) (* x 4)) 4) Stands for: <function application> ::= 16 (<fun> <arg1> ... <argn>) > ((car (cons + *)) 7 3) 10 CS 421 Lecture 2 & 3: Scheme 21 CS 421 Lecture 2 & 3: Scheme 22 Notes Sequencing (begin <exp> ..... <exp>) { Function application is call-by-value. { evalutes the expressions <exp> from left right Each <arg> is evaluated, as is the { returns the value of the rightmost expression. <fun>. >(begin (write "a") (write "b") { The order of evaluation is not (write "c") (+ 2 3)) specified. "a""b""c"5 { Some functions have no arguments. z writes "a", "b" and "c" out to the screen, in { ( ) is not a function application, its that order. the empty list. z evaluates to 5. CS 421 Lecture 2 & 3: Scheme 23 CS 421 Lecture 2 & 3: Scheme 24 4 Lists Lists and Expressions ¾ (list? x) { Scheme expressions are lists ¾ evaluates to #t if and only if x is/names a list. { Expressions are evaluated ¾ Otherwise it evaluates to #f. { How to say something is a list rather than an expression? ¾ ( ) ;the empty list { Use the special form quote: ¾ (list? ( )) > (quote <expression>) ¾ (null? ()) z evaluates to the list or scheme object expression. ¾ (null? x) z No evaluation of expression takes place. ¾ (this is a list with a very deep z Abbreviated as: ((((((((((((((((((end))))))))))))))))))) ’<expression> CS 421 Lecture 2 & 3: Scheme 25 CS 421 Lecture 2 & 3: Scheme 26 Examples Notes { Notation Convention >’(+ 1 2) z Recognizers end with a ? z There is also a ! convention -- used for something different >’(+ ’(* 3 4) 1 2) { Constants Convention z Constants such as booleans, strings, characters, and numbers do not need to be quoted. >(procedure? ’+) { Quoted Lists >(procedure? +) z A quoted list is treated as a constant. It is an error to alter one. >(symbol? ’+) { Nested Lists >(symbol? +) z Lists may contain lists, which may contain lists, which may contain lists .... CS 421 Lecture 2 & 3: Scheme 27 CS 421 Lecture 2 & 3: Scheme 28 List Manipulation Operations Examples { cons is the list constructor 1. (cons 1 ()) evaluates to (1) { car gets the first element of a list. 2. (cons 5 ’(1 2 3 4)) z Its name comes from: 3. (cons ’(1 2 3 4) ’(5)) Contents of the AddressRegister. 4. (car ’(a b c d)) { cdr gets the rest of a list. 5. (cdr ’(a b c d)) z Its name comes from: 6. (caar ’((1) 2 3 4)) Contents of the Decrement Register. 7. (cddr ’(a b c d)) { Names inherited from the first implementation of 8. (cdddr ’(a b c d)) Lisp on IBM 704 back in 1958. 9. (cddddr ’(a b c d)) CS 421 Lecture 2 & 3: Scheme 29 CS 421 Lecture 2 & 3: Scheme 30 5 Notes Lisp Manipulation Axioms 1. (car ()) is undefined, as is (cdr ()). 1. (car (cons <a> <d>)) is <a> 2. (pair? <list>) => #t when <list> is non-empty. 3. (pair? ()) 2. (cdr (cons <a> <d>)) is <d> 4. Any composition of cars and cdrs of length upto 3. If <list> is a list, then length 4 is valid, z car cdr (cons (car <list>) (cdr <list>)) z caar cdar cadr cddr z caaar cdaar cadar caddr cdadr cddar cdddr is equal? to <list> z caaaar ......... cddddr Question: How many operations in this last line? CS 421 Lecture 2 & 3: Scheme 31 CS 421 Lecture 2 & 3: Scheme 32 List Recursion Think Recursively! { Check if it is a list (list? …) Write a function, F, which when { Repeatedly apply cdr till you reach given a list <list> produces a the end of the list new list, obtained by adding 1 { Use (null? …) to check if it empty to every number in the <list> before deconstructing { Use (cons …) to build a list ¾ (F ’(a 1 b 2 c 3 d 4 e 5)) { Use (cdr …) to walk through list (F ’(a 2 b 3 c 4 d 5 e 6)) CS 421 Lecture 2 & 3: Scheme 33 CS 421 Lecture 2 & 3: Scheme 34 Base Case and Induction The Answers { If <list> is the empty list, then { (F ’( )) should just be ( ) what should (F <list>) be? { if (car <list>) is a number { If I know what (car <list>) is, and I (F <list>) should be also know what (F (cdr <list>)) is, (cons (+ 1 (car <list>)) (F (cdr do I know what (F <list>) should <list>))) be? { if (car <list>) is not a number (F <list>) should be (cons (car <list>) (F (cdr <list>))) CS 421 Lecture 2 & 3: Scheme 35 CS 421 Lecture 2 & 3: Scheme 36 6 The Code Tracing Procedures (define F > (F '(a 1 b 2 c 3 d 4 e 5)) > (trace F) (lambda (l) (a 2 b 3 c 4 d 5 e 6) (F) (if (null? l) ( ) > (F '(1 2 3 4)) | | |() (if (number? (car l)) |(F (1 2 3 4)) | | (5) (cons (+ 1 (car l)) | (F (2 3 4)) | |(4 5) (F (cdr l))) | |(F (3 4)) | (3 4 5) (cons (car l) | | (F (4)) |(2 3 4 5) (F (cdr l))))))) | | |(F ()) (2 3 4 5) CS 421 Lecture 2 & 3: Scheme 37 CS 421 Lecture 2 & 3: Scheme 38 Understanding cons Box Diagrams •cons creates a new pair each time it is called! List notation Pair notation •eq? on pairs returns true if and only if the two pairs are the same pairs (a b c d) (a .
Load more

Recommended publications
  • A History of Clojure
    A History of Clojure RICH HICKEY, Cognitect, Inc., USA Shepherd: Mira Mezini, Technische Universität Darmstadt, Germany Clojure was designed to be a general-purpose, practical functional language, suitable for use by professionals wherever its host language, e.g., Java, would be. Initially designed in 2005 and released in 2007, Clojure is a dialect of Lisp, but is not a direct descendant of any prior Lisp. It complements programming with pure functions of immutable data with concurrency-safe state management constructs that support writing correct multithreaded programs without the complexity of mutex locks. Clojure is intentionally hosted, in that it compiles to and runs on the runtime of another language, such as the JVM. This is more than an implementation strategy; numerous features ensure that programs written in Clojure can leverage and interoperate with the libraries of the host language directly and efficiently. In spite of combining two (at the time) rather unpopular ideas, functional programming and Lisp, Clojure has since seen adoption in industries as diverse as finance, climate science, retail, databases, analytics, publishing, healthcare, advertising and genomics, and by consultancies and startups worldwide, much to the career-altering surprise of its author. Most of the ideas in Clojure were not novel, but their combination puts Clojure in a unique spot in language design (functional, hosted, Lisp). This paper recounts the motivation behind the initial development of Clojure and the rationale for various design decisions and language constructs. It then covers its evolution subsequent to release and adoption. CCS Concepts: • Software and its engineering ! General programming languages; • Social and pro- fessional topics ! History of programming languages.
    [Show full text]
  • Lisp and Scheme I
    4/10/2012 Versions of LISP Why Study Lisp? • LISP is an acronym for LISt Processing language • It’s a simple, elegant yet powerful language • Lisp (b. 1958) is an old language with many variants • You will learn a lot about PLs from studying it – Fortran is only older language still in wide use • We’ll look at how to implement a Scheme Lisp and – Lisp is alive and well today interpreter in Scheme and Python • Most modern versions are based on Common Lisp • Scheme is one of the major variants • Many features, once unique to Lisp, are now in – We’ll use Scheme, not Lisp, in this class “mainstream” PLs: python, javascript, perl … Scheme I – Scheme is used for CS 101 in some universities • It will expand your notion of what a PL can be • The essentials haven’t changed much • Lisp is considered hip and esoteric among computer scientists LISP Features • S-expression as the universal data type – either at atom (e.g., number, symbol) or a list of atoms or sublists • Functional Programming Style – computation done by applying functions to arguments, functions are first class objects, minimal use of side-effects • Uniform Representation of Data & Code – (A B C D) can be interpreted as data (i.e., a list of four elements) or code (calling function ‘A’ to the three parameters B, C, and D) • Reliance on Recursion – iteration is provided too, but We lost the documentation on quantum mechanics. You'll have to decode recursion is considered more natural and elegant the regexes yourself. • Garbage Collection – frees programmer’s explicit memory management How Programming Language Fanboys See Each Others’ Languages 1 4/10/2012 What’s Functional Programming? Pure Lisp and Common Lisp Scheme • The FP paradigm: computation is applying • Lisp has a small and elegant conceptual core • Scheme is a dialect of Lisp that is favored by functions to data that has not changed much in almost 50 years.
    [Show full text]
  • Lists in Lisp and Scheme
    Lists in Lisp and Scheme • Lists are Lisp’s fundamental data structures • However, it is not the only data structure Lists in Lisp – There are arrays, characters, strings, etc. – Common Lisp has moved on from being merely a LISt Processor and Scheme • However, to understand Lisp and Scheme you must understand lists – common funcAons on them – how to build other useful data structures with them In the beginning was the cons (or pair) Pairs nil • What cons really does is combines two objects into a a two-part object called a cons in Lisp and a pair in • Lists in Lisp and Scheme are defined as Scheme • Conceptually, a cons is a pair of pointers -- the first is pairs the car, and the second is the cdr • Any non empty list can be considered as a • Conses provide a convenient representaAon for pairs pair of the first element and the rest of of any type • The two halves of a cons can point to any kind of the list object, including conses • We use one half of the cons to point to • This is the mechanism for building lists the first element of the list, and the other • (pair? ‘(1 2) ) => #t to point to the rest of the list (which is a nil either another cons or nil) 1 Box nota:on Z What sort of list is this? null Where null = ‘( ) null a a d A one element list (a) null null b c a b c > (set! z (list ‘a (list ‘b ‘c) ‘d)) (car (cdr z)) A list of 3 elements (a b c) (A (B C) D) ?? Pair? Equality • Each Ame you call cons, Scheme allocates a new memory with room for two pointers • The funcAon pair? returns true if its • If we call cons twice with the
    [Show full text]
  • Pairs and Lists (V1.0) Week 5
    CS61A, Spring 2006, Wei Tu (Based on Chung’s Notes) 1 CS61A Pairs and Lists (v1.0) Week 5 Pair Up! Introducing - the only data structure you’ll ever need in 61A - pairs. A pair is a data structure that contains two things - the ”things” can be atomic values or even another pair. For example, you can represent a point as (x . y), and a date as (July . 1). Note the Scheme representation of a pair; the pair is enclosed in parentheses, and separated by a single period. Note also that there’s an operator called pair? that tests whether something is a pair or not. For example, (pair? (cons 3 4)) is #t, while (pair? 10) is #f. You’ve read about cons, car, and cdr: • cons - takes in two parameters and constructs a pair out of them. So (cons 3 4) returns (3 . 4) • car - takes in a pair and returns the first part of the pair. So (car (cons 3 4)) will return 3. • cdr - takes in a pair and returns the second part of the pair. So (cdr (cons 3 4)) will return 4. These, believe it or not, will be all we’ll ever need to build complex data structures in this course. QUESTIONS: What do the following evaluate to? (define u (cons 2 3)) (define w (cons 5 6)) (define x (cons u w)) (define y (cons w x)) (define z (cons 3 y)) 1. u, w, x, y, z (write out how Scheme would print them and box and pointer diagram). CS61A, Spring 2006, Wei Tu (Based on Chung’s Notes) 2 2.
    [Show full text]
  • A Lisp Machine with Very Compact Programs
    Session 25 Hardware and Software for Artificial Intelligence A LISP MACHINE WITH VERY COMPACT PROGRAMS L. Peter Deutsch Xerox corporation, Palo Alto Research center (PARC) Palo Alto, California 94304 Abstract Data Types This paper presents a machine designed for LISP has many data types (e.g. list, compact representation and rapid execution symbolic atom, integer) but no declarations. of LISP programs. The machine language is a The usual implementation of languages with factor of 2 to 5 more compact than this property affixes a tag to each datum to S-expressions or conventional compiled code, indicate its type, in LISP, however, the , and the.compiler is extremely simple. The vast majority of data are pointers to lists encoding scheme is potentially applicable to or atoms, and it would be wasteful to leave data as well as program. The machine also room for a full word plus tag (the space provides for user-defined data structures. needed for an integer datum, for example) in every place where a datum can appear such as Introduction the CAR and CDR of list cells. Consequently, in BBN-LISP every datum is a Pew existing computers permit convenient or pointer; integers, strings, etc. are all efficient implementation of dynamic storage referenced indirectly. Storage is allocated in quanta, and each quantum holds data of allocation, recursive procedures, or only one type, so what type of object a operations on data whose type is represented given pointer references is just a function explicitly at run time rather than of the object's address, i.e. the pointer determined at compile time.
    [Show full text]
  • Mattox's Quick Introduction to Scheme
    Mattox’s Quick Introduction to Scheme or, What Do People See in This Language, Anyway? c November, 2000 Mattox Beckman 1 Introduction The purpose of this document is to give the reader an introduction to both the Scheme programming language and some of the techniques and reasoning used in functional programming. The goal is that the reader will be comfortable using Scheme and be able to write programs in functional style. The reader is assumed to be a CS321 student: someone who has written some large programs in C++ or Java, and is at any rate familiar with imperative or object oriented languages; but who is not familiar with functional programming. You will get a lot more out of this if you have a Dr. Scheme window open, try out the examples, and make up some of your own as you go along. The outline of this paper is as follows: Section 2 briefly discusses four major language paradigms. Section 3 introduces lists and list operations. 2 Language Paradigms There are four major language paradigms in use today, which have different definitions as to what constitutes a program. • Imperative: Languages like C, Fortran are called imperative, meaning “command”, because a program is thought of as being a list of commands for the computer to execute. • Functional: Languages like SML, Haskell, Lisp, and Scheme are common examples. These language involve “programming with functions.” A program is considered an expression to be evaluated. • Object Oriented: Languages like Smalltalk, in which a program is a collection of objects which com- municate with each other.
    [Show full text]
  • Functional Programming Pure Functional Languages
    Functional Programming • Pure functional PLs • S-expressions – cons, car, cdr • Defining functions • read-eval-print loop of Lisp interpreter • Examples of recursive functions – Shallow, deep • Equality testing 1 Functional-10, CS5314, Sp16 © BGRyder Pure Functional Languages • Referential transparency – value of an expression is independent of context where the function application occurs – means that all variables in a function body must be local to that function; why? • There is no concept of assignment – variables are bound to values only through parameter associations – no side effects 2 Functional-10, CS5314, Sp16 © BGRyder 1 Pure Functional Languages • Control flow accomplished through function application (and recursion) – a program is a set of function definitions and their application to arguments • Implicit storage management – copy semantics, needs garbage collection • Functions are 1st class values! – can be returned as value of an expression or function application – can be passed as an argument – can be put into a data structure and saved • Unnamed functions exist as values 3 Functional-10, CS5314, Sp16 © BGRyder Pure Functional Languages • Lisp designed for symbolic computing – simple syntax – data and programs have same syntactic form • S-expression – function application written in prefix form (e1 e2 e3 … ek) means • Evaluate e1 to a function value • Evaluate each of e2,…,ek to values • Apply the function to these values (+ 1 3) evaluates to 4 4 Functional-10, CS5314, Sp16 © BGRyder 2 History Lisp Scheme Common Lisp
    [Show full text]
  • Introduction to Cognitive Robotics
    Introduction to Cognitive Robotics Module 8: An Introduction to Functional Programming with Lisp Lecture 1: Common Lisp - REPL, lists, structures, equality, conditionals, CONS, CAR, CDR, dotted and assoc-list www.cognitiverobotics.net An Introduction to Functional Programming with Lisp 1 1 Introduction to Cognitive Robotics Aside: Programming Paradigms An Introduction to Functional Programming with Lisp 1 2 Introduction to Cognitive Robotics Note: This is an oversimplification Programming Paradigms Imperative Declarative Object- Procedural Functional Logic Oriented An Introduction to Functional Programming with Lisp 1 3 Introduction to Cognitive Robotics Programming Paradigms Imperative Declarative e.g. C Object- Procedural Functional Logic Oriented First do this and next do that Focus on how An Introduction to Functional Programming with Lisp 1 4 Introduction to Cognitive Robotics Programming Paradigms Imperative Declarative e.g. C++, Java Object- Procedural Functional Logic Oriented Send messages between objects to accomplish some task Focus on how An Introduction to Functional Programming with Lisp 1 5 Introduction to Cognitive Robotics Programming Paradigms Imperative Declarative e.g. Lisp Object- Procedural Functional Logic Oriented Evaluate an expression and use the resulting value for something Focus on what An Introduction to Functional Programming with Lisp 1 6 Introduction to Cognitive Robotics Programming Paradigms Imperative Declarative e.g. Prolog Object- Procedural Functional Logic Oriented Answer a question using logical
    [Show full text]
  • Lists in Lisp and Scheme • Lists Are Lisp’S Fundamental Data Structures, Lists in Lisp but There Are Others – Arrays, Characters, Strings, Etc
    Lists in Lisp and Scheme • Lists are Lisp’s fundamental data structures, Lists in Lisp but there are others – Arrays, characters, strings, etc. – Common Lisp has moved on from being and Scheme merely a LISt Processor • However, to understand Lisp and Scheme you must understand lists – common func?ons on them a – how to build other useful data structures with them Lisp Lists In the beginning was the cons (or pair) • What cons really does is combines two obJects into a • Lists in Lisp and its descendants are very two-part obJect called a cons in Lisp and a pair in Scheme simple linked lists • Conceptually, a cons is a pair of pointers -- the first is – Represented as a linear chain of nodes the car, and the second is the cdr • Each node has a (pointer to) a value (car of • Conses provide a convenient representaon for pairs list) and a pointer to the next node (cdr of list) of any type • The two halves of a cons can point to any kind of – Last node ‘s cdr pointer is to null obJect, including conses • Lists are immutable in Scheme • This is the mechanism for building lists • Typical access paern is to traverse the list • (pair? ‘(1 2) ) => #t from its head processing each node a null 1 Pairs Box and pointer notaon a Common notation: use diagonal line in • Lists in Lisp and Scheme are defined as (a) cdr part of a cons cell pairs for a pointer to null a a null • Any non empty list can be considered as a pair of the first element and the rest of A one element list (a) the list (a b c) • We use one half of a cons cell to point to the first element
    [Show full text]
  • Hilbert's Program Revisited
    1 1 Hilbert’s Program Revisited Volume I Base case: -computation 휔 Dr Stephen Gaito PerceptiSys Ltd April 7, 2019 Perish then Publish Press. 1 1 2 2 This document was prepared using ConTEXt and LuaTEX on April 7, 2019. Unless explicitly stated otherwise, all content contained in this document which is not software code is Copyright © 2019 PerceptiSys Ltd (Stephen Gaito) and is licensed for release under the Creative Commons Attribution-ShareAlike 4.0 International License (CC-BY-SA 4.0 License). You may obtain a copy of the License at http://creativecommons.org/licenses/by-sa/4.0/ Unless required by applicable law or agreed to in writing, all non-code content distributed under the above CC-BY-SA 4.0 License is distributed on an ‘AS IS’ BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the CC-BY-SA 4.0 License whose URL is listed above for the specific language governing permissions and limitations under the License. Again, unless explicitly stated otherwise, all content contained in this document which is software code is Copyright © 2019 PerceptiSys Ltd (Stephen Gaito) and is licensed under the Apache License, Version 2.0 (the "License"); you may not use this code except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed un- der the Apache 4.0 License is distributed on an ‘AS IS’ BASIS, WITHOUT WAR- RANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    [Show full text]
  • Cs 4480 Lisp
    CS 4480 LISP September 10, 2010 Based on slides by Istvan Jonyer Book by MacLennan Chapters 9, 10, 11 1 Fifth Generation • Skip 4th generation: ADA – Data abstraction – Concurrent programming • Paradigms – Functional: ML, Lisp – Logic: Prolog – Object Oriented: C++, Java 2 Chapter 9: List Processing: LISP • History of LISP – McCarthy at MIT was looking to adapt high- level languages (Fortran) to AI - 1956 – AI needs to represent relationships among data entities • Linked lists and other linked structures are common – Solution: Develop list processing library for Fortran – Other advances were also made • IF function: X = IF(N .EQ. 0, ICAR(Y), ICDR(Y)) 3 What do we need? • Recursive list processing functions • Conditional expression • First implementation – IBM 704 – Demo in 1960 • Common Lisp standardized 4 Example LISP Program (defun make-table (text table) (if (null text) table (make-table (cdr text) (update-entry table (car text)) ) ) ) • S-expression is used (for Symbolic language) – Other languages use M-expression (for Meta) 5 Central Idea: Function Application • There are 2 types of languages – Imperative • Like Fortran, Algol, Pascal, C, etc. • Routing execution from one assignment statement to another – Applicative • LISP • Applying a function to arguments – (f a1 a2 … an) • No need for control structures 6 Prefix Notation • Prefix notation is used in LISP – Sometimes called Polish notation (Jan Lukasiewicz) • Operator comes before arguments • (plus 1 2) same as 1 + 2 in infix • (plus 5 4 7 6 8 9) • Functions cannot be mixed because
    [Show full text]
  • Programming Languages Scheme Part 4 and Other Functional 2020
    Programming Languages Scheme part 4 and other functional 2020 1 Instructor: Odelia Schwartz Lots of equalities! Summary: § eq? for symbolic atoms, not numeric (eq? ‘a ‘b) § = for numeric, not symbolic (= 5 7) § eqv? for numeric and symbolic 2 equal versus equalsimp (define (equalsimp lis1 lis2) (define (equal lis1 lis2) (cond (cond ((null? lis1) (null? lis2)) ((not (list? lis1)) (eq? lis1 ((null? lis2) #f) lis2)) ((eq? (car lis1) (car lis2)) ((not (list? lis2)) #f) (equalsimp (cdr lis1) ((null? lis1) (null? lis2)) (cdr lis2))) ((null? lis2) #f) (else #f) ((equal (car lis1) (car ) lis2)) ) (equal (cdr lis1) (cdr lis2))) (else #f) ) ) 3 append (define (append lis1 lis2) (cond ((null? lis1) lis2) (else (cons (car lis1) (append (cdr lis1) lis2))) )) § Reminding ourselves of cons (run it on csi): (cons ‘(a b) ‘(c d)) returns ((a b) c d) (cons ‘((a b) c) ‘(d (e f))) returns (((a b) c) d (e f)) 4 Adding a list of numbers § This works: (+ 3 7 10 2) § This doesn’t work: (+ (3 7 10 2)) § Why? 5 Adding a list of numbers § This works: (+ 3 7 10 2) § This doesn’t work: (+ (3 7 10 2)) How would we achieve the second option? 6 Adding a list of numbers § This works: (+ 3 7 10 2) § This doesn’t work: (+ (3 7 10 2)) How would we achieve the second option? Breakout groups 7 Adding a list of numbers § We want: (+ (3 7 10 2)) (define (adder a_list) (cond ((null? a_list) 0) (else (eval(cons '+ a_list))) ) ) 8 Adding a list of numbers § We want: (+ (3 7 10 2)) (define (adder a_list) (cond ((null? a_list) 0) (else (eval(cons '+ a_list))) ) ) We’ll do a little
    [Show full text]