Fundamentals of Computer Science I (CS151 2003F)

Variable-Arity Procedures

Summary: We explore a variety of issues with variable-arity procedures, including effects of the different formats and detailed consideration of the sample procedures from the corresponding reading.

Contents:

Exercises

Exercise 0: Preparation

a. Review the reading on variable arity procedures.

b. Start DrScheme.

Exercise 1: Basic Experiments

Consider the following procedures:

(define proc1
  (lambda (stuff)
    stuff))
(define proc2
  (lambda stuff
     stuff))
(define proc3
  (lambda (more stuff)
    stuff))
(define proc4
  (lambda (more . stuff)
    stuff))

a. What do you expect the result of (procn 1) to be for each variant?

b. Verify your results experimentally.

c. What do you expect the result of (procn 1 2) to be for each variant?

d. Verify your results experimentally.

e. What do you expect the result of (procn 1 2 3) to be for each variant?

f. Verify your results experimentally.

Exercise 2: Experiments with display-line

Here is the display-line procedure from the reading.

;;; Procedure:
;;;   display-line
;;; Parameters:
;;;   val1 ... valn, 0 or more values
;;; Purpose:
;;;   Displays the strings terminated by a carriage return.
;;; Produces:
;;;   [Nothing]
;;; Preconditions:
;;;   0 or more values given as parameters.
;;; Postconditions:
;;;   All of the values have been displayed.
;;;   The output is now at the beginning of a new line.
(define display-line
  (lambda arguments
    (let kernel ((rest arguments))
      (if (null? rest)
          (newline)
          (begin
            (display (car rest))
            (kernel (cdr rest)))))))

a. Try out some other calls to display-line to check what it prints. For example, try the following:

(display-line "going" "going" "gone")
(display-line "countdown:" 5 4 3 2 1 "done")
(display-line)          ;; apply display-line to no arguments

b. Explain your results.

Exercise 3: Extending display-line

The current version of display-line prints all text together without spaces. Modify the code, so that one space is printed between any two adjacent values supplied as arguments to display-line. For instance, after your modifications, the example from the reading will change. It will now be ...

> (display-line "+--" "Here is a string!" "--+")
+-- Here is a string! --+

You may not use display-separated-line in your answer to this question, although you may refer to it for ideas.

Exercise 4: Determining the number of arguments

Define and test a procedure named call-arity that takes any number of arguments and returns the number of arguments it received (ignoring their values):

> (call-arity 'a #\b "c" '(d))
4
> (call-arity 0.0)
1
> (call-arity)
0

Exercise 5: Experiments with display-separated-line

Here is the display-separated-line procedure from the corresponding reading.

;;; Procedure:
;;;   display-separated-line
;;; Parameters:
;;;   separator, a string
;;;   val1 ... valn, 0 or more additional values.
;;; Purpose:
;;;   Displays the values separated by the separator and followed
;;;   by a carriage return.
;;; Preconditions:
;;;   The separator is a string.
;;; Postconditions:
;;;   All the values have been displayed.
;;;   The output is now at the beginning of a new line.
(define display-separated-line
  (lambda (separator . parameters)
    (if (null? parameters)
        (newline)
        (let kernel ((rest parameters))
          (display (car rest))
          (if (null? (cdr rest))
              (newline)
              (begin
                (display separator)
                (kernel (cdr rest))))))))

a. What do you think should happen if you invoke display-separated-line without giving it any arguments? Verify your results experimentally.

b. What do you think should happen when you give it only one argument? Verify your results experimentally.

c. What do you think should happen when you give it two arguments? Verify your results experimentally.

d. What do you think should happen when you give it three arguments? Verify your results experimentally.

Exercise 6: A Clicker

Define and test a procedure, clicker, that takes one or more arguments, of which the first must be an integer and each of the others must be either the symbol 'up or the symbol 'down. Clicker should start from the given integer, add 1 for each 'up argument, subtract 1 for each 'down argument, and return the result:

> (clicker 17 'up 'up)
19
> (clicker -12 'down 'up 'down 'down 'down)
-15
> (clicker 100)
100

Exercise 7: Multiple Separators

In writing, we often separate the last element of a list using a different separator than for the prior elements. For example, we might separate the all but the last element with commas and the last element with and. Extend display-separated-line so that it requires two parameters (the default separator and the final separator) and supports as many the client provides.

 

History

Tuesday, 31 October 2000 [Samuel A. Rebelsky]

Thursday, 12 April 2001 [Samuel A. Rebelsky]

Monday, 12 November 2002 [Samuel A. Rebelsky]

Wednesday, 9 April 2003 [Samuel A. Rebelsky]

 

Disclaimer: I usually create these pages on the fly, which means that I rarely proofread them and they may contain bad grammar and incorrect details. It also means that I tend to update them regularly (see the history for more details). Feel free to contact me with any suggestions for changes.

This document was generated by Siteweaver on Tue Dec 9 13:59:23 2003.
The source to the document was last modified on Tue Nov 11 13:53:15 2003.
This document may be found at http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2003F/Labs/variable-arity.html.

You may wish to validate this document's HTML ; Valid CSS! ; Check with Bobby

Samuel A. Rebelsky, rebelsky@grinnell.edu