CSE3302 Programming Languages (n-n-n-notes)

1
CSE3302Programming Languages(n-n-n-notes)

• Summer 2003
• Dr. Carter Tiernan

2
Functional Programming

• List Processing - LISP
• Complex interrelationships among data
• Recursion in conjunction with conditional
  expressions
• Primitive list-handling subroutines
• Applicative language

3
LISP

• Function applications
• Prefix (Polish) notation flexibility
• Fully parenthesized no precedence rules
• Symbolic data
• Lists of symbols called atoms
• List is ONLY data structure in LISP

4
Lists

• S-expressions
• Function applications are evaluated
• Quoted lists are treated as data
• Programs and data represented the same way
• Convenient for one program to generate and call
  for execution of another
• Simple to write program manipulators

5
LISP Execution

• Usually interpreted and often interactive
• Functions
• Pure compute a value only
• eq, plus, difference, etc.
• Pseudo have side effects on computer state
• set, defun, etc.

6
Data Structures

• Constructor list
• Primitives atoms
• Numeric (integer and floating point)
• Many ops provided arithmetic, increment,
  decrement, max, min, relational, predicates
• Nonnumeric character strings
• Limited ops comparisons for equality
• nil (false, empty set)
• null is the test op

7
Constructor

• List
• Surrounded by parentheses
• Separated by blanks
• Zero, one or more elements
• Can contain lists
• () equivalent to nil called empty or null list

8
Accessing Parts of a List

• Car
• Selects the first element of a list
• Cdr
• Returns all of a list except its first element
• Car and Cdr are selectors
• Car and Cdr can be combined to access interior
  parts of a list ex. caadr

9
Building a list

• Cons
• Creates a list from a first element and a list
• Is the inverse of car and cdr
• Example
• (car (to be or not)) to
• (cdr (to be or not)) (be or not)
• (cons to (be or not)) (to be or not)

10
Info Representation

• Property lists
• (p1 v1 p2 v2 pn vn) where pn is the nth
  property and vn is the value of that property
• P-lists give flexibility
• Easy to define a function to get properties

11
Info Representation

• Association lists
• ((a1 v1) (a2 v2) (an vn))
• Handles properties which are flags or properties
  with multiple values

12
Recursive list construction

• Append two lists together
• Identify simplest cases
• (append () L) L
• (append L ()) L
• Reduce other cases to the simplest cases
• (append L M) (cons (car L) (append (cdr L) M)
• (defun append (L M)
• (if (null L))
• M
• (cons (car L) (append (cdr L) M) ))

13
Atoms

• Created by mentioning them
• Have properties and relations (p-list)
• Print name / pname
• putprop adds a property to an atom
• apval denotes the binding of an atom to a value
• set binds an atom
• symbol-plist shows property list of an atom

14
List representation

• Linked list
• Cells in the list have a right and a left
• Right part points to next cell in list
• Left part points to value of the cell
• Data and programs both represented the same way
• Program linked list called an expression tree

15
List Primitives

• Efficient
• Car returns a left part
• Cdr returns a right part
• Cons requires storage allocation for new cell
• Car, Cdr, and Cons do not change values
• Sublists can be shared
• Pseudo-functions alter lists
• rplaca, rplacd
• Have same drawbacks as aliasing

16
Conditional expression

• Cond
• Mimics mathematical notation
• Logical ops are defined in terms of the
  conditional
• And Or
• Operands are evaluated sequentially
• Conditional interpretation vs. strict

17
LISP on omega

• LISP interpreter on both omega and gamma
• Invoke by typing lisp
• Exit by typing (quit)
• CMU Common Lisp
• Info at www.cons.org/cmucl/

18
Iteration

• Performed by recursion
• Reduction
• Perform some op on every element of a list
• Uses a binary function to reduce a list to a
  single value
• Mapping
• Apply a function to every element of a list
• Returns a list of the results
• Filtering
• Forms a sublist containing all elements that
  satisfy some property

19
Functional arguments

• Abstracting out pattern
• Mapcar
• Filter
• Reduce
• Suppress details
• Simplify combination

20
Recursive Interpreters

• Arranged by cases
• Atoms
• Numeric
• Nonnumeric
• Quote
• Conditional
• Functions

21
Interpreters

• Primitive ops performed explicitly
• User-defined functions
• Evaluate parameters
• Bind formals to actuals
• Add bindings to environment
• Evaluate function in environment

22
Environment of evaluation

• Arguments going to (apply f x a) (p.380)
• f the function - lambda expression
• x the parameters - bound formals
• a the environment - existing environment with the
  addition of the bound formals
• Universal function

23
Static scoping

• Closure to indicate environment of definition -
  function keyword
• Instruction part (ip) - program, lambda expr.
• Environment part (ep) - definition environment
• (closure ip ep)
• User-defined functions can be
• Dynamically scoped lambda expressions
• Statically scoped function closures

24
Incompatible scope rules

• Options
• Adopt uniform static scoping
• Use default static scoping but allow special
  dynamic scoping

25
Storage reclamation

• Explicit erasure
• Work for programmers
• Security problems (dangling pointers)
• Automatic reclamation
• Reference counts
• Garbage collection

26
Reference counts

• Accessible cells are referenced
• Reference count keeps track of how many other
  cells reference the current one
• Count must be incremented and decremented
  correctly
• Cells with zero count are added to the free list

27
Reference counts

• Cycles defeat reference counts
• Cyclic reference boosts the count of each member
  plus one member has an outside reference.
• If outside reference goes away, cycle still has
  references internally but no access from anywhere
  else in program
• Allowing cycles is an open issue

28
Garbage Collection

• When storage becomes low, system starts up
  garbage collection
• Mark and sweep process
• Starting at roots mark all cells that can be
  reached recursively moving from each cell to its
  children
• When all are marked, sweep through memory from
  top, free unmarked cells and reset flags on
  marked cells

29
Garbage Collection

• Wreaks havoc on execution time
• Non uniform and unpredictable
• Approaches to more efficiency include
• Continuous garbage collection
• Parallel

30
LISP

• AI - represent and manipulate complex
  interrelationships among symbolic data
• Suited to ill-specified problems
• Easy to manipulate LISP programs in LISP