Lisp Tutorial | MAPCAR and LAMBDA in Lisp

Applicative Programming in Lisp
Usually, the input to a Lisp function is some sort of data.

Functions are data too, so applicative programming takes this idea and uses Lisp functions in the same way other data: as inputs to other functions and functions returned as values. Today's Programming Lisp Tutorial introduces Applicative Programming in Lisp, MAPCAR and LAMBDA.

And of course we have the answer to the Lisp Programming Challenge from our last post.

Yet More Recursion in Lisp

Our last Lisp tutorial looked at using recursion to access data from nested lists. Today's Lisp tutorial looks at more Lisp recursion techniques. Firstly let's look at the Lisp Programming Challenge from our last Lisp recursion post:

(defun get-orbit (planet-list)
  (if (null planet-list) nil
    (cons (second (first planet-list))
          (get-orbit (rest planet-list)))))

(defun get-diameter (planet-list)
  (if (null planet-list) nil
    (cons (third (first planet-list))
          (get-diameter (rest planet-list)))))

(defun get-mass (planet-list)
  (if (null planet-list) nil
    (cons (fourth (first planet-list))
          (get-mass (rest planet-list)))))

More Recursion in Lisp
There are certain functions that we usually apply to numbers and cannot apply to lists for example:
(/ 8 2)
4

