Tutorial I

Gamma: Version 4.0
Prev |  | Next

# Chapter 4. Tutorial I

This tutorial contains examples of the basic types and mechanisms of Gamma. The first example shows you how to manipulate lists. A list is a very important data type in Gamma. The understanding of list manipulation is a key notion to many of Gamma's constructions. The second example walks you through the famous "Hello world" program.

# 4.1. Lists

The examples below demonstrate some of the basics of list manipulation. Since Gamma uses the Lisp engine, it inherits the rich set of list functions for which Lisp is known.

        /* The program starts with the line containing the shell's
        directive #!. It makes a Gamma program appear to be a
        stand_alone executable to the user. The directive must appear
        as the first line and must reference the actual Gamma
        executable, not a link.  */

        #!/usr/cogent/bin/gamma

        /*
         * Lisp defines the functions 'car', 'cdr', and 'cons' as the basic
         * list manipulation functions.  The origins of these names have no
         * meaning on today's computers:
         *	CAR	- Contents of the Address Register
         *	CDR	- Contents of the Decrement Register
         *	CONS	- Construct (OK, this makes sense)
         *
         * We can define alternate names for car and cdr here:
         */

        head := car;
        tail := cdr;

        /*
         * Create some lists.
         */

        a = list ("My", "dog", "has", "fleas");
        b = list (1, 2, 3, 4, 5, 6);

        /* The pound sign "#" in front of a symbol prevents Gamma
        from evaluating the symbol so the symbol is taken literally.
        Thus, if x = 5, then the function call list (#x, 1) will
        create the list (x 1) rather than (5 1).
         */

        c = list (#a, #b, #c, #d, #e, #f);
        d = list (#d, #h, #b, #i, #g, #e, #c);

        /*
         * Take the first component of a list.
         */

        e = head (a);
        princ ("The first component of ", a, " is ", e, "\n");

        /*
         * Take the tail of a list.
         */

        e = tail (a);
        princ ("\nThe tail of ", a, " is ", e, "\n");

        /*
         * Concatenate two lists.  Notice that list elements do not need to be the
         * same type.
         */

        e = append (a, b);
        princ ("\nappending ", b, " to ", a, " gives:\n	", e, "\n");

        /*
         * Walk a list and print each element
         */

        princ ("\nThe elements of 'a' are:\n");
        with i in a do
        {
            princ ("	", i, "\n");
        }

        /*
         * Add an element to the beginning of a list
         */

        princ ("\nAdding a zero to ", b, "\n");
        b = cons (0, b);
        princ ("    Gives: ", b, "\n");

        /*
         * Take the first element of the tail of the list (the second element)
         * We can use combinations of car and cdr to do this.  However, Gamma
         * predefines a number of car and cdr combinations to make this easier,
         * by inserting multiple 'a's and 'd's between the 'c' and the 'r' in
         * the words car and cdr.
         * For example,   caddr(x)    is the same as    car(cdr(cdr(x)))
         *
         * Gamma defines all one_, two_, and three_letter combinations of
         * car and cdr.
         */

        princ ("\na is ", a, "\n");
        x = car (cdr (a));
        princ ("    car(cdr(a)) is: ", x, "\n");
        x = cadr (a);
        princ ("    cadr(a) is: ", x, "\n");

        /*
         * Some other interesting list functions...
         */

        princ ("\n");
        princ ("Union of        ", c, " and ", d, " is ", union (c, d), "\n");
        princ ("Intersection of ", c, " and ", d, " is ", intersection (c, d), "\n");
        princ ("Difference of   ", c, " and ", d, " is ", difference (c, d), "\n");
        princ ("Difference of   ", d, " and ", c, " is ", difference (d, c), "\n");

Prev | Home | Next
Memory Management | Up | "Hello world" program

Copyright 1995-2002 by Cogent Real-Time Systems, Inc.