CS 363 Comparative Programming Languages - PowerPoint PPT Presentation

About This Presentation
Title:

CS 363 Comparative Programming Languages

Description:

(DEFINE (compare x y) (COND (( x y) (DISPLAY 'x is greater than y' ... (car L) returns the first element of L (cdr L) returns L minus the first element ... – PowerPoint PPT presentation

Number of Views:16
Avg rating:3.0/5.0
Slides: 64
Provided by: tjh5
Learn more at: https://www.tjhsst.edu
Category:

less

Transcript and Presenter's Notes

Title: CS 363 Comparative Programming Languages


1
CS 363 Comparative Programming Languages
  • Functional Languages Scheme

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

3
Fundamentals of Functional Programming Languages
  • In an FPL, the evaluation of a function always
    produces the same result given the same
    parameters
  • This is called referential transparency

4
Functions
  • A function is a rule that associates to each x
    from some set X of values a unique y from another
    set Y of values
  • y f(x) or f X ? Y
  • Functional Forms
  • Def A higher-order function, or functional form,
    is one that either takes functions as parameters,
    yields a function as its result, or both

range
domain
5
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

6
Scheme
  • (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)))
  • )
  • )

7
Introduction to Scheme
  • A mid-1970s dialect of LISP, designed to be a
    cleaner, more modern, and simpler version than
    the contemporary dialects of LISP
  • Uses only static scoping
  • Functions are first-class entities
  • They can be the values of expressions and
    elements of lists
  • They can be assigned to variables and passed as
    parameters

8
Scheme
  • (define (gcd u v)
  • (if ( v 0)
  • u
  • (gcd v (remainder u v))
  • )
  • )
  • Once defined in the interpreter
  • (gcd 25 10)
  • 5

9
Scheme Syntax
simplest elements
  • expression ? atom list
  • atom ? number string
  • identifier character boolean
  • list ? ( expression-sequence )
  • expression-sequence ? expression
  • expression-sequence expression

10
Scheme atoms
  • Constants
  • numbers, strings, T True,
  • Identifier names
  • Function/operator names
  • pre-defined user defined

11
Scheme Expression vs. C
  • In Scheme
  • ( 3 ( 4 5 ))
  • (and ( a b)(not ( a 0)))
  • (gcd 10 35)
  • In C
  • 3 4 5
  • (a b) (a ! 0)
  • gcd(10,35)

12
Evaluation Rules for Scheme Expressions
  1. Constant atoms (numbers, strings) evaluate to
    themselves
  2. Identifiers are looked up in the current
    environment and replaced by the value found there
    (using dynamically maintained symbol table)
  3. 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.

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




2
3
4
5
14
Scheme Conditionals
  • If statement
  • (if ( v 0)
  • u
  • (gcd v (remainder u v))
  • )
  • (if ( a 0) 0 (/ 1 a))
  • Cond statement
  • (cond (( a 0) 0)
  • (( a 1) 1)
  • (else (/ 1 a))
  • )

Both if and cond functions use delayed evaluation
for the expressions in their bodies (i.e. (/ 1
a) is not evaluated unless the appropriate branch
is chosen).
15
Example of COND
  • (DEFINE (compare x y)
  • (COND
  • ((gt x y) (DISPLAY x is greater than y))
  • ((lt x y) (DISPLAY y is greater than x))
  • (ELSE (DISPLAY x and y are equal))
  • )
  • )

16
Predicate Functions
  • 1. 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
Predicate Functions
  • 2. 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
  • , ltgt, gt, lt, gt, lt, EVEN?, ODD?, ZERO?,
    NEGATIVE?

18
let function
  • Allows values to be given temporary names within
    an expression
  • (let ((a 2 ) (b 3)) ( a b))
  • 5
  • Semantics Evaluate all expressions, then bind
    the values to the names evaluate the body