Whereas the following will create an error:
(/9 '(2 3 4))

If, as in the above example, we wanted to divide a list of numbers by another number we could write a recursive function to do this:

(defun divide-list-by-x (the-list x) 
    (if (null the-list) nil      
      (cons (/ (first the-list) x)     
      (divide-list-by-x (rest the-list) x))))

(divide-list-by-x '(2 3 4) 2)
(1 3/2 2)

Similarly we could write a recursive Lisp function to perform the modulus function on a list of numbers:

(defun list-mod (the-list mod)
         (if (null the-list) nil
           (cons (mod (first the-list) mod)
                 (list-mod (rest the-list) mod))))

 When writing recursive Lisp functions we need to be able to define the following 3 things:

    * When to stop recursing
    * How do we take the next step
    * How to call the recursive function

The two recursive Lisp examples above use a single test to identify when to stop recursing, however we can also use two (or more) tests to identify when the recursive function should stop. In this example, we check to see if a given number is less than every number in a list by writing a recursive function. The function stops recursing if it reaches the end of the list, or if the function encounters a number that is equal to or greater than our test number:

(defun less-than-list (x the-list) 
   (cond ((null the-list) t)       
             ((>= x (first the-list)) nil)       
             (t (less-than-list x (rest the-list)))))

Today's Programming Lisp Challenge
Lisp has many different data types. Write a function to extract the numbers from this list:

(1 Partridge 2 Turtle Doves 3 French Hens 4 Calling Birds 5 Gold Rings)

So:
(extract-numbers '(1 Partridge 2 Turtle Doves 3 French Hens 4 Calling Birds 5 Gold Rings))

should return:

(1 2 3 4 5)

Subscribe to the RSS feed and check back soon for the answer and more Programming Lisp tutorials.

Lisp Tutorial | More Recursion in Lisp

Our last Lisp Tutorial introduced the idea of recursion in Lisp. Today we're looking at more recursive Lisp functions but first let's look at the answer to yesterday's Lisp challenge. 

Lisp Tutorial Answer
Write a function called INCREASING-P this function returns T if all the numbers in the list are in ascending order and NIL if they are not.

As a reminder, when writing recursive Lisp functions we need to be able to define the following 3 things:

• When to stop recursing
• How do we take the next step
• How to call the recursive function
  

In the example of our INCREASING-P function we:

• Stop recursing when we get to the last two elements of the list
• Compare the first 2 elements of the list to see if the second is greater
• Call the recursive function with the REST of the list

(defun increasing-p (the-list)
  (cond ((null (rest the-list)) t)
        ((< (first the-list) (second the-list))
         (increasing-p (rest the-list)))
        (t nil)))

Defining Variables
Before we look further at recursion we're going to define a GLOBAL VARIABLE. Global variables can be evaluated by all functions, this contrasts with LET and LET* which defined variables that were only valid inside that function.

To define a global variable we can use DEFVAR function for example:
(defvar *simpsons* '(homer marge lisa bart maggie))

Note, it's not necessary to though it is common practice and recommended to identify global variables with * around them like *this*

Now when we evaluate this variable we can see its contents:
*simpsons*
(HOMER MARGE LISA BART MAGGIE)

More Recursion in Lisp

Let's define a global variable called *planets*, In this variable we'll store a nested list of attributes of the planet

• planet-name 
• orbit(AU) 
• diameter(km) 
• mass(kg)

;planet-name orbit(AU) diameter(km) mass(kg)
(defvar *planets* '((mercury 0.38 4880 3.30e23)
                      (venus .72 12103.6 4.869e24)
                      (earth 1 12756.3 5.972e24)
                      (mars 1.52 6794 6.4219e23kg)
                      (jupiter 5.2 142984 1.900e27)
                      (saturn 9.54 120536 5.68e26)
                      (uranus 19.218 51118 8.63e25)
                      (neptune 30.06 49532 1.0247e26)
                      (pluto 39.5 2274 1.27e22)))

Copy, paste and evaluate the above in your Lisp environment.

If we want to create a list of the planet names we need to take the first element of each list. As our *planets* variable is a nested list, the FIRST of *planets* evaluates to this:

(first *planets*)
(MERCURY 0.38 4880 3.3E23)

To get the planets name we need to take the FIRST of this list, so the FIRST of the FIRST of *planets*:
(first (first *planets*))
MERCURY

To create a full list of our planets names we can use recursion, firstly we need to answer our three important questions:

• When to stop recursing?
• When we reach the end of the list
• How do we take the next step
• CONS the FIRST of the FIRST of *planets* 
• How to call the recursive function
• With the REST of *planets*

(defun get-names (planet-list)
  (if (null planet-list) nil
    (cons (first (first planet-list))
          (get-names (rest planet-list)))))

(get-names *planets*)
(MERCURY VENUS EARTH MARS JUPITER SATURN URANUS NEPTUNE PLUTO)

Today's Programming Lisp Challenge
Write GET-ORBIT, GET-DIAMETER, GET-MASS functions that creates a list of orbits, diameter and masses.

Subscribe to the RSS feed and check back soon for the answer and more Programming Lisp tutorials.

Lisp Recursion Tutorial | Recursion in Lisp

Today's Programming Lisp tutorial looks at recursion. Recursion is a very powerful programming tool in Lisp, but before we being let's have a look at the answer to the last programming lisp challenge.

Write a function called BETWEEN that takes 3 input arguments N, MIN and MAX. This function tests to see if N is between MIN and MAX.

(defun between (n min max)
  (if (and (>= n min)
           (<= n max)) t nil))

And with some example input:

(between 6 3 9)
T

(between 2 3 9)
NIL

Recursion in Lisp
Recursion is when a function calls itself. The best way to introduce it is to look at some examples. we've looked at predicates before: the ODDP predicate tests to see if a number is odd however this predicate only works with numbers and not lists. We can use a recursive function (a function that calls itself) to see if there are any odd numbers in the list.

(defun any-odd (the-list)
                  (cond ((null the-list) nil)
                        ((oddp (first the-list)) t)
                         (t (any-odd (rest the-list)))))


The above function illustrates some important features of programming recursive features, here's a line by line break down:

this line defines the function's name as any-odd and its input as the-list:

(defun any-odd (the-list)

This line uses COND to setup a conditional test, (null the-list) checks to see if we're reached the end of the list, if we have it returns nil, if not we go on to the next line of our conditional statement:

(cond ((null the-list) nil)

This line takes the first item of the-list and uses this as the input to ODDP, if ODDP is true we return T:

((oddp (first the-list)) t)

The final line is only evaluated if the previous lines evaluated to nil. This is were the function becomes recursive - it calls itself. Our ANY-ODD function is called with the REST of the list. 

(t (any-odd (rest the-list)))))

Here's another example, this time we'll take a number and a list as input, and check to see if the number appears in the list:

(defun n-in-list (n the-list)
                      (cond ((null the-list) nil)
                        ((equalp n (first the-list)) t)
                         (t (n-in-list n (rest the-list)))))

When programming recursive functions in Lisp we have to know:

• When to stop recursing - in both of the above examples we return nil when we reach the end of the list (null the-list)
• How do we take the next step? This is usually the body of the recursive function. In our ANY-ODD function our step was to test the first item of the list to see if it was ODD, in our N-IN-LIST function, our step was to use the EQUALP predicate and see if N was equal to the FIRST element of the-list
• How to call the recursive function? In the ANY-ODD function above, the function calls itself with the REST of the list. With the N-IN-LIST function, the function calls itself with N and the REST of the-list.

Today's Programming Lisp Challenge
Write a function called INCREASING-P this function returns T if all the numbers in the list are in ascending order and NIL if they are not.

Subscribe to the RSS feed and check back soon for the answer and more Programming Lisp tutorials.

Using AND NOT and OR in Lisp

Today's Lisp tutorial looks at using AND NOT and OR in Lisp, but firstly let's have a look at the answer to the challenge set in our last Lisp tutorial Using LET in Lisp:

Write a Lisp function called GUESS, where you try and guess the number thrown by a dice, this will have several parts.This function will randomly choose from 6 possibilities. You call the function with your guess of 1, 2, 3, 4 5 or 6, the function randomly chooses 6 choices and tells you if your guess was right or wrong.

(defun guess (n)
  (let ((dice (+ 1 (random 6))))
    (cond ((equalp dice n )  (list  'you 'guessed 'right 'it 'was dice))
          (t (list 'you 'guessed 'wrong 'it 'was dice)))))

The NOT Predicate in Lisp
We've looked at predicates in Lisp in a previous Lisp tutorial post. Predicates return T or  NIL if the statement is true or false. In Lisp T is true and NIL is false. Using NOT turns T into NIL and NIL into T.

For example using the ZEROP predicate we can test if the number is zero:
(zerop 4)
NIL


(zerop 0)
T

Using NOT we can check to see if a number is not zero:

(not (zerop 4))
T

(not (zerop 0))
NIL

The AND Predicate in Lisp
The AND Predicate in Lisp takes two inputs, both of these must be true for it to evaluate and return T otherwise it returns NIL.
(and (> 6 4) (< 1 3))
T

Here only one of our predicates is true:
(and (numberp 6) (equalp 1 9))
NIL

The OR Predicate in Lisp

The OR Predicate in Lisp returns T if either one or both arguments are true:

(or (numberp 6) (equalp 1 9))
T

(or (> 7 6) (equalp 1 1))
T

Today's Lisp Challenge
Write a function called BETWEEN that takes 3 input arguments N, MIN and MAX. This function tests to see if N is between MIN and MAX.

Subscribe to Programming Lisp Tutorial Blog and check back to see the solution!

Using LET in LISP

Today we're looking at using LET, but firstly let's look at the answer to our last Lisp tutorial: Write a function called MY-COMPARE using COND that will take two numbers as input and return one of these statements as appropriate:

THE FIRST NUMBER IS LARGER
THE SECOND NUMBER IS LARGER
THE TWO NUMBERS ARE EQUAL

(defun my-compare (x y)
    (cond ((> x y) '(the first number is larger))
          ((< x y) '(the second number is larger))
           (t '(the two numbers are equal))))

Using Let in Lisp

Let creates a local variable: a variable that is only valid inside the function. One common use is to avoid performing the same function over and over again. For example if we need the square of a number several times, we could calculate it once and give it a name rather than calculating it every time:

(defun my-square (x)

  (let ((the-square (* x x)))

   (list 'the 'square 'of x ’is the-square x 'multiplied 'by x 'is the-square)))

One of the best ways to learn is to look at lots of examples. Here's another example that uses LET and calculates the average of two numbers:

(defun average (x y)
       (let ((sum (+ x y)))
           (list x y ’average ’is (/ sum 2.0))))

So far our examples have only used one local variable, we can use LET to specify multiple local variables:

(defun sum-and-difference (x y)
                 (let ((sum (+ x y))
                   (difference (- x y)))
                   (list 'the 'sum 'of x 'and y 'is sum 'the 'difference 'is difference)))

This Lisp let example asks the user to enter a number and uses the NUMBERP predicate to check that what has been entered is a number. If the answer is a number it returns val (which is the number), if NUMBERP returns NIL then the asknumber function is called again.
(defun ask-number ()
  (format t "Please enter a number. ")
  (let ((val (read)))
    (if (numberp val)
        val
        (ask-number)))) 

Here is the general form of LET in Lisp:

(LET ((var-1 value-1)

       (var-2 value-2)

...

       (var-n value-n))

  body)

LET* in Lisp

The LET* creates the local variables one at a time rather than all at once. This means that one local variable can refer to another.

(defun price-change (old new)
  (let* ((diff (- new old))
   (proportion (/ diff old))
   (percentage (* proportion 100.0)))
   (list ’widgets ’changed ’by percentage ’percent))) 

Summary
Using LET and LET* functions in Lisp allow us to create local variables.

Today's Lisp Challenge
Write a Lisp function called GUESS, where you try and guess the number thrown by a dice, this will have several parts.This function will randomly choose from 6 possibilities. You call the function with your guess of 1, 2, 3, 4 5 or 6, the function randomly chooses 6 choices and tells you if your guess was right or wrong.

There are several steps to solving this problem. Any time you have a programming challenge with several steps, break it down into the individual tasks and get these working one by one. Make divide and conquer your programming mantra!

1. The RANDOM function in Lisp returns a random number between 0 and n-1. For example
(random 2) returns one of two possibilities, either 0 or 1. Try evaluating the RANDOM function in your version of Common Lisp.
2. Start writing your GUESS function, by getting it to return either 0, 1, 2, 3, 4 or 5. Then add 1 to the result to get the numbers one to 6.
3. Use LET  to store this random result as a local variable called dice.
3. Use COND to check whether the guess of matches the result ofour local variable dice.
4. If the guess is right return: YOU GUESSED RIGHT IT WAS [put the local variable dice here]
5. If the guess was wrong return: YOU GUESSED WRONG IT WAS [put the local variable dice here]

There are a few steps involved in this, get them working one by one and check back tomorrow for the answer and more programming Lisp tutorials.

Using COND in Common Lisp

Our last post looked at IF THEN statements using the IF function in Lisp. Here's the answer to the challenge set in that post, to write a MY-ABSOLUTE function using an IF function:

(defun my-absolute (x)
              (if (>= x 0) x
                (* -1 x)))

COND

It's possible to use multiple IF functions but if you have lots of things to test it can be more convenient to use a COND function.

COND is a conditional function. It consists of any number of
test and consequent clauses.

(COND (first-test first-consequent)
(second-test second-consequent)
....
(last-test last-consequent))

COND works by progressing through each clause in turn. If the test part is true, COND evaluates the consequent part and returns its value, it does not evaluate any further clauses.

If the test evaluates to NIL (false), COND jumps to the next clause. If all clauses are false, COND returns NIL.

Here's an example COND function:

(defun what-is (x)
  (cond ((equal x ’apple) ’fruit)
    ((equal x ’asparagus) ’vegetable)
    ((equal x ’pork-chop) ’meat)
    (t ’unknown)))

As shown in the example above, it's useful to put a T as the last COND clause. This allows you to return a value or perform another task if all of the preceeding clauses are false.

Today's Challenge:
Write a function called MY-COMPARE using COND that will take two numbers as input and return one of these statements as appropriate:

THE FIRST NUMBER IS LARGER
THE SECOND NUMBER IS LARGER
THE TWO NUMBERS ARE EQUAL

If.. then.. else..

Previously we looked at using a predicates to test whether something was TRUE or FALSE, on in Lisp T or NIL:


(oddp 5)
T

Predicates can form part of an IF THEN statement: if something is true then do something.
The IF function takes three arguments: a test, a true part, and a
false part.

For example, using the ODDP function to test if a number is odd and then returning a statement|:

(if (oddp 3) '(the number is odd) '(the number is even))
(THE NUMBER IS ODD)

(if (oddp 4) '(the number is odd) '(the number is even))
(THE NUMBER IS EVEN)

As well as returning simple statements as in the above example, we can also get Lisp to perform further functions is a test is T or nil. This function for example:

• takes a single number (n) as its input argument.
• tests to see if a number is odd using the ODDP function,
• if the number is odd we add 1 to it to make it even,
• if the ODDP test returns NIL we simply return our original odd number.

;make odd
(defun make-odd (n)
  (if (evenp n) ; the test
      (+ 1 n) ;the true statement
    n)) ; the false statement

Today's Challenge
Write a function in Lisp called MY-ABSOLUTE that returns the absolute value of a number. Absolute values are always non-negative. For negative numbers the absolute value multiply the number by -1; for zero and positive numbers the absolute value is the number itself.

Remember the IF function takes three arguments:

• a test
• a true part, and a
• false part

We'll post the answer in our next http://programminglisp.blogspot.com/ blogpost.

Lists in Lisp

Lists are are one of Lisp's most flexible and powerful data types. Here are some examples of lists:

(red orange yellow green blue indigo violet)

(10 green bottles)

(9 18 27 36 45 54 63 72 81 90 99 108)

(thisisalist)

((a)(list of) (lists))

To get the length of a list, we can use the LENGTH function. We have to put the quote mark ' in front of each word here, otherwise Lisp would try to evaluate or understand what we mean:

length '(red orange yellow green blue indigo violet))

7

(length '(10 green bottles))

3

(length '(9 18 27 36 45 54 63 72 81 90 99 108))

12

(length '(thisisalist))

1

(length '((a)(list of) (lists)))

3

As you can see from the final example, lists can contain other lists. The elements of the list are the things that appear inside only one level of parentheses, so in the final example the LENGTH function returns 3 because there are only 3 elements to the list:

(a)

(list of)

(lists)

As we saw briefly in the first steps with Lisp post we can extract individual elements from lists using these functions:

(first '(a b c d e))
A

(second '(a b c d e))
B

(third '(a b c d e))
C

(rest '(a b c d e))
(B C D E)

(last '(a b c d e))
(E) 

(first (first '((a)(list of) (lists))))

A

Creating a new list is very easy using the LIST function:

(list 'banana)

(banana) 

(list 'water 'malt 'hops 'yeast)
(WATER MALT HOPS YEAST)

Again we have to put the quote mark ' in front of each word here, otherwise Lisp would try to evaluate or understand what we mean by water, malt, hops and yeast i.e. had we assigned values to these.

We'll look more at using, creating and extracting data from lists in future posts.

Using Cons To Create Lists In Lisp

Today's post looks at creating lists in Lisp. Before we do that let's have a look at the answer to yesterday's post:

Write a function called square-odd-p. This function takes a single number as input, it squares this number and tests to see if the square of the number is odd.

(defun square-odd-p (x)
   (oddp (* x x)))

Creating Lists in Lisp
cons is a Common Lisp primitive, that creates lists from an atom
(number or letter) and a list:

(cons 1 '(2 3))
(1 2 3)

 We'll use cons to help us write a function to replace the first member of a list. In order to do this we'll:

• Have to take two inputs to our function: the new item and the list
• We'll use the rest function to return everything but the first member of the list
• We can then cons our new item to the start of this list:

(defun replace-first (new-item the-list)
   (cons new-item (rest the-list)))

And an example:

(replace-first 'peter-pan '(one flew over the cuckoos nest))
   (PETER-PAN FLEW OVER THE CUCKOOS NEST)

In the next post we'll look at some more examples of building and manipulating lists.

Predicates In Lisp

Today we're looking at predicates. Predicates are tests that we can use to see if something is true or false.

Before we do that let's look at the answers from yesterday:

(defun minus-one (x)
   (- x 1))

(defun ten-times-bigger (x)
   (* x 10))

(defun weeks-to-days (weeks)
   (* weeks 7))

It doesn't matter if you called weeks x or something entirely different, it is often useful to give our arguments names that are useful.

Predicates
As mentioned earlier predicates are tests that return either True or False. In lisp:

T = True
Nil = False

Here are some examples:

oddp checks to see if a number is odd:

(oddp 5)
T

(oddp 6)
NIL

evenp checks to see if a number is even:

(evenp 5)
NIL

(evenp 6)
T

Here are some other common predicates with examples:
(zerop 0)
T

(= 3 4)
NIL

(> 3 4)
NIL

(< 5 10)
T



Predicate Summary

• (evenp n) true if n is even
• (floatp n) true if n is a floating point number
• (integerp n) true if n is an integer
• (minusp n) true if n is less than zero
• (numberp n) true if n is a number 
• (oddp n) true if n is an odd number (0 is considered even) 
• (plusp n) true if n is greater than 0 
• (zerop n) true if n is 0
• (> x y) true if x is greater than y
• (< x y) true if x is less than y
• (>= x y) true if x is greater than or equal to y
• (<= x y) true if x is less than or equal to y

Using Predicates In Functions
In yesterday's post we wrote our own functions. We can include predicates in these functions. For example, this function adds two numbers together and checks to see if the result is even, again we could all it almost anything but as it's a predicate that check to see if the sum of two numbers is even we'll call it sum-even-p:

(defun sum-even-p (x y)
   (evenp (+ x y)))


Notice the order of the function

    (evenp (+ x y)))

the input element to evenp is the + function and x y


Today's Challenge
Today's challenge write a function called square-odd-p. This function takes a single number as input, it squares this number and tests to see if the square of the number is odd.

Check tomorrow's post for the answer and more Lisp tutorials.

Writing A Function In Lisp

There are a large number of built in functions in Lisp, it's also possible, useful and very easy to write your own functions in Lisp. Have a look at this function:

(defun my-square (x)
(* x x))

Let's break this down:

defun is a function used to define new functions.
my-square is the name that we've given to our function, we could call it almost anything we like but it makes to give it a useful name so that we can remember it later.
x is the argument or input to our function. Again we could call this almost anything we like.
(* x x) This is where the actual work of our function takes place, we using the multiply function and multiplying x by itself.

When you have written and evaluated this function, it can be called and used just any other function:
(my-square 5)
25

(my-square 9)
81

It's good practice to comment your function, both so that others can understand it quickly and easily and for yourself.

(defun my-square (x)
 "this function squares an input number x"
(* x x))

Using double quotes " " adds a definition to your function, these can only be used after you have defined the input arguments.

A more versatile way of adding comments that can be used anywhere is to use semicolons, anything after the semicolon is ignored:

(defun my-square (x)
 "this function squares an input number x"

(* x x)) ; this line squares x

We'll work more on writing new functions tomorrow, for now see if you can write these functions, answers in tomorrow's post:

minus-one a function that takes a single number as input and returns the number that is one less
ten-times-bigger a function that takes a single number as input and returns the number that is ten times bigger
weeks-to-days a function that takes a number of weeks as input and returns the total number of equivalent days

These examples may seem simple, however this is a really good stepping stone to learn how to build much more powerful functions in Lisp. Answers and more on building functions tomorrow...

First Steps With Lisp

Assuming you've followed yesterday's post and installed a version of Common Lisp, today we'll look at some first steps in learning Lisp.

We'll discuss background ideas and other useful theory in future posts, but for now we'll dive straight in and get our hands dirty with some Lisp programming.

1. Open your Lisp listener window, if it's not all ready showing, look for 'Listener' under your window menu.

2. As you would expect, Lisp can perform all sorts of mathematical operations, type this into your listener:
(+ 2 3)

It should of course return 5. There are a couple of useful points here:
-The function always come first
-The function and its arguments are surrounded by ()

3. Here are some more examples:
(+ 2 4 5 6)
17

(* 10 9)
90

(- 10 2.5)
7.5

and so on...
4. These operations can be nested inside one another for example:
(+ 1 (* 3 3))
10
The inner parentheses get evaluated first.

5. Aside from mathematical functions, many function access data. For example:
(first '(a b c d e))
A

6. The function 'first' returns the first item of a list. There are many other similar functions for accessing data:
(second '(a b c d e))
B

(third '(a b c d e))
C

(rest '(a b c d e))
(B C D E)

(last '(a b c d e))
(E)

7. The ' quote mark stops the Lisp from trying to evaluate the list (from trying to interpret what the list means - we could have for example assigned values to these letters).

Tomorrow we'll start building our own functions, but for now get used to using these functions in your version of Lisp

Learning Lisp

Lisp (an acronym for List Processing) is a powerful programming language designed to create other computer programs. The most used form of Lisp today is Common Lisp, it's available on every computer platform and uniform in use through a standard reference manual.

To start programming with LISP you need to install an integrated development environment (IDE). The good news is that there are many Common Lisp IDE's available for free:

Allegro Common Lisp a free version is available for Linux, Windows, Mac OSX and FreeBSD
Armed Bear Common Lisp (ABCL) a free open source implementation for Linux, Windows, Mac OSX and FreeBSD. Needs to be compiled before installing so possibly not the best choice for beginners.
CLISP available for Linux, Max OS X, Windows, xBSD, Solaris, Tru64, Solaris, HP-UX, BeOS, NeXTStep, IRIX, AIX
Lispworks a full commercial version and a free 'personal edition' are available for Macintosh, Linux, Windows and FreeBSD.
SBCL Steel Bank Common Lisp, a free open source implementation available for Linux, OSX, FreeBSD and with a version 'in progress' for Windows.

There is also a very good Lisp plugin called CUSP available for the Eclipse programming environment.

Choose and install a Lisp IDE for you platform and follow these Lisp tutorials and exercises to start learning Common Lisp today.