Class 25: Introduction to Files

Held Monday, March 5, 2001

Summary

Today we consider how to make Scheme read values and characters from files and write values to other files.

Assignments

• Laboratory writeup 2.

Notes

• Please do not use input as a verb.
  • Are there questions on homework 4?
• I expect to have all the copies of exam 1 turned in by the end of the day today, so I'll get them back to you by Wednesday.
  • Let me know if you have not turned in your exam.
• There are two ways for you to get extra credit on exam 2 this Thursday (the opportunities are Thursday; exam 2 isn't until after break).
  • Attend the alumni scholars talk by Lea Wittie on debugging.
  • Attend the convocation talk by Professor Roberts. (He's an interesting and outspoken fellow; he's already sent a letter criticizing the laptop proposal to Dean S.)
• A few of you have noted that it would be helpful to have a helper function that prints a request for information, reads a value, and then returns the value read. Here's one possibility:

  ;;; Procedure:
  ;;;   read-value
  ;;; Parameters:
  ;;;   prompt, a string
  ;;; Purpose:
  ;;;   Prints a request for information, reads a value, and returns
  ;;;   the value read.
  ;;; Produces:
  ;;;   val, a value.  (Can be any type of value.)
  ;;; Preconditions:
  ;;;   It is still possible to print output to the standard output port.
  ;;;   It is still possible to read input from the standard input port.
  ;;;   prompt is a string.
  ;;; Postconditions:
  ;;;   Additional text may have appeared on output.
  ;;;   A value will have been read from input.
  ;;;   val is the value that was read from input.
  (define read-value
    (lambda (prompt)
      (display prompt)
      (read)))
  

• I'm expecting that some will eventually want a procedure that reads only numbers. Here's one example.

  ;;; Procedure:
  ;;;   read-number
  ;;; Parameters:
  ;;;   prompt, a string
  ;;; Purpose:
  ;;;   Print a request for information and repeatedly read a value
  ;;;   until a number is entered.
  ;;; Produces:
  ;;;   val, a number
  ;;; Preconditions:
  ;;;   It is still possible to print output to the standard output port.
  ;;;   It is still possible to read input from the standard input port.
  ;;;   prompt is a string.
  ;;; Postconditions:
  ;;;   Additional text will have appeared on output.
  ;;;   One or more values will have been read from input.
  ;;;   The first number entered after this procedure is called will
  ;;;     be returned.
  (define read-number
    ; Helper: Print an error message and try again
    (let ((failure (lambda (prompt val)
                      (display "That wasn't a number!")
                      (newline)
                      (read-number prompt))))
      (lambda (prompt)
        (display prompt)
        ; Read a value
        (let ((val (read)))
          (if (number? val) 
              val
              (failure prompt val))))))
  

Overview

• Files and ports
• Reading values
  • Examples: Summing values
• Reading characters and lines
• Lab

Why Use Files?

• 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.

Ports

• 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 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)
• For example, here's some code that reads one value from the file data

  (let* (; Prepare to read from a file
         (source (open-input-file "data")) 
         ; Read one value
         (value (read source)))
    ; We're done, so clean up.
    (close-input-port source)
    ; Return the value read
    value)
  

• 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?

Reading All the Values in A File

• Let's consider an example in which we read all the numbers in a file and add them up.
• How do we approach the problem?
• It seems like a case for repetition, so we'll need to ask ourselves our favorite questions about recursion.
• How do we break up the problem?
  • Read the first number.
  • Read the remaining numbers.
• What's the base case?
  • No numbers remain.
• What value do we return in that case?
  • 0, the identity for addition.
• How do we write the recursive call?
  • We'll figure that out later.
• What do we do if the recursive call works correctly?
  • We've read one number. We've summed all the remaining numbers. So ... just add 'em together.
• Okay, now we're ready to worry about some details.
• We don't read from files, we read from ports. Hence, we'll add a husk that converts the file name to a port.
• See the reading for more information.
• We'll also add some error checking.

Characters

• You can read a character at a time (rather than a value at a time) using (read-char port).
• Why is this useful? It lets you be more general than the basic read procedure.
• You can also look at the next character that you're about to read using (peek-char port)
• Why is this useful? Sometimes you want to read differently based on what you see next.
  • If you see a semicolon, read the whole line as a string and ignore it.
  • If you see anything else, read it as a Scheme value
• When read-char encounters the end of the file, it returns the same special value as read
• Let's consider an example in which we read a line of text from a file.
• See the reading for more details.