(guile.info.gz) Scripting Examples
Info Catalog
(guile.info.gz) The Top of a Script File
(guile.info.gz) Guile Scripts
5.2.2 Scripting Examples
------------------------
To start with, here are some examples of invoking Guile directly:
`guile -- a b c'
Run Guile interactively; `(command-line)' will return
`("/usr/local/bin/guile" "a" "b" "c")'.
`guile -s /u/jimb/ex2 a b c'
Load the file `/u/jimb/ex2'; `(command-line)' will return
`("/u/jimb/ex2" "a" "b" "c")'.
`guile -c '(write %load-path) (newline)''
Write the value of the variable `%load-path', print a newline, and
exit.
`guile -e main -s /u/jimb/ex4 foo'
Load the file `/u/jimb/ex4', and then call the function `main',
passing it the list `("/u/jimb/ex4" "foo")'.
`guile -l first -ds -l last -s script'
Load the files `first', `script', and `last', in that order. The
`-ds' switch says when to process the `-s' switch. For a more
motivated example, see the scripts below.
Here is a very simple Guile script:
#!/usr/local/bin/guile -s
!#
(display "Hello, world!")
(newline)
The first line marks the file as a Guile script. When the user
invokes it, the system runs `/usr/local/bin/guile' to interpret the
script, passing `-s', the script's filename, and any arguments given to
the script as command-line arguments. When Guile sees `-s SCRIPT', it
loads SCRIPT. Thus, running this program produces the output:
Hello, world!
Here is a script which prints the factorial of its argument:
#!/usr/local/bin/guile -s
!#
(define (fact n)
(if (zero? n) 1
(* n (fact (- n 1)))))
(display (fact (string->number (cadr (command-line)))))
(newline)
In action:
$ fact 5
120
$
However, suppose we want to use the definition of `fact' in this
file from another script. We can't simply `load' the script file, and
then use `fact''s definition, because the script will try to compute
and display a factorial when we load it. To avoid this problem, we
might write the script this way:
#!/usr/local/bin/guile \
-e main -s
!#
(define (fact n)
(if (zero? n) 1
(* n (fact (- n 1)))))
(define (main args)
(display (fact (string->number (cadr args))))
(newline))
This version packages the actions the script should perform in a
function, `main'. This allows us to load the file purely for its
definitions, without any extraneous computation taking place. Then we
used the meta switch `\' and the entry point switch `-e' to tell Guile
to call `main' after loading the script.
$ fact 50
30414093201713378043612608166064768844377641568960512000000000000
Suppose that we now want to write a script which computes the
`choose' function: given a set of M distinct objects, `(choose N M)' is
the number of distinct subsets containing N objects each. It's easy to
write `choose' given `fact', so we might write the script this way:
#!/usr/local/bin/guile \
-l fact -e main -s
!#
(define (choose n m)
(/ (fact m) (* (fact (- m n)) (fact n))))
(define (main args)
(let ((n (string->number (cadr args)))
(m (string->number (caddr args))))
(display (choose n m))
(newline)))
The command-line arguments here tell Guile to first load the file
`fact', and then run the script, with `main' as the entry point. In
other words, the `choose' script can use definitions made in the `fact'
script. Here are some sample runs:
$ choose 0 4
1
$ choose 1 4
4
$ choose 2 4
6
$ choose 3 4
4
$ choose 4 4
1
$ choose 50 100
100891344545564193334812497256
Info Catalog
(guile.info.gz) The Top of a Script File
(guile.info.gz) Guile Scripts
automatically generated byinfo2html