Tutorial Introduction to Guile

This document is an introduction into using Guile, the GNU extension language
and system. Guile is a dialect of the Scheme programming language, and I will
assume you're at least confident about the very basics of Scheme or LISP in
general. However, Guile also allows application developers to integrate it
into their code to provide scripting capability to it and extend the main
Guile language with primitives specific to the application being extended.
Exactly this is what I want to give a brief introduction to.

If you want to develop and test the code presented here on-the-fly for yourself
while working through the text (it is for sure a good idea and even better if
you want to play around with certain stuff not literally presented inbetween),
you need of course to install GNU Guile (including the appropriate development
package containing header files, if necessary for your system) as well as
Gnuplot, and have a UNIX-like
environment and some C compiler (just use gcc). I worked on a GNU/Linux
machine with Guile 1.8.7, Gnuplot 4.2 and gcc 4.3.1, but any recent Guile and
Gnuplot should do it.

1 The Fundamentals

Guile is an implementation and dialect of the Scheme programming language
(Scheme is a dialect of LISP itself). It is intended to be used as the
extension language of the GNU project.

That means that Guile is designed as a library you can include into your own
project and make the interpreter run code within it; additionally, you can
provide special procedures in this Guile environment that interface to the
core of your application. This way, Scheme scripts written by a user can
manipulate stuff “within” your application.

The point of this all is to provide an easy way for you to make your application
extensible and scriptable. For instance, if you need some sort of
configuration files or even real scripting support for your application,
you can use
Guile instead of rolling your own “small” configuration or scripting
language and interpreter; it already exists, so don't waste your time on yet
another one but instead keep working on the new and exciting parts of your
project! Having Guile as some “universal” scripting language (at least that's
what the Guile people would like it to be, but I think it's suited to this
goal) also means that a user does not have to learn different languages for
each application she wants to configure or script. Instead she can do so on
all her favourite software with just learning Scheme. Besides, at least my
personal opinion is that Scheme is very nice and fun to program in, and
very well suited to small pieces of code like scripts.

And the very best: The current development on Guile allows the core Guile
“platform” to run not only Scheme code but support other languages as well
on top of Guile. So you can just integrate Guile as scripting interpreter
into your code, and have it also run scripts in ECMAScript, Emacs Lisp or
any other language that Guile will implement in the future (like Perl,
Tcl, Python or others) – and you don't have to think a single instant about
this!

In concrete terms, installing Guile on your system provides basically two
things for you:

First, you can use the guile command-line utility as a Scheme
interpreter to write programs (or as a table-top calculator
if you want to).

Second, use the libguile programming library to run applications
using Guile as scripting extension; or write your own that can access the
interpreter and make use of it to script your code.

2 The Tortoise

“Why did you call him Tortoise, if he wasn't one?” Alice asked.

“We called him Tortoise because he taught us,” said the Mock Turtle angrily.

