Week 1

Intro to Lisp

Lisp

Acronym: List Processing || Lots of Irritating Silly Parentheses

# To run lisp progran in VS Code:
> rlwrap sbcl           # starts REPL - read-eval-print loop
* (load "file.lisp")    # assume hello()
* (hello)               # calls hello() method in file.lisp
* (+ 2 3)               # prints 5 (quick temp. form)
* (exit)                # either trash the terminal or enter (exit)

Syntax Basics

Atoms : basic syntactic units of the language ex:

  • Numbers

    • Integers (0, -1, 69)

    • Ratios (1/2, 2/3, 4/2)

    • Floats (0.0, -1.0, +1.5)

  • Individual Chars : #\a, #\@

  • Strings : "string"

  • Boolean : T (true), NIL (false)

  • Symbols - names (made up of strings/numbers/chars) used for naming functions, variables, & other entities:

    • 2021CPS305, symbolName123, +, T, NIL, <>, -+49ers+-, <+==+>

  • Lists : sequence of either atoms or other lists separated by blanks

    • (1 2 3)
(a b c d)
(a "b" T -2.0)
(a (b c) (d (e f)))
()    ; () = NIL

  • Vectors : faster list-like sequence

    • #(1 2 3), #(a "b" -2.0)

S-Expressions

symbolic expressions (aka function application: non-empty list are themselves forms)

syntax : ( op a1 a2 a3 ... )

op : function || operator

a1 a2 a3 ... : arguments || operands

Forms : lisp expressions that may be meaningfully evaluated

  • (= (+ 2 3) 5) : evaluates to t

  • (a b c) : ERROR 'a' is not a function (this is a list, not a form)

; same as 2 * 8
; evaluates to 6
(* 2 8)

; you can chain operations aswell
; same as doing 2 + (4 * 4)
; evaluates to 18
(+ 2 (* 4 4))

; another ex.
; same as doing (8/2) - (8*4)
(- (/ 8 2) (* 4 8))
; = to -28

; (2 + [4 * 6]) * (3 + 5 + 7)
; = 390
(* (+ 2 (* 4 6)) (+ 3 5 7))


; (2 - [3 - [6 + 4/5]]) ÷ (3 * [6 - 2])
; = 29/60
(/
    (- 2 (- 3 (+ 6 4/5)))     ; numerator
    (* 3 (- 6 2))             ; denominator
)
; evaluates to 29/60

Variables & Constants

below ex. are for global vars/const ; for local vars use let>defvar

  • Variables

    • DEFINE =(defvar varName varValue "var desc.")

    • SET =(setq varName newValue)

      ; defines a mutable var *total-glasses* and assigns it's value to be 0
; u dont need the *sandwich* like below ex's, but it is good practice
(defvar *total-glasses* 0 "Total glasses so far")

; change value to 3
(setq *total-glasses* 3)

; same as += 1
(setq *total-glasses* (+ *total-glasses* 1))

  • Constants

    • DEFINE =(defparameter constName constValue)

    • SET =can't change const value

      ; const variable B = 20
(defparameter B 20)

Named Procedures (aka Functions)

syntax : (defun [funcName] ([parameters]) ([body]) )

; squares the value of x
(defun square (x) (* x x))

; sum of squares of 2 parameters
(defun sum-of-squares (x y)
    ; calls above square function from inside this function    
    (+ (square x) (square y))    
)

Lambda (Anonymous Functions)

much like in other languages, lambda fx's are quick one liners that are defined and called in the same line.

syntax : ( (lambda params body) arguments )

; normal (squares 4) vs. lambda function:
( (lambda (x) (* x x)) 4 )

((lambda (x y) (+ x y)) 2 2)    ; => 4

Blocks + Progn

  • Block

    Blocks allow for contorlled sequential execution.

    • syntax : (block blockName body)

      (block test
    (print "hello")
    (+ 2 2)
)

; evaluates to:
; "hello"
; 4

  • Progn

    skipped the blockname and can call the block directly

    • syntax : (progn body)

      ; evaluates to same thing above