19
Quote () function
  • A list that is preceeded by QUOTE or a quote mark
    () is NOT evaluated.
  • QUOTE is required because the Scheme interpreter,
    named EVAL, always evaluates parameters to
    function applications before applying the
    function. QUOTE is used to avoid parameter
    evaluation when it is not appropriate
  • QUOTE can be abbreviated with the apostrophe
    prefix operator
  • Can be used to provide function arguments
  • (myfunct (a b) (c d))

20
Output functions
  • Output Utility Functions
  • (DISPLAY expression)
  • (NEWLINE)

21
define function
  • Form 1 Bind a symbol to a expression
  • (define a 2)
  • (define emptylist ( ))
  • (define pi 3.141593)

22
define function
  • Form 2 To bind names to lambda expressions
  • define (cube x)
  • ( x ( x x ))
  • )
  • (define (gcd u v)
  • (if ( v 0)
  • u
  • (gcd v (remainder u v))
  • )
  • )

function name and parameters
function body lambda expression
23
Function Evaluation
  • Evaluation process (for normal functions)
  • 1. Parameters are evaluated, in no particular
    order
  • 2. The values of the parameters are substituted
    into the function body
  • 3. The function body is evaluated
  • 4. The value of the last expression in the body
    is the value of the function
  • (Special forms use a different evaluation process)

24
Data Structures in Scheme Box Notation for Lists
first element (car)
rest of list (cdr)
1
List manipulation is typically written using
car and cdr
25
Data Structures in Scheme
(1,2,3)
1
2
3
c
d
a
((a b) c (d))
b
26
Basic List Manipulation
  • (car L) returns the first element of L
  • (cdr L) returns L minus the first element
  • (car (1 2 3)) 1
  • (car ((a b)(c d))) (a b)
  • (cdr (1 2 3)) (2 3)
  • (cdr ((a b)(c d))) ((c d))

27
Basic List Manipulation
  • (list e1 en) return the list created from the
    individual elements
  • (cons e L) returns the list created by adding
    expression e to the beginning of list L
  • (list 2 3 4) (2 3 4)
  • (list (a b) x (c d) ) ((a b)x(c d))
  • (cons 2 (3 4)) (2 3 4)
  • (cons ((a b)) (c)) (((a b)) c)