(Lewis Carroll, Alice's Adventures in Wonderland)

As the project to demonstrate Guile, we're going to develop a very simple
“Tortoise” graphics program. It will use Gnuplot for graphics output, but
should be easy to adapt to any other graphics systems.

It will produce graphics output by assuming that there's a tortoise sitting in
the middle of the screen; this tortoise is able to perform some basic
instructions given by the user.

You can ask it to turn left by a certain number of degrees (or right by giving
a negative number), or you can intstruct it to walk a certain number of steps
forward.
It has got a pen and you can ask it to carry it either in its paws or behind
its ear, so that when it moves it will leave a mark on the ground or not.

Finally, if you got yourself and the poor tortoise completely confused, you
can ask it to walk away to a fresh (empty) ground, sit in the middle and
face right, just as at the very start.

2.1 The Core System

Let's finally start and implement the core program that will keep track of the
tortoise, its movements and the graphics output. This will be implemented in
C. As mentioned before, I'm going to use Gnuplot for the graphics output
(at first I wanted to use the Gtk+ toolkit, but there were some problems with
this approach I will come back to later).

The idea is to start a Gnuplot process in the background and send it commands
to draw the lines we want on the screen over a pipe. Here's the code for a
program that will start up a Gnuplot process and keep connected to it
via a pipe ready to get further plotting commands:

Note that here we're not doing any error checks on the system routines; you
shouldn't be doing this yourself, but it keeps this code as simple as possible.
As that so far has nothing to do with what you want to read about in this
tutorial, I think this should be the best way to go.

What we're doing here is starting a Gnuplot process with the start_gnuplot
routine and opening a pipe that can feed commands to it into
global_output, so that we are later able to plot lines.

Gnuplot is started with a fixed coordinate range (-10 to 10 in both x and y
directions). We're going to use parametric mode so we won't get any problems
drawing vertical lines, and multiplot mode in order to allow building the
graphics incrementally by adding single lines each at a time.

Now, this code adds a routine for plotting a line from (x1, y1)
to (x2, y2):

(You may want to read up on parametric plotting in Gnuplot or on parametric
equations for lines if you're not sure what's going on here. Or just believe
me that this will do what we want for the moment.)

Finally, we can write the routines that will control the tortoise; here's some
trigonometry involved, and you will need to #include <math.h>:

As a side-note: This program leaves the Gnuplot process alive when terminating;
we could send it a quit command before finishing, but later on we
won't be able to do so and instead of cooking up anything more complicated,
I'll just leave it like that. It basically works this way and even has the
advantage that the Gnuplot window stays open until you close it, despite the
fact that our tortoise-program has already finished. And if you get worried
about the processes, just do a killall gnuplot afterwards...

I don't know about you, but I myself like using Makefiles; so save the full
code we've worked out to tortoise.c and this as Makefile:

Of course, CFLAGS and LIBS are quite useless at the moment, but
they will get some use later, so I just included them right away. Now,
doing a make run should compile and run your code and open up a
Gnuplot window with the resulting graphics; for me it looks like this:

Congratulations, you've just done your first tortoise-graphics! Still, we
don't want to fix and compile the instructions directly with our C code as
we just did; instead, the user should be able to interactively control the
tortoise.

3 Becoming Guiled

This is where Guile comes into play. Without it, we could write some additional
code that reads, parses and interprets commands to the tortoise, calling the
appropriate tortoise primitives as already defined.

Sounds not too bad? Well, probably it isn't. But in the C code we also used a
loop to draw the square – otherwise we would have had to repeat the same two
lines (movement and turn) four times. And what if we wanted to draw a polygon
with, say, 1024 vertices? I hope you are convinced now that to make our tool
really useful, we also needed to implement some means of looping.

Hm, while we're at it: Our tortoise-package can also be used to build up
a Koch's curve quite elegantly using recursion (try a quick internet search if
you can't wait until I'll come back to it in more detail later) – so want to
implement some sort of procedures that can recursively call themselves?

All in all, we were probably going to implement a full-fledged tortoise
programming language – but think about it: Has this
anything to do with our original application and goal? I hate to spoil you
all the fun (writing programming languages can be quite fun), but no, it hasn't.

Luckily, we need not go through all this effort; Guile already provides a
perfectly good way of making our tortoise programmable. Scheme should be
quite a good language to perform all we want (loops, procedures, recursion)
– and much more.
We just need to link our tortoise to the Guile-world, which will be the topic
of the next sections.

3.1 Adding Guile

First, let's add Guile to our code; you need to #include <libguile.h>
as the “master header”. In our main routine, take out again the
temporary test code we used to produce the first output, and replace it
instead by these lines:

scm_with_guile (&register_functions, NULL);
scm_shell (argc, argv);

scm_with_guile may be a bit weird at first glance; what it does is
calling the provided routine (register_functions – we'll create it
in a few moments). Additionally, it also “activates” Guile during this
call, so that
other Guile library functions can be called from within
register_functions. Don't worry about what exactly goes on there, you
just need to remember that this indirection is necessary if you want to work
with Guile.

