------------------------------------------------------------------------------
MC logo
Printing
[^] Tom's Lisp
------------------------------------------------------------------------------
[Basic Input Format] [Lists, Pairs and Related Operations] [Conditional Evaluation] [Basic Function Definition] [Definitions and Scope] [Functions Which Take Functions] [String Functions] [Exception Handling] [Quoting And Evaluation] [Variable-Length Parameter Lists] [Macro Definitions] [Printing] [The Tomslsp command and its switches] [Index of Standard Functions]

Tom's Lisp provides only the most primitive facilities for printing. Tom's Lisp programs can print only to standard output; there is no facility to open files. There is no input facility under program control, either.

The two operations it does have are print and sprint. The print primitive takes a single object and outputs an external representation of the object. It then evaluates to its argument. This operation calls the same print function which the interpreter itself uses to print the values of the expressions you enter.

lsp>(print 17)
1717
lsp>(print "Hi there")
"Hi there""Hi there"
lsp>(print '(a b c (d e) 22)))
(a b c (d e) 22)(a b c (d e) 22)

Simply running the print from the command prompt shows the value twice, since print displays the argument, evaluates to the argument, then the interpreter again prints this value. The print function is more useful when called inside another function. We'll see one in a moment.

First, though, we also need the sprint function. Its name stands for “string print” since it takes a string and prints out the characters it contains, without the surrounding quotes. Since the input parser knows obeys the \n and \t escape sequences when it reads strings, these are useful with sprint.


lsp>(sprint "howdy")
howdy"howdy"
lsp>(sprint "how\tare\nyou\ntoday?\n")
how     are
you
today?
"how    are
you
today?
"
lsp>

This function is also fairly pointless when entered directly, but it can be useful inside functions. For instance:

(define (count from to)
    (if (< from to) (begin (print from) (sprint " ") (count (+ from 1) to))
        (if (= from to) (begin (print from) (sprint "\n") 'done)))
)
When run:
lsp>(count 5 10)
5 6 7 8 9 10
done
The count function generates and prints a sequence of values separated by spaces. The integer values are printed with print, and the spaces between them and the trailing newline are generated with sprint. (The done atom returned by the function is rather a filler. It must return something.)

While we could certainly create a count function which takes two integers and returns a list of the count from one to the other, that would not let us control how the system prints it. With print and sprint, we can format the list as we like.

For a more complex example, suppose we wish to work with polynomials as lists of coefficients. You can evaluate a polynomial at x quite easily:

(define (polyval x poly)
    (if (null? poly)
        0
        (+ (* x (polyval x (last-but 1 poly))) (car (last 1 poly)))
    )
)
In execution:
lsp>(polyval 5 '(6 3 8 1))
866
lsp>(polyval -3 '(9 11 8))
56
Since 6×53 + 3×52 + 8×5 + 1 = 866, and 9×-32 + 11×-3 + 8 = 56. (The key to understanding this little function is to generalize this observation: 6x3 + 3x2 + 8x + 1 = x(6x2 + 3x + 8) + 1, where the parenthetical subexpression can be evaluated recursively.)

A function to print the polynomials in a readable form would go nicely with our little evaluator.

(define (prpoly-r first order poly)
    (begin      
        (if (!= (car poly) 0) 
            (begin 
                (if (not first) (sprint " + "))
                (print (car poly))
                (if (> order 0) (sprint "x"))
                (if (> order 1) (begin (sprint "^") (print order)))
            )
        )
        (if (> order 0) 
            (prpoly-r (and first (= (car poly) 0)) (- order 1) (cdr poly))
        )
    )
)
(define (prpoly poly)
    (if (null? poly) (print 0) (prpoly-r #t (- (length poly) 1)  poly))
)
(define (polyat x poly)
    (begin
        (prpoly poly)
        (sprint " at x=")
        (print x)
        (sprint " is ")
        (polyval x poly)
    )
)
When can produce:
lsp>(polyat 5 '(6 3 8 1))
6x^3 + 3x^2 + 8x + 1 at x=5 is 866
lsp>(polyat (- 0 3) '(9 11 8))
9x^2 + 11x + 8 at x=-3 is 56

The prpoly-r function goes recursively through the terms, printing a representation of each one. It skips zero terms, suppresses exponents below two, and prints the constant term as a constant. Its parameter first means that the function hasn't printed anything yet, and is used to suppress printing a leading plus sign. The prpoly function is a wrapper which just handles the case of the empty list, and polyat produces a nice line of output by calls to print and sprint, as well as prpoly. It does play one dirty trick by allowing its own value (which comes from polyval) to become part of the output line. This makes the function value printed by the interpreter seem to disappear.