(progn
    (print "hello")
    (+ 2 2)
)

Special Forms

If op is 1 of 25 special words, the form is evaluated as a special form

Special Forms usually produce values (but not always)

  • quote

    • (quote v) aka 'v where v=form : returns v as data, w/o evaluating it.

      (quote (+ 2 3))    ; (+ 2 3) not 5
'(+ 2 3)           ; (+ 2 3)

  • and / or

    The following objects are interpreted as NIL : (), '(), NIL, 'NIL

    All other objects are interpreted as True

    • and a1 ... aN

      • all forms a1...aN are evaluated (L-to-R)

      • if any form evaluates to NIL, and returns NIL

      • if none of the forms are NIL, and returns evaluation of aN

; 3rd form is nil
; returns NIL
(and 0 1 nil (+ 3 4) 3)

; no form is NIL
; returns (* 3 3) = 9
(and 0 1 2 (* 3 3))

  • or a1 ... aN

    • all forms a1...aN are evaluated (L-to-R)

    • if any form ai evaluates to true, or returns evaluation of ai

    • if all forms but aN evaluate to NIL, or returns evaluation of aN

; 3rd form is (< 3 4) (truthy)
; return (< 3 4) = T
(or nil (> 5 6) (< 3 4) (= 1 2))

; 1st form is 0 (truthy)
; returns 0
(or 0 (* 3 3) 2 1)

  • if

    • (if cond then [else])

    • if cond-form is T, then evaluate then-form

    • opt. [else]-form is evaluated if cond-form is NIL (false)

(if (condition)
    (option-1)
    ; else
    (option-2))

; cond=NIL, so else=(* 3 2) =6
(if nil
    4
    (* 3 2)) ; else

; cond=(and 0 1 NIL ..) =NIL, so else=10 =10
(if (and 0 1 nil (+ 3 4) 3)
    3
    10) ; else

; cond=(or 0 ...) =0 (truthy), so then=(+ 5 5) =10
(if (or 0 (* 3 3) 2 1)
    (+ 5 5) ; then
    (* 10 10))

  • When we want to evaluate several conditions in a row we use cond :

    (cond
     ; if condition 1
     ((= 1 2)
     (print "hello")) 
    ; else if condition 2
    ((= 1 1)
    (print "world")) 
    ; else
    (t ("nothing else worked"))) 
    ; evaluates to:
    ; "world"

  • let

    special form for temporary local variable binding

    • syntax : (let ((var1 val1) … (varN valN)) <s-expressions>)

      • var1, ... varN : variable names

      • val1, ... valN : initial values assigned to respective vars (default=NIL)

      • each varN is assigned to their valN, and finally the s-expression is evaluated.

      • The value of the last expression evaluated is returned

; x =4
; s-exp = (* 4 4) =16 is returned
(let ((x 4)) (* x x))

(let ((x 3)    ; x=3
      (y 1))   ; y=1
     (+ (* y x) x))    ; s-exp = (+ (* 1 3) 3) =6 is returned

; ERROR 
(let ((x 3)       ; x=3
     (y (* x x))) ; ERROR 3 hasn't been bound to x yet!
     (+ x y))

Loops

  • dotimes : used to create simple loops that loop from 0 to n-1

    analogous to "for i in range(n)" in python

    • syntax : (dotimes (i [n] [completed value]))

      • i - loop iteration variable

      • n - loops until n-1

      • completed value - opt. value that's returned when the loop completes; NIL by default.

    (dotimes (i 3)
     (prnt i))
; 0
; 1
; 2
; NIL

  • do : more versatile looping

    • syntax :

      • (do ((i [start value] ([increment by] [operation] i)

      • ([body])))

      • (([exit condition]) i)

      • ([body]))

        (defvar i 0)
(do ((i 0 (1+ i))
    (print i))
    ((> i 4) i)
    ((print i)))

Note: i needs to be initialized prior.

PreviousWeek 2

Last updated