(As a side-note: There's also a scm_init_guile method that
does this “activation” directly and without this peculiar call-back; it may
seem more reasonable and easy-to-understand to you, and you can well use that
one instead. However, Guile recommends using scm_with_guile for better
portability where possible.)

The call to scm_shell actually runs the Guile REPL (Read-Evaluate-Print
Loop, that shell-like command prompt for interactive Scheme evaluation you
also get when starting up guile directly) – the idea is to do all
the initialization we need for our application, and finally run the REPL,
where the user can then enter her commands in Scheme code. Actually, this
routine does a little more: It also processes the command-line arguments given
to our tortoise-program in the way guile handles its arguments;
for instance, you can then do tortoise -s foobar.scm and have your
commands read from foobar.scm. That's why we need to pass it
argc and argv, in case you were interested.

scm_shell does not return, but rather keep on until the user closes
the REPL; then our tortoise-program will also finish as a whole.
Do you remember that I still owe you an explanation why using the Gtk+ toolkit
for graphics would have been more complicated than Gnuplot? The reason I
decided against Gtk+ is that for the Gtk+ toolkit you do something similar:
After your program's initialization, you call out to a Gtk+ main loop that
will process incoming events and also never fully return control to your
program – but in this case, we can't run both Gtk+'s main loop and
the Guile REPL; at least not without writing a multi-threaded application.
That would have been again some unnecessary complication; I hope you
agree with me now... But if not, just go ahead and try converting our
package to Gtk+! I guess that's an interesting exercise.

Finally, we still have to create register_functions:

static void*
register_functions (void* data)
{
return NULL;
}

You're right, it's not really interesting or even useful for now, but we'll fill
it in later. Notice the two void*? The argument data gets
passed whatever we want from scm_with_guile – that's why there's
NULL as second argument in the call, but we could make it a pointer to
an integer or even a large struct in case we needed to pass some data to
register_functions. In turn, the return value of
register_functions, which is also NULL in this case but could be
anything as complex as you want, is returned from scm_with_guile –
something we also don't need.

3.2 Compiling with Guile

Once again, we'll try to compile and run what we have so far. To do so, we
have to tell the compiler where to look for libguile.h as well as the
linker to include libguile. You can work out the appropriate flags
for yourself, but the utility guile-config that comes with Guile
can do it for you.

So all we need to do is update the Makefile like this (and now the variables
get some meaning!):

CFLAGS = `guile-config compile`
LIBS = `guile-config link`

With these adaptions, you should be able to compile and run the program again.
This time, the Gnuplot window that pops up should just be empty (and stay so),
but on the command-line a Guile REPL will be available just as if you had
started guile yourself.

You can do some Scheme programming, but so far nothing to use our little
tortoise at all:

That's quite nice, isn't it? Still, without control over the tortoise, it does
not make sense at all; you can just use guile directly without all
the effort we went through if you want to program in Scheme. But we can fix
this easily.

3.3 Adding the Tortoise

As I've promised, we'll integrate the tortoise into the Guile environment now.
We can simply tell Guile to make our tortoise-procedures available from
Scheme with scm_c_define_gsubr; these need to be called from within
the activated “Guile mode”, so we add the calls to register_functions:

The first arguments are the Scheme-names for the procedures we're going to
register, the last arguments pointers to the C functions that implement them.
The numbers inbetween define the number of arguments the procedures take,
namely required, optional and whether there's a rest-list argument nor not –
in our case, there are neither optional arguments nor rest-lists, but
tortoise-turn and tortoise-move take one required
argument (the angle or distance, respectively).

Unfortunatly, this is only one half of the changes needed; Guile represents
all Scheme values with the SCM type, and thus both the return values and
argument-types of the C procedures need to be SCM's. In order to get the
double values out, we need some Guile API functions; our
tortoise procedures become:

