Home > Posts > Beginner's Guide to Racket

Beginner's Guide to Racket

  ·   14 min read

Introduction to Racket #

What is Racket? #

Racket is a programming language in the Lisp family, known for its powerful macro system, emphasis on language-oriented programming, and extensive library support. It’s designed to be both a practical language for building real-world applications and a powerful platform for experimenting with and extending programming language concepts. Racket’s design promotes creating and using domain-specific languages (DSLs) tailored to particular tasks, making it a flexible choice for various programming paradigms. Unlike many other Lisps, Racket emphasizes practicality and ease of use, especially for beginners.

Why learn Racket? #

Learning Racket offers several advantages:

  • Gentle Learning Curve: Racket’s syntax is relatively straightforward, and its interactive interpreter makes experimentation easy. The language’s design prioritizes clarity and readability.
  • Powerful Macro System: Racket’s macro system lets you extend the language itself, creating new syntax and control structures tailored to your specific needs. This allows for creating highly expressive and efficient code.
  • Excellent for Language Design: Racket provides a robust platform for exploring and implementing different programming language concepts, from simple interpreters to sophisticated compilers.
  • Large and Active Community: Racket benefits from a supportive and active community, providing ample resources and assistance for learners.
  • Extensive Libraries: Racket boasts a comprehensive collection of libraries covering various domains, including web development, GUI programming, and more.

Setting up your environment #

