This outline is also available in PDF.
Held: Wednesday, 20 September 2006
Summary:
Today we continue to explore files, particularly how one recurses over
files.
Related Pages:
Notes:
- Although I have not finished grading HW16, we will go over
some key issues. You may want to look at
unriffle.ss
and
index-of.ss.
- Don't forget tomorrow's convocation.
Overview:
- About files.
- Key file operations.
- File recursion.
- Lab.
- As I hope you've figured out by now, it is possible (although not
necessarily easy) to use Scheme to do
anything
you can do
on the computer.
- Two similar things that you often want to do are to save data to files and
to recover data from files.
- Why?
- So that data can last a long time.
- So that you can deal with more data than you can easily enter by hand.
- So that you can write a word processor.
- ...
- As you might guess, you can do both activites with Scheme.
- Rather than dealing directly with files, Scheme adds a layer of
abstraction called a port.
- Each port is associated with something that can be used for input
or output.
- That thing can be a file.
- That thing can also be the keyboard (for input), the screen (for
output), or a network connection.
- Why do we have ports?
- So that the process of writing anywhere (or reading anywhere) is the same; our code doesn't need to change.
- So that we can read from the same file more than once simultaneously and not get lost about where we are in the file.
- To create a port that corresponds to a file that you want to read from,
use
(open-input-file file-name).
- To create a port that corresponds to a file that you want to write to,
use
(open-output-file file-name).
- You can read from input ports with
(read port)
- You can write to ports with
-
(newline port)
-
(write value port)
-
(display value port)
- When you're done with an input port, use
(close-input-port port)
- When you're done with an output port, use
(close-output-port port)
- What does
read do when there's nothing left in the file?
It returns a special value (which DrScheme displays as
#<eof>).
- You can tell that that value indicates the end of the file with
eof-object?
- Since files often contain an unpredictable amount of information, we
typically process files recursively.
- You may recall that the pattern for recursion is
(define recursive-proc
(lambda (val)
(if (base-case-test)
(base-case val)
(combine (partof val)
(recursive-proc (simplify val))))))
- For files, the base-case-test is almost always
(eof-object? (peek-char input-port))
- The simplify is a bit more indirect. When we read a character or value
from a file, we have gotten closer to the end of the file.
- Hence, the form is often
(define recursive-proc
(lambda (input-port other-params)
(if (eof-object? (peek-char input-port))
(close-and-return input-port (base-case other-params))
(combine (read input-port)
(recursive-proc input-port other-params)))))
(define close-and-return
(lambda (input-port return-value)
(close input-port)
return-value))
- For writing to a file, the recursion looks a bit more typical. That is, it depends on what we're recursing over.
;