28
Example Functions
  • 1. member - takes an atom and a simple list
    returns T if the atom is in the list ()
    otherwise
  • (DEFINE (member atm lis)
  • (COND
  • ((NULL? lis) '())
  • ((EQ? atm (CAR lis)) T)
  • ((ELSE (member atm (CDR lis)))
  • ))

29
Example Functions
  • 2. equalsimp - takes two simple lists as
    parameters returns T if the two simple lists
    are equal () otherwise
  • (DEFINE (equalsimp lis1 lis2)
  • (COND
  • ((NULL? lis1) (NULL? lis2))
  • ((NULL? lis2) '())
  • ((EQ? (CAR lis1) (CAR lis2))
  • (equalsimp(CDR lis1)(CDR lis2)))
  • (ELSE '())
  • ))

30
Example Functions
  • 3. equal - takes two general lists as parameters
    returns T if the two lists are equal
    ()otherwise
  • (DEFINE (equal lis1 lis2)
  • (COND
  • ((NOT (LIST? lis1))(EQ? lis1 lis2))
  • ((NOT (LIST? lis2)) '())
  • ((NULL? lis1) (NULL? lis2))
  • ((NULL? lis2) '())
  • ((equal (CAR lis1) (CAR lis2))
  • (equal (CDR lis1) (CDR lis2)))
  • (ELSE '())
  • ))

31
Example Functions
  • (define (count L)
  • (if (null? L) 0
  • ( 1 (count (cdr L)))
  • )
  • )
  • (count ( a b c d))
  • ( 1 (count (b c d)))
  • ( 1 ( 1(count (c d))))
  • ( 1 ( 1 ( 1 (count (d)))))
  • ( 1 ( 1 ( 1 ( 1 (count ())))))
  • ( 1 ( 1 ( 1 ( 1 0)))) 4

32
Scheme Functions
  • Now define
  • (define (count1 L) ??
  • )
  • so that (count1 (a (b c d) e)) 5

33
Scheme Functions
  • This function counts the individual elements
  • (define (count1 L)
  • (cond ( (null? L) 0 )
  • ( (list? (car L))
  • ( (count1 (car L))(count1 (cdr L))))
  • (else ( 1 (count (cdr L))))
  • )
  • )
  • so that (count1 (a (b c d) e)) 5

34
Example Functions
  • (define (append L M)
  • (if (null? L) M
  • (cons (car L)(append(cdr L) M))
  • )
  • )
  • (append (a b) (c d)) (a b c d)

35
How does append do its job?
  • (define (append L M)
  • (if (null? L) M
  • (cons (car L)(append(cdr L) M))))
  • (append (a b) (c d))
  • (cons a (append (b) (c d)))

36
How does append do its job?
  • (define (append L M)
  • (if (null? L) M
  • (cons (car L)(append(cdr L) M))))
  • (append (a b) (c d))
  • (cons a (append (b) (c d)))
  • (cons a (cons b (append () (c d))))

37
How does append do its job?
  • (define (append L M)
  • (if (null? L) M
  • (cons (car L)(append(cdr L) M))))
  • (append (a b) (c d))
  • (cons a (append (b) (c d)))
  • (cons a (cons b (append () (c d))))
  • (cons a (cons b (c d)))

38
How does append do its job?
  • (define (append L M)
  • (if (null? L) M
  • (cons (car L)(append(cdr L) M))))
  • (append (a b) (c d))
  • (cons a (append (b) (c d)))
  • (cons a (cons b (append () (c d))))
  • (cons a (cons b (c d)))
  • (cons a (b c d))

39
How does append do its job?
  • (define (append L M)
  • (if (null? L) M
  • (cons (car L)(append(cdr L) M))))
  • (append (a b) (c d))
  • (cons a (append (b) (c d)))
  • (cons a (cons b (append () (c d))))
  • (cons a (cons b (c d)))
  • (cons a (b c d))
  • (a b c d)

40
Reverse
  • Write a function that takes a list of elements
    and reverses it
  • (reverse (1 2 3 4)) (4 3 2 1)

41
Reverse
  • (define (reverse L)
  • (if (null? L) ()
  • (append (reverse (cdr L))(list (car L)))
  • )
  • )

42
Selection Sort in Scheme
  • Lets define a few useful functions first
  • (DEFINE (findsmallest lis small)
  • (COND ((NULL? lis) small)
  • ((lt (CAR lis) small)
  • (findsmallest (CDR lis)
    (CAR lis)))
  • (ELSE
  • (findsmallest (CDR lis)
    small))
  • )
  • )

43
Selection Sort in Scheme
Cautious programming!
  • (DEFINE (remove lis item)
  • (COND ((NULL? lis) () )
  • (( (CAR lis) item) lis)
  • (ELSE
  • (CONS (CAR lis) (remove
    (CDR lis) item)))
  • )
  • )

Assuming integers
44
Selection Sort in Scheme
  • (DEFINE (selectionsort lis)
  • (IF (NULL? lis) lis
  • (LET ((s (findsmallest (CDR lis) (CAR
    lis))))
  • (CONS s (selectionsort (remove lis s)) )
  • )
  • )

45
Higher order functions
  • Def A higher-order function, or functional form,
    is one that either takes functions as parameters,
    yields a function as its result, or both
  • Mapcar
  • Eval

46
Higher-Order Functions mapcar
  • Apply to All - mapcar
  • - Applies the given function to all elements
    of the given list result is a list of the
    results
  • (DEFINE (mapcar fun lis)
  • (COND
  • ((NULL? lis) '())
  • (ELSE (CONS (fun (CAR lis))
  • (mapcar fun (CDR lis))))
  • ))

47
Higher-Order Functions mapcar
  • Using mapcar
  • (mapcar (LAMBDA (num) ( num num num)) (3 4 2
    6))
  • returns (27 64 8 216)

48
Higher Order Functions EVAL
  • It is possible in Scheme to define a function
    that builds Scheme code and requests its
    interpretation
  • This is possible because the interpreter is a
    user-available function, EVAL

49
Using EVAL for adding a List of Numbers
  • Suppose we have a list of numbers that must be
    added
  • (DEFINE (adder lis)
  • (COND((NULL? lis) 0)
  • (ELSE ( (CAR lis)
  • (adder(CDR lis ))))
  • ))
  • Using Eval
  • ((DEFINE (adder lis)
  • (COND ((NULL? lis) 0)
  • (ELSE (EVAL (CONS ' lis)))
  • ))
  • (adder (3 4 5 6 6))
  • Returns 24

50
Other Features of Scheme
  • Scheme includes some imperative features
  • 1. SET! binds or rebinds a value to a name
  • 2. SET-CAR! replaces the car of a list
  • 3. SET-CDR! replaces the cdr part of a list

51
COMMON LISP
  • A combination of many of the features of the
    popular dialects of LISP around in the early
    1980s
  • A large and complex language the opposite of
    Scheme

52
COMMON LISP
  • Includes
  • records
  • arrays
  • complex numbers
  • character strings
  • powerful I/O capabilities
  • packages with access control
  • imperative features like those of Scheme
  • iterative control statements

53
ML
  • A static-scoped functional language with syntax
    that is closer to Pascal than to LISP
  • Uses type declarations, but also does type
    inferencing to determine the types of undeclared
    variables
  • It is strongly typed (whereas Scheme is
    essentially typeless) and has no type coercions
  • Includes exception handling and a module facility
    for implementing abstract data types

54
ML
  • Includes lists and list operations
  • The val statement binds a name to a value
    (similar to DEFINE in Scheme)
  • Function declaration form
  • fun function_name (formal_parameters)
  • function_body_expression
  • e.g.,
  • fun cube (x int) x x x

55
Haskell
  • Similar to ML (syntax, static scoped, strongly
    typed, type inferencing)
  • Different from ML (and most other functional
    languages) in that it is purely functional (e.g.,
    no variables, no assignment statements, and no
    side effects of any kind)

56
Haskell
  • Most Important Features
  • Uses lazy evaluation (evaluate no subexpression
    until the value is needed)
  • Has list comprehensions, which allow it to deal
    with infinite lists

57
Haskell Examples
  • 1. Fibonacci numbers (illustrates function
    definitions with different parameter forms)
  • fib 0 1
  • fib 1 1
  • fib (n 2) fib (n 1)
  • fib n

58
Haskell Examples
  • 2. Factorial (illustrates guards)
  • fact n
  • n 0 1
  • n gt 0 n fact (n - 1)
  • The special word otherwise can appear as a
    guard

59
Haskell Examples
  • 3. List operations
  • List notation Put elements in brackets
  • e.g., directions north,
    south, east, west
  • Length
  • e.g., directions is 4
  • Arithmetic series with the .. operator
  • e.g., 2, 4..10 is 2, 4, 6, 8, 10

60
Haskell Examples
  • 3. List operations (cont)
  • Catenation is with
  • e.g., 1, 3 5, 7 results in
  • 1, 3, 5, 7
  • CONS, CAR, CDR via the colon operator (as in
    Prolog)
  • e.g., 13, 5, 7 results in
  • 1, 3, 5, 7

61
Haskell Examples
  • Quicksort
  • sort
  • sort (ax) sort b b ? x b lt a
  • a
  • sort b b ? x b gt a

62
Applications of Functional Languages
  • LISP is used for artificial intelligence
  • Knowledge representation
  • Machine learning
  • Natural language processing
  • Modeling of speech and vision
  • Scheme is used to teach introductory programming
    at a significant number of universities

63
Comparing Functional and Imperative Languages
  • Imperative Languages
  • Efficient execution
  • Complex semantics
  • Complex syntax
  • Concurrency is programmer designed
  • Functional Languages
  • Simple semantics
  • Simple syntax
  • Inefficient execution
  • Programs can automatically be made concurrent
Write a Comment
User Comments (0)
About PowerShow.com