1 / 20

Comparative Programming Languages

Functional programming with Lisp/Scheme. Comparative Programming Languages. Fundamentals of Functional Programming Languages. The objective of the design of a functional programming language (FPL) is to mimic mathematical functions to the greatest extent possible

armen
Télécharger la présentation

Comparative Programming Languages

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. Functional programming with Lisp/Scheme Comparative Programming Languages

  2. Fundamentals of Functional Programming Languages • The objective of the design of a functional programming language (FPL) is to mimic mathematical functions to the greatest extent possible • The basic process of computation is fundamentally different in a FPL than in an imperative language • In an imperative language, operations are done and the results are stored in variables for later use • Management of variables is a constant concern and source of complexity for imperative programming • In an FPL, variables are not necessary, as is the case in mathematics CS 363 Spring 2005 GMU 2

  3. Lisp • Lisp – based on lambda calculus (Church) • Uniform representation of programs and data using single general data structure (list) • Interpreter based (written in Lisp) • Automatic memory management • Evolved over the years • Dialects: COMMON LISP, Scheme CS 363 Spring 2005 GMU 3

  4. Scheme • Scheme is a functional programming language and a dialect of Lisp. It was developed by Guy L. Steele and Gerald Jay Sussman at MIT • Use Programming Languages ->Dr. Scheme here in the Comp Sys lab CS 363 Spring 2005 GMU 4

  5. Common Lisp • Use: clisp for Common Lisp here in the systems lab CS 363 Spring 2005 GMU 5

  6. Scheme (dr scheme, guile) (define (gcd u v) (if ( = v 0) u (gcd v (remainder u v)) ) ) (define (reverse l) (if (null? l) l (append (reverse (cdr l))(list (car l))) ) ) CS 363 Spring 2005 GMU 6

  7. Scheme (dr scheme, guile) Using guile (gnu scheme): (load "slides.scm") (gcd 56 108) --> 4 (reverse '(2 3 556)) --> (556 3 2) CS 363 Spring 2005 GMU 7

  8. Common Lisp (clisp) (defun mygcd (u v) (if (= v 0) u (mygcd v (rem u v)) ) ) (defun myreverse (l) (if (null l) l (append (myreverse (cdr l))(list (car l))) ) ) ;; (load "slides.lsp"), (mygcd 56 108) --> 4 ;; (myreverse '(2 3 556)) --> (556 3 2) 8

  9. Scheme (define (gcd u v) (if ( = v 0) u (gcd v (remainder u v)) ) ) • Once defined in the interpreter: • (gcd 25 10) • 5 9

  10. Scheme/Lisp expression → atom | list atom → number | string | identifier | character | boolean list → ‘(‘ expression-sequence ‘)’ expression-sequence → expression | expression-sequence expression 10

  11. In C: 3 + 4 * 5 (a = = b) && (a != 0) gcd(10,35) Scheme Expression vs. C In Scheme: (+ 3 (* 4 5 )) (and (= a b)(not (= a 0))) (gcd 10 35) 11

  12. Evaluation Rules for Scheme Expressions • Constant atoms (numbers, strings) evaluate to themselves • Identifiers are looked up in the current environment and replaced by the value found there (using dynamically maintained symbol table) • A list is evaluated by recursively evaluating each element in the list as an expression; the first expression must evaluate to a function. The function is applied to the evaluated values of the rest of the list. 12

  13. * Scheme Evaluation To evaluate (* (+ 2 3)(+ 4 5)) • * is the function – must evaluate the two expressions (+ 2 3) and (+ 4 5) • To evaluate (+ 2 3) • + is the function – must evaluation the two expressions 2 and 3 • 2 evaluates to the integer 2 • 3 evaluates to the integer 3 • + 2 3 = 5 • To evaluate (+ 4 5) follow similar steps • * 5 9 = 45 + + 4 5 2 3 13

  14. Cond statement: (cond (( = a 0) 0) ((= a 1) 1) (else (/ 1 a)) ) Scheme Conditionals If statement: (if ( = v 0) u (gcd v (remainder u v)) ) (if (= a 0) 0 (/ 1 a)) 14

  15. Example of COND (Scheme) (DEFINE (compare x y) (COND ((> x y) (DISPLAY “x is greater than y”)) ((< x y) (DISPLAY “y is greater than x”)) (ELSE (DISPLAY “x and y are equal”)) ) ) 15

  16. Example of COND (Lisp) (defun compare (x y) (COND ((> x y)(format t “x is greater than y”)) ((< x y)(format t “y is greater than x”)) (t (format t “x and y are equal”)) ) ) 16

  17. Predicate Functions (Scheme) EQ? takes two symbolic parameters; it returns #T if both parameters are atoms and the two are the same e.g., (EQ? 'A 'A) yields #T (EQ? 'A '(A B)) yields () • Note that if EQ? is called with list parameters, the result is not reliable • EQ? does not work for numeric atoms (use = ) 17

  18. Predicate Functions (Lisp) EQ takes two symbolic parameters; it returns #T if both parameters are atoms and the two are the same e.g., (eq 'A 'A) yields #T (eq 'A '(A B)) yields nil 18

  19. Predicate Functions (Scheme) LIST? takes one parameter; it returns #T if the parameter is a list; otherwise() 3. NULL? takes one parameter; it returns #T if the parameter is the empty list; otherwise() Note that NULL? returns #T if the parameter is() 4. Numeric Predicate Functions =, <>, >, <, >=, <=, EVEN?, ODD?, ZERO?, NEGATIVE? 19

  20. Predicate Functions (Lisp) LISTP takes one parameter; it returns #T if the parameter is a list; otherwise nil 3. NULL takes one parameter; it returns #T if the parameter is the empty list; otherwise nil Note that NULL returns #T if the parameter is() 4. Numeric Predicate Functions =, <>, >, <, >=, <=, EVENP, ODDP, ZEROP 20

More Related