Calendar management
Embedded contextual email
Scheduling automation
Automated outreach
Telehealth
Marketplaces
Recruiting
Document management
Real estate
Communications software
Docs
SDKs
Tutorials
API status
Changelog
Support
Blog
Events
Guides
Newsroom
Partners
Build vs. buy
Customer stories
Trust & security
Why NylasLearn you a Lisp (Racket)
Ever wondered what Lisp is all about? Using Racket we’re going to learn the fundamentals of the Lisp programming family.
Ever wondered what Lisp is all about? Using Racket we’re going to learn the fundamentals of the Lisp programming family.
Racket is a descendant of Scheme which is a descendant of Lisp. Interestingly enough, Racket was the inspiration for Clojure.
We’ll take a closer look at each one of these topics shortly:
In this post, we’re going to get a small introduction to Racket, a programming language part of the Lisp family of languages.
Racket (1995) → If we’re on a Mac, the best way is to use homebrew and type on the terminal window:
$ brew install --cask racket
For other systems, you can refer to the download page.
Let’s open up the DrRacket which is Racket’s own Integrated Development Environment (IDE). On the terminal type:
$ drracket
The first time we run it, it will prompt us to choose a language. Choose the first one:
Then save the file using Crtl + S and call it Sandbox.rkt or whatever you prefer. Then type:
#lang racket (+ 1 2 3)
Here we’re simply saying, we’re going to sum this list of numbers. Everything on Racket is either a single value or a list. Press the Run button 
Let’s say now that we would like to multiply the result by 2.
#lang racket (* (+ 1 2 3) 2)
Starting to look weird, huh? Simply we’re saying that we want to multiply the result of the sum operation by 2. So we can infer that nested parentheses get evaluated first. So we first complete the addition `1 + 2 + 3`, take the result and multiply it by 2.
Now we can see why everything is surrounded by parentheses in Lisp, but there’s more. This is how we would declare and call a function:
#lang racket
(define (HelloFunction name)
(string-append "Hello " name))
(HelloFunction "Blag")
Here, our function name is HelloFunction and it has a parameter called name. As we can see the function name and parameter are surrounded by parentheses. The body of the function, which is surrounded with parenthesis as well, states that we’re going to append the string Hello and the parameter name. The whole function is surrounded by parentheses. When calling the function, we surround it with parentheses and pass the parameter.
We said that everything is an expression, so what do we mean by that exactly? Well, we can do something like this:
#lang racket (define (sum_or_by num) ((if (< 5 num) + *) 10 20)) (sum_or_by 6) (sum_or_by 2)
If the number we’re passing as a parameter is lower than 5, then sum 10 and 20, but if the number is bigger than 5, then multiply 10 and 20.
We can also do something like this:
#lang racket (define myLambda (lambda () (print "Hello Racket!"))) (myLambda)
Here we are defining a lambda which is an anonymous function (Anonymous functions are useful because they allow us to create functions inline without the need of actually declaring them. They are usually faster and consume less resources), but assigning that into a variable, so we can call the variable in order to run the lambda.
And what about this?
#lang racket (define myLambda (lambda () (+ 2 3))) (* (myLambda) 8)
We’re creating a lambda and assigning it to a variable called myLambda. This lambda will sum 2 and 3 together. Then, we’re multiplying the result of the lambda by 8.
Let’s create a simple example of a Fibonacci sequence. Where each number equals the sum of its predecessors.
So if we input 5, the answer will be 0 1 1 2 3 5.
#lang racket
# Here we define a function called showFib that gets num as the argument
(define (showFib num)
# It will display on the screen the result of calling the fib function passing num, 0 and 1
(display (fib num 0 1)))
# Here we define a method called fib that gets three parameters: num, a and b.
(define (fib num a b)
# If a > 0 and num > 1
( cond [(and (> a 0) (> num 1))
# Sum a and b and add the result to the output
(append (cons (+ a b) '())
# call the fib function again, subtracting one from num and adding a plus b
(fib (sub1 num) (+ a b) a))]
# If a equals 0
[(= a 0)
# Add a and b to the output
(append (append (cons a (cons b '()))
# Sum a and b and add it to the output
(cons (+ a b) '()))
# Call the fib function again, subtracting one from num and adding a plus b
(fib(sub1 num)(+ a b) b))]
# If num equals 1, then we can stop and append a terminator to the list
[(= 1 num) (append '())]))
What about a big number? How about 5000?
Hard to see but the last number is 1045 digits long.
Learning Racket or Lisp is great to bend your mind on how programming languages work.
Watch the livestream Learn you a Lisp (Racket) | Coding with Nylas | Episode 35
To learn more about Nylas, follow our documentation.
Don’t miss the action, watch our LiveStream Coding with Nylas:
Please enter your email address and receive the latest updates.
Blag aka Alvaro Tejada Galindo is a Senior Developer Advocate at Nylas. He loves learning about programming and sharing knowledge with the community. When he’s not coding, he’s spending time with his wife, daughter and son. He loves Punk Music and reading all sorts of books.