You've already guessed it, scm_to_double gets the value “out of” a
Scheme number (if it is a number at all, but we won't care about this and
assume we're only fed correct arguments).

You also noticed for sure that I made our procedures return some “reasonable”
values, using some other Guile API stuff: SCM_UNSPECIFIED means just
that there's no return value (like void in C). If you define a
procedure that has no meaningful result, you at least need to return
SCM_UNSPECIFIED from it to make Guile happy (and assert this fact).

The penup
and pendown commands return (as a Scheme boolean, created by
scm_from_bool) the state of the pen before the requested change.

turn and move return the new direction and coordinate
(as a Scheme list with two entries), respectively – of course, you already
know what scm_from_double and scm_list_2 do, right?

Congratulations, now we've managed to build the whole tortoise package with
Guile! And left is all the fun working with it...

3.4 Having Fun with our Tortoise

Recompile the program (should be easy thanks to our neat Makefile) and run it.
Once again, you should get the Guile (Tortoise!) REPL, but now our procedures
should really be available. Try out all of the functionality with a session
like this:

(I won't include the expected graphics output, just see for yourself...) I
hope everything works for you, too. If not, it's the perfect time to go back
to the code and try to find what's going wrong... Otherwise, let's have some
fun and do real programming with our tortoise!

For instance, we can automate the task of drawing polygons with a Scheme
function; try out this code:

Remember that I promised you something about Koch's curve? Now we're going to
construct it, using a recursive function. See for instance
http://en.wikipedia.org/wiki/Koch_curve for details about what Koch's
curve is. Anyways, here comes the code; try to find out how it works, if you
want:

Are you impressed? I hope at least a little so... Unfortunatly, the
Gnuplot-over-a-pipe approach is quite slow (at least on my system), so you
could probably have been even more impressed if the graphics would have been
there more quickly; but anyways, at least I like this very much! Regarding the
Scheme code, I won't comment it further, as not to spoil all your fun
thinking about it. I encourage you to do so, I like this recursive
construction very much. Oh, and here's my resulting plot:

Looks quite interesting, doesn't it? By the way, this is also for me the first
time I constructed the “inverse” snowflake with “negative sign” – I don't
know if that's done in general, but I just wanted to know the result, so here
it is (the left half of the image, which got constructed by the second call).

4 Next Steps

I hope this introduction so far gave you an idea about what Guile can do for
you and how it basically works. For what I needed with my first Guile project,
the stuff so far was nearly enough; however, that was of course only the tip
of the iceberg, and there's a lot of things you could still
learn.

For instance, there are of course a whole lot of other functions in the
Guile library to work with Scheme objects; nearly any primitive that is
accessible from Scheme can be used from within a C procedure, also – there's
even a routine to capture continuations!

Starting up a REPL as we did is nice, but if you just want to run a user's
configuration script at start-up of your application and then continue with
your code, there are also routines that evaluate single Scheme commands or
even run a file and return afterwards.

And if you decided that one tortoise is not enough, you could introduce some
sort of “tortoise object” that can be created and passed to the various
routines. This would allow a user to control as many tortoises in parallel as
she wants – such
a user-defined Scheme object is called a SMOB in Guile and is of
course also easy to realize.

If you ever really need any of the stuff I mentioned or are just curious about
what else you can do, I strongly suggest you browse the
Guile Reference Manual.
Surely you can find all you need (and much more) there! And if you need
further help, try asking on the
Mailing Lists.

I want to thank David Drysdale for his own “Tutorial Introduction to Guile”,
upon which this document is largly based (in fact, mostly a rewrite of with
some updates and – as I see it, of course – improvements).

Finally, I hope my write-up was useful to you; in case you have any comments,
suggestions, tips or just want to drop me some note whatsoever, I look forward
to receiving a message. You can contact me as Daniel Kraft,
d@domob.eu. Good luck with Guile and hopefully you also enjoyed
reading through this tutorial a little bit!