Skip to main content

Lisp Hello World

Introduction to Lisp Programming Language

What is Lisp?​

Lisp (short for LISt Processing) is a programming language that was designed in the late 1950s by John McCarthy. It is one of the oldest programming languages still in use today and is known for its unique syntax and powerful features. Lisp is a functional programming language that treats code as data, allowing programs to manipulate and generate other programs.

Lisp has influenced many other programming languages, including Python, Ruby, and JavaScript. It has been used in a wide range of applications, from artificial intelligence to web development.

History of Lisp​

Lisp was created by John McCarthy at the Massachusetts Institute of Technology (MIT) in the late 1950s. McCarthy wanted to develop a language that could be used for symbolic processing, as well as general-purpose programming. He introduced the concept of "S-expressions" (symbolic expressions) as the fundamental data structure in Lisp, which greatly simplified the language's syntax.

Over the years, Lisp has evolved and several dialects have been developed, including Common Lisp, Scheme, and Clojure. Common Lisp is the most widely used dialect and is the one we will focus on in this tutorial.

Features of Lisp​

Lisp has several distinctive features that set it apart from other programming languages:

  1. Code as data: In Lisp, programs can be manipulated as data. This allows for powerful metaprogramming capabilities, such as writing programs that generate other programs.

  2. Dynamic typing: Lisp is dynamically typed, meaning that variable types are determined at runtime. This allows for greater flexibility but may introduce some runtime errors.

  3. Automatic memory management: Lisp provides automatic memory management through garbage collection, relieving the programmer from managing memory manually.

  4. Functional programming: Lisp is a functional programming language, which means that functions are first-class citizens. Functions can be passed as arguments, returned as results, and assigned to variables.

  5. Macros: Lisp has a powerful macro system that allows for the creation of domain-specific languages and custom language constructs.

Hello World in Lisp​

Now let's dive into some Lisp code! Here's a simple "Hello, World!" program in Common Lisp:

(print "Hello, World!")

In this example, the print function is used to display the string "Hello, World!" on the console. The parentheses in Lisp are used to denote function calls, and the function name comes first.

Lisp Examples: From Hello World to More​

In this section, we will explore 10 simple examples in Lisp, starting with the classic "Hello World" program. Let's dive in!

Example 1: Hello World​

(defun hello-world ()
  (format t "Hello World!"))

(hello-world)

Explanation:

  • defun is used to define a function in Lisp.
  • In this example, we define a function called hello-world that prints the string "Hello World!" using the format function with the t argument, which represents the standard output.
  • Finally, we call the hello-world function to execute it.

Expected Output: 

Hello World!

Example 2: Addition​

(defun add (a b)
  (+ a b))

(format t "Enter two numbers: ")
(let ((num1 (read)))
  (format t "Enter the second number: ")
  (let ((num2 (read)))
    (format t "The sum is ~a" (add num1 num2))))

Explanation:

  • Here, we define a function called add that takes two arguments, a and b, and returns their sum.
  • We prompt the user to enter two numbers using the format function.
  • let is used to bind the input values to num1 and num2 variables.
  • Finally, we call the add function with num1 and num2 as arguments and print the result using format.

Expected Output: 

Enter two numbers: 
5
Enter the second number: 
7
The sum is 12

Example 3: Factorial​