To start programming in Racket, you need to download and install the Racket distribution from the official website (https://racket-lang.org/). The installation process is straightforward and involves downloading the appropriate installer for your operating system and following the on-screen instructions.

Once installed, you’ll have access to several tools, including:

  • DrRacket: An interactive development environment (IDE) that provides features like syntax highlighting, code completion, and debugging tools. This is the recommended environment for beginners.
  • The Racket command-line interpreter: A command-line interface for executing Racket code. Useful for quick experimentation and scripting.

Your first Racket program #

The simplest Racket program prints “Hello, world!” to the console. Open DrRacket and type the following code into the editor:

(displayln "Hello, world!")

Click the “Run” button (or use the keyboard shortcut). The output window will display:

Hello, world!

This short program uses the displayln function, which displays a string and adds a newline character at the end. The parentheses denote function calls in Racket; displayln is the function, and "Hello, world!" is its argument (the string to be displayed). This demonstrates the fundamental syntax of Racket: expressions are enclosed in parentheses, with the first element being the function or operator and the remaining elements being its arguments.

Basic Syntax and Data Types #

Numbers and Arithmetic #

Racket supports various number types, including integers, floating-point numbers, and complex numbers. Arithmetic operations are straightforward:

  • Addition: (+ 2 3) ; evaluates to 5
  • Subtraction: (- 5 2) ; evaluates to 3
  • Multiplication: (* 4 6) ; evaluates to 24
  • Division: (/ 10 2) ; evaluates to 5.0 (floating-point result)
  • Exponentiation: (expt 2 3) ; evaluates to 8 (2 raised to the power of 3)
  • Modulo: (modulo 10 3) ; evaluates to 1 (remainder after division)

Racket uses prefix notation for arithmetic operations (and most other operations). This means the operator comes before the operands.

Booleans and Comparisons #

Racket’s boolean values are #t (true) and #f (false). Comparison operators return boolean values:

  • Equals: (= 5 5) ; evaluates to #t
  • Not equals: (/= 5 3) ; evaluates to #t
  • Greater than: (> 10 5) ; evaluates to #t
  • Less than: (< 2 7) ; evaluates to #t
  • Greater than or equal to: (>= 5 5) ; evaluates to #t
  • Less than or equal to: (<= 3 8) ; evaluates to #t

Boolean operations include:

  • And: (and #t #f) ; evaluates to #f
  • Or: (or #t #f) ; evaluates to #t
  • Not: (not #t) ; evaluates to #f

Strings and Text Manipulation #

Strings in Racket are enclosed in double quotes: "This is a string". Several functions are available for string manipulation:

  • String concatenation: (string-append "Hello" " " "world!") ; evaluates to "Hello world!"
  • String length: (string-length "Racket") ; evaluates to 6
  • Substring: (substring "Racket" 0 4) ; evaluates to "Rack" (extracts characters from index 0 up to, but not including, index 4)

Many other string manipulation functions are available in the racket/string module.

Lists and Data Structures #

Lists are fundamental data structures in Racket. They are created using the list function or by directly writing elements within parentheses:

  • (list 1 2 3) ; creates a list '(1 2 3)
  • '(1 2 3) ; creates the same list using the quote notation (’) which prevents evaluation

List operations include:

  • first: Returns the first element of a list. (first '(1 2 3)) returns 1.
  • rest: Returns the list without the first element. (rest '(1 2 3)) returns '(2 3).
  • cons: Adds an element to the beginning of a list. (cons 0 '(1 2 3)) returns '(0 1 2 3).
  • append: Concatenates two lists. (append '(1 2) '(3 4)) returns '(1 2 3 4).

Racket also offers other data structures like vectors, hash tables, and more, which provide different ways to organize and access data efficiently.

Variables and Assignments #

Variables in Racket are assigned values using define:

(define x 10)
(define y 5)
(define sum (+ x y))  ; sum will be 15

define creates a variable binding. The variable’s name is x, y or sum and their values are assigned on the right side of the define expression. Note that define is not an assignment statement in the traditional sense; it creates a new binding. Racket also supports more advanced binding mechanisms like let and let* which are useful for creating local variable scopes.

Control Structures #

Conditional Statements (if, cond) #

Racket provides if and cond for controlling program flow based on conditions.

  • if: The simplest conditional statement. It evaluates a condition and executes one of two branches depending on whether the condition is true or false.
(if (> x 5)
    (displayln "x is greater than 5")
    (displayln "x is not greater than 5"))
  • cond: A more general conditional that allows for multiple conditions and branches. It’s especially useful when dealing with multiple possibilities.
(cond
  [(> x 10) (displayln "x is greater than 10")]
  [(> x 5) (displayln "x is greater than 5")]
  [else (displayln "x is 5 or less")])

cond evaluates each condition in turn. If a condition is true, the corresponding expression is evaluated, and the cond expression completes. The else clause acts as a default case if none of the preceding conditions are true.

Loops (for, while) #

Racket offers various looping constructs. for and while are commonly used.

  • for: Provides a concise way to iterate over a sequence of values or a range.
(for ([i (in-range 1 11)])  ; Iterate from 1 to 10 (inclusive)
  (displayln i))

(for ([i (in-list '(a b c))]) ; Iterate through a list
  (displayln i))

in-range creates a sequence of numbers, and in-list iterates through the elements of a list.

  • while: Executes a block of code repeatedly as long as a condition is true.
(let ([i 0])
  (while (< i 10)
    (displayln i)
    (set! i (+ i 1))))

let creates a local variable i, and set! modifies its value within the loop. Note the imperative style used with set! which modifies the existing variable binding.

Defining Functions #

Functions in Racket are defined using define:

(define (add-numbers x y)
  (+ x y))

(define (greet name)
  (displayln (string-append "Hello, " name "!)))

The syntax is (define (function-name parameter1 parameter2 ...) body). The function name is followed by the parameters in parentheses, and the function body is the expression(s) that will be evaluated when the function is called. The result of the last expression in the body is the return value of the function.

Working with Functions #

Function Definition and Application #

Functions in Racket are first-class citizens, meaning they can be passed as arguments to other functions, returned as values from functions, and stored in data structures. We’ve already seen how to define functions using define:

(define (square x)
  (* x x))

(square 5)  ; Returns 25

Function application is straightforward: the function name is followed by its arguments in parentheses. Racket uses prefix notation, meaning the function comes before its arguments.

Higher-Order Functions #

Higher-order functions are functions that take other functions as arguments or return functions as results. Racket provides many built-in higher-order functions, making functional programming very convenient. Here are a few examples:

  • map: Applies a function to each element of a list and returns a new list containing the results.
(map square '(1 2 3 4)) ; Returns '(1 4 9 16)
  • filter: Selects elements from a list that satisfy a given predicate (a function that returns a boolean).
(filter even? '(1 2 3 4 5 6)) ; Returns '(2 4 6)
```  (`even?` is a built-in function that checks if a number is even.)

* **`foldl` (or `foldr`):**  Accumulates a result by applying a function cumulatively to the elements of a list.

```racket
(foldl + 0 '(1 2 3 4)) ; Returns 10 (1 + 2 + 3 + 4 + 0)

Lambda Expressions #

Lambda expressions (anonymous functions) allow you to create functions without giving them a name. They are particularly useful when you need a function for a short-lived task and don’t want to clutter your code with named function definitions.

(map (lambda (x) (* x 2)) '(1 2 3)) ; Returns '(2 4 6)

The syntax is (lambda (parameters) body). This creates a function that takes the specified parameters and executes the provided body.

Recursion #

Recursion is a powerful technique where a function calls itself to solve a problem. Racket supports recursion effectively. Here’s an example of a recursive function to calculate the factorial of a number:

(define (factorial n)
  (if (= n 0)
      1
      (* n (factorial (- n 1)))))

(factorial 5) ; Returns 120

The factorial function calls itself with a smaller input (n-1) until it reaches the base case (n = 0), at which point it returns 1. This recursive approach elegantly solves the problem of calculating factorials. It is crucial to ensure that recursive functions have a well-defined base case to prevent infinite recursion.

Modules and Programs #

Creating and Using Modules #

Modules in Racket provide a way to organize code into reusable units, promoting modularity and code reusability. A module is a self-contained unit that defines functions, variables, and other entities. They help to manage namespaces and prevent naming conflicts.

To create a module, you save your Racket code in a file with the .rkt extension. The first line of the file typically specifies the module’s name and imports any necessary libraries.

#lang racket

(provide my-function)

(define (my-function x)
  (+ x 10))

This creates a module named my-module.rkt (assuming you save it with this name). #lang racket specifies the language, provide declares what’s exported (made available to other modules), and the rest is the module’s content.

To use this module in another file:

#lang racket

(require "my-module.rkt")

(my-function 5) ; This will call the function from the my-module.rkt file.

The require form loads the my-module.rkt module, making its exported functions available.

Namespaces and Imports #

Namespaces in Racket prevent naming conflicts between modules. Each module has its own namespace, so you can use the same name for different entities in different modules without causing errors. The provide and require forms manage what’s exported from and imported into a module.

For example, if two modules both define a function named add, the import mechanism ensures that each add function is accessible through its module’s namespace. This avoids ambiguity and confusion.

You can also use require to import specific elements from a module:

(require racket/string [string-append :string-append])

This only imports the string-append function, renaming it to simply string-append.

Writing Larger Programs #

For larger programs, it’s crucial to leverage Racket’s modularity features. Break down your code into smaller, manageable modules, each with a specific responsibility. This makes your code easier to understand, maintain, and test. Use well-defined interfaces (through provide) to specify what each module offers to other parts of the program.

Consider using a project structure to organize your modules and other resources. For example, you could group related modules into subdirectories.

Effective use of modules, along with version control (e.g., Git), helps manage the complexity of larger Racket projects. The raco command-line tool is useful for managing Racket projects.

Input and Output #

Reading from the Console #

Racket provides several ways to read input from the console. The simplest is using read:

(display "Enter a number: ")
(define num (read))
(displayln (+ num 10))

This code prompts the user to enter a number, reads the input using read (which reads a single S-expression), and then prints the number plus 10. read is powerful but expects correctly formatted Racket input; it’s not ideal for handling arbitrary user input which might contain errors.

For more robust console input handling, especially for strings that might contain spaces, consider using read-line:

(display "Enter your name: ")
(define name (read-line))
(displayln (string-append "Hello, " name "!"))

read-line reads an entire line of text from the console, including spaces.

Writing to the Console #

The primary function for writing to the console is display or displayln. display outputs text; displayln outputs text followed by a newline character.

(display "Hello, ")
(display "world!\n") ; \n adds a newline

(displayln "This is on a new line.")

You can also use printf for formatted output, similar to C’s printf:

(printf "The value of x is: ~a\n" 10) ; ~a is a placeholder for arbitrary values.

File Input and Output #

Racket provides functions for reading from and writing to files. Here’s how to write data to a file:

(define output-port (open-output-file "my-file.txt"))
(displayln "This text will be written to the file." output-port)
(close-output-port output-port)

This code opens a file named “my-file.txt” for writing, writes a line of text to it, and then closes the file. It’s crucial to close the output port to ensure data is written correctly to disk.

Reading from a file is done similarly:

(define input-port (open-input-file "my-file.txt"))
(let loop ([line (read-line input-port)])
  (when (not (eof-object? line))
    (displayln line)
    (loop (read-line input-port))))
(close-input-port input-port)

This code opens the file, reads each line using read-line, prints it, and continues until the end-of-file (eof-object?) is reached. Again, closing the input port is essential. Error handling (e.g., checking if the file exists before opening it) is recommended for production-level code.

Advanced Concepts (Optional) #

Macros #

Racket’s macro system is a powerful feature allowing you to extend the language itself. Macros operate on the code’s syntax before it’s evaluated, enabling you to create new language constructs and abstractions. A macro transforms one piece of code into another before the transformed code is evaluated.

A simple example demonstrates creating a macro that defines a function with a default argument:

#lang racket

(define-syntax-rule (define-with-default name params default-value body ...)
  (begin
    (define (name . args)
      (let ([params (if (null? args) default-value args)])
        body ...))
    name))

(define-with-default my-func (x) 0 (+ x 10))

(my-func 5)   ; Returns 15
(my-func)    ; Returns 10 (default value used)

define-syntax-rule defines a macro that transforms the define-with-default form into a function definition with appropriate logic for handling the default argument. Macros are powerful but require a deep understanding of Racket’s syntax and its evaluation process. Incorrectly written macros can lead to subtle and hard-to-debug errors.

Data Structures (More In Depth) #

Racket offers a rich set of data structures beyond lists. Here’s a brief overview:

  • Vectors: Vectors provide efficient access to elements by index, similar to arrays in other languages. They are created using vector.

  • Hash Tables: Hash tables store key-value pairs, enabling fast lookups by key. They are created using make-hash.

  • Structures: Structures allow you to create custom data types with named fields. They are defined using struct.

  • Sequences: A generalized abstraction encompassing lists, vectors, strings, and other ordered collections. Functions like map, filter, and foldl often work with sequences, offering a consistent interface across different data types.

Understanding these data structures is crucial for writing efficient and well-structured Racket programs. Choosing the appropriate data structure depends on the specific needs of your application—considering factors like access patterns and memory usage.

Exception Handling #

Racket uses a sophisticated exception handling mechanism. Exceptions are raised using raise and caught using with-handlers.

(with-handlers ([exn:fail? (lambda (exn)
                            (displayln "An error occurred!"))])
  (begin
    (raise (exn:fail "Something went wrong"))
    (displayln "This line won't be reached")))

This code uses with-handlers to catch exn:fail? exceptions (a specific type of exception). If a exn:fail exception is raised, the error message is printed; otherwise, the code proceeds normally. Racket’s exception handling system allows for more fine-grained control over error handling, including custom exception types and handlers. Using structured exception handling helps create more robust and reliable programs.

←
Beginner's Guide to Smalltalk
Beginner's Guide to Zig
→
back to top