Software II: Principles of Programming Languages

Dr. R. M. Siegfried

Functional Languages: Scheme

If this does not answer all your questions, please go to CSC 160 - A First Course In Computer Programming - Notes index

Scheme

• Scheme is a dialect of the  LISP, a functional  programming language designed and implemented by John McCarthy et. al.  at MIT.
• LISP was the pre-eminent language of Artificial Intelligence
• Gerald Sussman and Guy Steele based Scheme on LISP and it was standardized by the IEEE in 1989.

Expressions in Scheme

• The Expression is the basic building block of Scheme functions:

(+ 5 8)
(/ 7.0 3)
(sqrt 4)
• The basic syntax for expressions is:

(opname operand1 operand2 ...)
• Expressions can be nested inside expressions:

(+ 2 (* 4 5))

Function definitions

• Functions can be defined in Scheme by writing:

(define (func-name param1 param2)
  (expression)
)
• Example

(define (add x y )
   (+ x y)
)
(define (force mass accel)
   (* mass accel)

)

Conditional Expressions in Scheme

There are two mechanisms for writing conditional expressions in Scheme

cond

if

cond expressions are:
(cond
    [(condition1) (expression1) ]
    [(condition2) (expression2) ]
    [else (cexpression3)]
   )

cond statements: An Example

(define (sign-check x)
  (cond
    [(> x 0) 'Positive ]
    [(< x 0) 'Negative ]
    [else 'zero ]
   )
 )

if expressions

• if expressions can be used to set a value if a condition is true:

(define (func-name params)
  (if (condition) expression1))
or
(define (func-name params)
  (if (condition)
  expression1 expression2))

if Expressions: Examples

(define (check-sign x)
  (if (> x 0) 'Positive))

(define (check-sign x)
  (if (> x 0) 'Positive 'Nonpositive))

(define (check-sign x)
  (if (> x 0) 'Positive
 (if (< x 0) 'Negative 'Zero)))

Lists in Scheme

• Like LISP, lists are the primary data type in Scheme.
• A list is a ordered collection of items and can be defined two ways:

 (list 45 1 65 'car true)
or
(cons 45 (cons 1(cons 65(cons 'car (cons true empty)))))

Using Lists in Scheme

• Scheme makes very heavy use of recursion to manipulate lists:

(define (sum x)
  (cond
    [(empty? x) 0]
    [else (+ (first x) (sum (rest x)))]
  )
)

(define (number x)
  (cond
    [(empty? x) 0]
    [else (+ 1 (number (rest x)))]
  )
)
(define (average x)
  (/ (sum x) (number x)
  )
}

Predicates

• A predicate is a property of  a data object or the relationship between data objects.
• Scheme provides several predicates that test the data objects that they are given:
• empty?  - true if the list is empty; false if not
• boolean?   - true if the operand is a boolean; false if not
• number? -  true if the operand is a number; false if not

Using Predicates

(define (sum x)
  (cond
    [(empty? x) 0]
    [else
     (cond
       [(number? (first x))
          (+ (first x) (sum (rest x)))]
       [else (sum(rest x))])]
  )
)

Sorting in Scheme

;; sort : list-of-numbers -> list-of-numbers
     ;; to create a list of numbers with the
     ;; same numbers as alon sorted in
     ;; descending order
     (define (sort alon)
       (cond
         [(empty? alon) empty]
         [(cons? alon) (insert (first alon)
                        (sort (rest alon)))]))

;; insert : number sorted-number-list -> number-
;;   list to create a list of numbers from n and
;;   alon that is sorted in descending order;
;;   alon is sorted
(define (insert n alon)
  (cond
    [(empty? alon) (cons n empty)]
    [else (cond
            [(< n (first alon)) (cons n alon)]
            [else (cons (first alon)
    (insert n (rest alon)))])]))

[Back to the Assignment Index]