Comp 210 Lab 6: Mutual Recursion, Multiple Complex Arguments

Index: Directory Example, list, Zip Examples

In class we defined the following data definitions:

     A file is a symbol.

     A directory is structure
       (make-dir name contents)
     where name is a symbol, and contents is a l-o-f-d.

     A list-of-files-and-directories (l-o-f-d) is one of
       - empty
       - (cons f lofd)
         where f is a file, and lofd is a l-o-f-d
       - (cons d lofd)
         where d is a directory, and lofd is a l-o-f-d.

     ; file-func : file -> ?
     (define (file-func a-file)
        ...)

     ; dir-func : directory -> ?
     (define (dir-func a-dir)
        ...(dir-name a-dir)...
        ...(lofd-func (dir-contents a-dir))...)

     ; lofd-func : l-o-f-d -> ?
     (define (lofd-func a-lofd)
        (cond
           [(empty? a-lofd)        ...]
           [(file? (first a-lofd)) ...(file-func (first a-lofd))...
                                   ...(lofd-func (rest a-lofd))...]
           [(dir? (first a-lofd))  ...(dir-func (first a-lofd))...
                                   ...(lofd-func (rest a-lofd))...]))

     (define (file? any)
        (symbol? any))

To do: Write a function

     ; flatten-dir : directory symbol -> (directory or l-o-f-d)
     ; Returns a structure like the original directory, except that the
     ; named directory is removed, with its contents moved up one level.

     foo
   /  |  \
bar baz to-remove
         / \
       one two

      foo
   /  /  \  \
bar baz one two

 to-remove
  /  |  \
foo bar baz

foo bar baz

Follow the templates and think about a single case at a time. If you do that, it shouldn't be too difficult. If you don't, you'll probably have real trouble.

Here is a solution.

The following is a convenient abbreviation:

     (list 1 3 5 7)
     =
     (cons 1 (cons 3 (cons 5 (cons 7 empty))))

• Q: What's the difference between (cons 1 empty) and (list 1 empty)?
• A: The former creates a list containing one element, 1. The latter creates a list containing two elements, 1 and empty, i.e., the list (cons 1 (cons empty empty)).

• Q: What's the difference between (cons 1 2) and (list 1 2)?
• A1: The former is an error -- cons's second argument must be a list. The latter creates a list containing two elements, 1 and 2, i.e., the list (cons 1 (cons 2 empty)).
• A2: For the curious... There is another answer if we consider all of Scheme. However, we won't be talking about that in this course.

• Q: What's the difference between (cons 1) and (list 1)?
• A: The former is an error -- cons requires two arguments. The latter creates a list containing one element, 1.

• Q: What's the difference between (cons 1 2 empty) and (list 1 2 empty)?
• A: The former is an error -- cons requires two arguments. The latter creates a list containing three elements.

• Q: What is (list)?
• A: empty.

In short, cons and empty are the constructors of lists. list is another function which makes lists, and is convenient shorthand for combinations of the constructors.

To do:

• Develop a program zip2 which behaves as follows:

       (zip2 (list 1 3 5)
             (list 'foo 'bar 'baz))
       =
       (list (list 1 'foo)
             (list 3 'bar)
             (list 5 'baz))
  
       (zip2 (list "hi")
             (list "there"))
       =
       (list (list "hi" "there"))
       

  Assume that the input lists are of the same length.

• Develop a program unzip2 which behaves as follows:

       (unzip2 (list (list 1 'foo)
                     (list 3 'bar)
                     (list 5 'baz)))
       =
       (list (list 1 3 5)
             (list 'foo 'bar 'baz))
  
       (unzip2 (list (list "hi" "there")))
       =
       (list (list "hi")
             (list "there"))
       

  Assume that the sublists are all length-2 lists.