(defun factorial (n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

(format t "Enter a number: ")
(let ((num (read)))
  (format t "The factorial of ~a is ~a" num (factorial num)))

Explanation:

  • The factorial function calculates the factorial of a given number n recursively.
  • If n is less than or equal to 1, the function returns 1. Otherwise, it multiplies n with the factorial of n-1.
  • We prompt the user to enter a number using format.
  • let is used to bind the input value to the num variable.
  • Finally, we call the factorial function with num as an argument and print the result using format.

Expected Output: 

Enter a number: 
6
The factorial of 6 is 720

Example 4: Fibonacci Sequence​

(defun fibonacci (n)
  (if (< n 2)
      n
      (+ (fibonacci (- n 1)) (fibonacci (- n 2)))))

(format t "Enter the length of the Fibonacci sequence: ")
(let ((length (read)))
  (format t "The Fibonacci sequence is:")
  (dotimes (i length)
    (format t " ~a" (fibonacci i)))))

Explanation:

  • The fibonacci function calculates the Fibonacci sequence for a given length n.
  • If n is less than 2, the function returns n. Otherwise, it calculates the sum of the previous two Fibonacci numbers.
  • We prompt the user to enter the length of the sequence using format.
  • let is used to bind the input value to the length variable.
  • We use dotimes to iterate i from 0 to length-1 and print the Fibonacci number at each iteration.

Expected Output: 

Enter the length of the Fibonacci sequence: 
8
The Fibonacci sequence is: 0 1 1 2 3 5 8 13

Example 5: String Reverse​

(defun reverse-string (str)
  (coerce (reverse (coerce str 'list)) 'string))

(format t "Enter a string: ")
(let ((input (read-line)))
  (format t "Reversed string: ~a" (reverse-string input)))

Explanation:

  • The reverse-string function reverses a given string str.
  • We convert the string to a list using coerce, reverse the list using reverse, and then convert it back to a string.
  • We prompt the user to enter a string using format.
  • let is used to bind the input value to the input variable.
  • Finally, we call the reverse-string function with input as an argument and print the reversed string.

Expected Output: 

Enter a string: 
Hello World
Reversed string: dlroW olleH

Example 6: List Manipulation​

(let ((list '(1 2 3 4 5)))
  (format t "Original list: ~a~%" list)
  (format t "Length of the list: ~a~%" (length list))
  (format t "First element: ~a~%" (first list))
  (format t "Last element: ~a~%" (last list))
  (format t "Rest of the list: ~a~%" (rest list))
  (format t "List without the first element: ~a~%" (cdr list)))

Explanation:

  • In this example, we demonstrate various list manipulations.
  • We define a list using (let ((list '(1 2 3 4 5))).
  • We use format to print the original list, length, first element, last element, rest of the list, and the list without the first element.

Expected Output: 

Original list: (1 2 3 4 5)
Length of the list: 5
First element: 1
Last element: 5
Rest of the list: (2 3 4 5)
List without the first element: (2 3 4 5)

Example 7: Sorting​

(let ((list '(5 3 1 4 2)))
  (format t "Original list: ~a~%" list)
  (format t "Sorted list: ~a~%" (sort list #'<)))

Explanation:

  • Here, we demonstrate sorting a list in ascending order.
  • We define an unsorted list using (let ((list '(5 3 1 4 2))).
  • We use format to print the original list and the sorted list using the sort function with the #'< argument, which represents the less than operator for sorting in ascending order.

Expected Output: 

Original list: (5 3 1 4 2)
Sorted list: (1 2 3 4 5)

Example 8: Conditional Statement​

(format t "Enter your age: ")
(let ((age (read)))
  (if (>= age 18)
      (format t "You are an adult.")
      (format t "You are a minor.")))

Explanation:

  • In this example, we prompt the user to enter their age and use a conditional statement (if) to determine if they are an adult or a minor.
  • We bind the input value to the age variable using let.
  • If the age is greater than or equal to 18, it prints "You are an adult." Otherwise, it prints "You are a minor."

Expected Output: 

Enter your age: 
25
You are an adult.

Example 9: Looping​

(dotimes (i 5)
  (format t "Iteration ~a~%" (1+ i)))

Explanation:

  • dotimes is used for looping a specific number of times.
  • In this example, we loop 5 times and print the iteration number using format and (1+ i) to increment i.

Expected Output: 

Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5

Example 10: Recursion​

(defun countdown (n)
  (if (<= n 0)
      (format t "Blastoff!")
      (progn
        (format t "~a " n)
        (countdown (- n 1)))))

(countdown 5)

Explanation:

  • The countdown function uses recursion to print a countdown from a given number n to 0.
  • If n is less than or equal to 0, it prints "Blastoff!" Otherwise, it prints the current number and recursively calls the countdown function with n-1.

Expected Output: 

5 4 3 2 1 Blastoff!

That concludes our examples in Lisp. Each example demonstrates different aspects of the language, ranging from basic I/O operations to more complex recursive functions.

Comparison with other languages​

Lisp's unique syntax and features make it stand out from other programming languages. Here are a few comparisons with popular languages:

  • Python: Lisp and Python both support functional programming paradigms, but Lisp has a more flexible syntax and more advanced metaprogramming capabilities through macros.

  • Ruby: Ruby is heavily influenced by Lisp and shares some of its features, such as closures and code blocks. However, Lisp has a simpler syntax and a more powerful macro system.

  • JavaScript: Lisp and JavaScript are both dynamically typed languages, but Lisp has a more expressive syntax and a more extensive set of built-in functions for list manipulation.

For more information on Lisp, you can visit the official Common Lisp website.

Now that you have a basic understanding of Lisp and its features, you can start exploring more complex concepts and diving deeper into the world of Lisp programming.