scheme I/0 输入输出操作

2.1. `open-input-file`, `read-char`, and `eof-object?`

The function (open-input-file filename) is available to open a file. This function return a port for input. The function (read-char port) is to read a character from the port. As this function returns eof-object when it reaches the end of the file (EOF), you can check it by using eof-object?. The function (close-input-port port) is to close the input port. The [code 1] shows a function that returns file contents as string.

[code 1]

(define (read-file file-name)

  (let ((p (open-input-file file-name)))

    (let loop((ls1 '()) (c (read-char p)))

      (if (eof-object? c)

	  (begin

	    (close-input-port p)

	    (list->string (reverse ls1)))

	  (loop (cons c ls1) (read-char p))))))
为什么要reverse，因为cons c ls1 是把先前读取的放在后面，而c放在前面，为什么不(cons ls1 c)

#\!)
> (define c (cons 1 2))
> (cons c 3)
'((1 . 2) . 3)

> (cons 3 c)
'(3 1 . 2)

把cons放在car位置上，会有一个（），而放在第二个则没有。

For instance, the result shown in [example 1] is obtained by applying the [code 1] to a file [hello.txt]. As the newline character is represented by '\n', it is not easy to read. Function display is available, however, for formatting ([example 2]).

[hello.txt]

Hello world!

Scheme is an elegant programming language.

[example 1]

(cd "C:\\doc")

(read-file "hello.txt")

;Value 14: "Hello world!\nScheme is an elegant programming language.\n"

[example 2]

(display (read-file "hello.txt"))

Hello world!

Scheme is an elegant programming language.

;Unspecified return value

2.2. Syntaxes `call-with-input-file` and `with-input-from-file`

You can open a file for input using the syntax call-with-input-file or with-input-from-file. These syntaxes are convenient because they handle errors.

(call-with-input-file filename procedure)

It opens a file named filename for input. The procedure is a function that takes input port as an argument. The file should be closed explicitly because it is not closed when the control is returned from the procedure if the input port is potentially used again. The [code 1] can be rewritten like [code 2] using call-with-input-file.

它打开一个文件来作为输入，接受一个函数（port做为参数）

[code 2]

(define (read-file file-name)

  (call-with-input-file file-name

    (lambda (p)

      (let loop((ls1 '()) (c (read-char p)))

	(if (eof-object? c)

	    (begin

	      (close-input-port p)

	      (list->string (reverse ls1)))

	    (loop (cons c ls1) (read-char p)))))))

(with-input-from-file filename procedure) 自动关闭

It opens a file named filename as the standard input. The procedure is a function with no argument. The file is closed when the control is returned from the procedure. [code 3] shows the rewritten function of [code 1] using with-input-from-file.

[code 3]

(define (read-file file-name)

  (with-input-from-file file-name

    (lambda ()

      (let loop((ls1 '()) (c (read-char)))

	(if (eof-object? c)

	    (list->string (reverse ls1))

	    (loop (cons c ls1) (read-char)))))))

2.3. `read`

The function (read port) reads a S-expression from the port. It is convenient to read contents with parentheses like [paren.txt]. （这个真是为lisp专门设计的。

[paren.txt]

'(Hello world!

Scheme is an elegant programming language.)

'(Lisp is a programming language ready to evolve.)

[code 4]

(define (s-read file-name)

  (with-input-from-file file-name

    (lambda ()

      (let loop ((ls1 '()) (s (read)))

	(if (eof-object? s)

	    (reverse ls1)

	    (loop (cons s ls1) (read)))))))

The following shows the result of reading paren.txt by s-read.

(s-read "paren.txt")

⇒ ((quote (hello world! scheme is an elegant programming language.))

(quote (lisp is a programming language ready to evolve.)))
demo1：

'(hello wrodl)
'(you )
'(can)

输出:'('(hello wrodl) '(you) '(can))

demo2:

(you) (can)

'((you) (can))

demo3:
(you (we)) (can)
输出：'((you (we)) (can))

Exercise 1

Write the function read-lines that returns a list of strings which correspond to each line of file contents. The newline character is represented by#\Linefeed in Scheme. Following is the result of applying this function to the hello.txt.

(read-lines "hello.txt") ⇒ ("Hello world!" "Scheme is an elegant programming language.")

3. Output to files

3.1. Making a Port for output

Similar functions to those for input are available to make output ports.

(open-output-file filename): It opens a file for output and returns a output port.
(close-output-port port): It closes the port for output.
(call-with-output-file filename procedure): It opens a file named filename for output and calls procedure. The function procedure takes the port as an argument.
(with-output-to-file filename procedure): It opens a file named filename as the standard output and calls procedure. The procedure is a function with no argument. The file is closed when the control is returned from the procedure.

3.1. Functions for output

Following functions for output are available. These functions output to the standard output if the port is omitted.

(write obj port): It outputs the obj to the port. Strings are enclosed in double quotes and characters are combined with the #\.
(display obj port): It outputs the obj to the port. Strings are not enclosed in double quotes and characters are not combined with the #\.
(newline port): It begins a new line.
(write-char char port): It outputs the char to the port.; 转自：http://www.shido.info/lisp/scheme9_e.html

scheme 提供了一些输入输出过程，可以调用它们读取输入端口，写入输出端口，而这些端口<port>可以与控制台<console>、文件<file>或者字符串<string>相关联。

1.Reading<读取>

scheme 读取<reader>过程有一个可选输入端口参数，默认是当前输入端口<通常是控制台>。

读取可以是基于字符、行或者是符号表达式。在每一次读取过程中，端口的状态都会更新，以使下一次读取时从已经读过的后面开始。如果一个端口已经读取到结尾，读取过程就返回 end-of-file 或 eof-object 对象，这个对象可以用 eof-object? 函数来判断。

read-char 过程读取指定端口下一个字符;
read-line 过程读取指定端口的下一行，返回一个字符串<换行符会自动去掉>;
read 过程读取指定端口的下一个符号表达式。

2.Writing<写入>

scheme 写入过程以一个被写入对象和一个可选输出端口为参数，输出端口默认是当前输出端口<通常为控制台>。

write-char 过程把一个字符<不带 #\>写入到指定端口；
write 过程把一个符号表达式以一种 machine-readable 的形式写入指定端口，比如，一个字符串会被双引号括着，而字符会带有 #\；
display 过程把一个符号表达式以一种 human-readable 的形式写入指定端口，比如，一个字符串不会被双引号括着，而一个字符不会带有 #\。

3.File ports<文件端口>

scheme　输入（输出）过程以标准输入（输出）为默认输入（输出）端口，所以当从标准输入（输出）读取（写入）时，不用指定端口，但是如果你想显式的给出端口，可以调用无参数的 current-input-port 和 current-out-port 过程：

scheme@(guile-user)> (display 9)

9scheme@(guile-user)> (display 9 (current-output-port))

9scheme@(guile-user)>

open-input-file 以一个文件名为参数，返回与这个文件相关联的输入端口，当所给文件不存在时会报错；
open-output-file 以一个文件名为参数，返回与这个文件相关联的输出端口，当所给文件已存在时会报错。

当对一个端口完成所有操作时，你应当用 close-input-port 和 close-output-port 来关闭它。

下面例子中，假设当前文件夹下 hello.txt 文件只含有 hello 一个词：

scheme@(guile-user)> (define i (open-input-file "hello.txt"))

scheme@(guile-user)> (read-char i)

#\h

scheme@(guile-user)> (define j (read i))

scheme@(guile-user)> j

ello

scheme@(guile-user)> (read-char i)

#\newline

scheme@(guile-user)> (read-char i)

#<eof>

下面例子，假设当前文件夹下没有 greeting.txt 文件：

scheme@(guile-user)> (define o (open-output-file "greeting.txt"))

scheme@(guile-user)> (display "hello" o)

scheme@(guile-user)> (write-char #\space o)

scheme@(guile-user)> (display 'world o)

scheme@(guile-user)> (newline o)

scheme@(guile-user)> (close-output-port o)

此时，在当前文件夹下会有一个 greeting.txt 文件，文件内容为：hello world

3.1 Automatic opening and closing of file ports<自动开关文件端口>

scheme 中的 call-with-input-file 和 call-with-output-file 过程会为你自动打开一个端口，并且当你不再用它时会自动关闭它。

call-with-input-file 过程以一个文件名和一个过程为参数，而参数过程是以一个端口为参数，而 call-with-input-file 过程的作用就是把与一个文件名相关的端口传给其过程参数，并且当过程参数返回时确保该端口被关闭：

scheme@(guile-user)> (call-with-input-file "hello.txt"

... (lambda (i)

... (let* ((a (read-char i))

... (b (read-char i))

... (c (read-char i)))

... (list a b c))))

(#\h #\e #\l)

call-with-output-file 过程与 call-with-input-file 过程相似，但是其所服务的对象是输出文件。

4.String ports<字符串端口>

open-input-string 过程使一个字符串与一个端口相关联，而那些读取过程对该端口的操作就是读出字符串中的内容：

scheme@(guile-user)> (define i (open-input-string "hello world"))

scheme@(guile-user)> (read-char i)

#\h

scheme@(guile-user)> (read i)

ello

scheme@(guile-user)> (read i)

world

scheme@(guile-user)> (read i)

#<eof>

5.Loading file<加载文件>

load 过程会在当前模块中顺序执行当前文件夹下给定文件名中所有 scheme 语句。

参考：
http://www.shido.info/lisp/scheme9_e.html

http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-9.html

http://lispor.is-programmer.com/posts/23271.html