Expressions

Abelson & Sussman · 1996 · SICP §1.1

Primitive expressions

The simplest expressions are self-evaluating: numbers evaluate to themselves, strings evaluate to themselves. The interpreter reads, evaluates, and prints. That loop is the whole interface.

; Primitive expressions — they evaluate to themselves.

486
; => 486

"hello"
; => "hello"

; Primitive procedures are built in:
(+ 137 349)
; => 486

(- 1000 334)
; => 666

(* 5 99)
; => 495

# Primitive expressions in Python
print(486)          # 486
print("hello")      # hello
print(137 + 349)    # 486
print(1000 - 334)   # 666
print(5 * 99)       # 495

Combinations — prefix notation

A combination is a list where the first element is the operator and the rest are operands. Parentheses make the structure explicit. There is no precedence to memorize — nesting is the only grouping mechanism.

; Combinations: (operator operand1 operand2 ...)
; No precedence rules — nesting is explicit.

(+ 21 35 12 7)
; => 75

(* 25 4 12)
; => 1200

; Nesting: the tree structure is visible
(+ (* 3 5) (- 10 6))
; => 19

; Deeper nesting
(+ (* 3 (+ (* 2 4) (+ 3 5))) (+ (- 10 7) 6))
; => 57

# Combinations — Python uses infix, so precedence matters
print(21 + 35 + 12 + 7)        # 75
print(25 * 4 * 12)              # 1200
print(3 * 5 + (10 - 6))         # 19
print(3 * (2 * 4 + (3 + 5)) + ((10 - 7) + 6))  # 57

Naming — define

define binds a name to a value in the environment. Once bound, the name can stand in for the value anywhere. This is the simplest form of abstraction: giving things names so we don't have to remember their values.

; Naming: define associates a name with a value.

(define size 2)

(display "size = ")
(display size) (newline)
; => 2

(display "5 * size = ")
(display (* 5 size)) (newline)
; => 10

(define pi 3.14159)
(define radius 10)
(define circumference (* 2 pi radius))

(display "circumference = ")
(display circumference)
; => 62.8318

# Naming in Python
size = 2
print(f"size = {size}")         # 2
print(f"5 * size = {5 * size}") # 10

import math
pi = math.pi
radius = 10
circumference = 2 * pi * radius
print(f"circumference = {circumference:.4f}")

Conditional expressions — cond and if

cond tests clauses in order and returns the value of the first true one. if is the two-branch special case. Both are special forms: they don't evaluate all their arguments.

; Conditional expressions

(define (abs x)
  (cond ((> x 0) x)
        ((= x 0) 0)
        ((< x 0) (- x))))

(display "abs(-5) = ") (display (abs -5)) (newline)
(display "abs(0)  = ") (display (abs 0)) (newline)
(display "abs(3)  = ") (display (abs 3)) (newline)

; Shorter with if:
(define (abs2 x)
  (if (< x 0) (- x) x))

(display "abs2(-7) = ") (display (abs2 -7))

# Conditional expressions in Python
def abs_val(x):
    if x > 0:
        return x
    elif x == 0:
        return 0
    else:
        return -x

print(f"abs(-5) = {abs_val(-5)}")
print(f"abs(0)  = {abs_val(0)}")
print(f"abs(3)  = {abs_val(3)}")

# Shorter with ternary:
abs2 = lambda x: -x if x < 0 else x
print(f"abs2(-7) = {abs2(-7)}")

The substitution model

To evaluate a combination: evaluate the subexpressions, then apply the operator to the operand values. For compound procedures, substitute the argument values for the formal parameters in the body. This is the substitution model — simple, mechanical, and sufficient until we introduce assignment in Chapter 3.

; The substitution model in action.
; Define a procedure, then trace its evaluation.

(define (square x) (* x x))
(define (sum-of-squares x y)
  (+ (square x) (square y)))
(define (f a)
  (sum-of-squares (+ a 1) (* a 2)))

; Evaluate (f 5):
; -> (sum-of-squares (+ 5 1) (* 5 2))
; -> (sum-of-squares 6 10)
; -> (+ (square 6) (square 10))
; -> (+ (* 6 6) (* 10 10))
; -> (+ 36 100)
; -> 136

(display "(f 5) = ")
(display (f 5))

# Substitution model in Python
def square(x):
    return x * x

def sum_of_squares(x, y):
    return square(x) + square(y)

def f(a):
    return sum_of_squares(a + 1, a * 2)

# f(5) -> sum_of_squares(6, 10) -> square(6) + square(10)
#       -> 36 + 100 -> 136
print(f"f(5) = {f(5)}")

Notation reference

Translation notes

Scheme uses prefix notation uniformly; Python uses infix for arithmetic and keyword syntax for definitions and conditionals. The substitution model described here is applicative-order (evaluate arguments first). Python also uses applicative order. Normal-order (evaluate arguments only when needed) appears in Chapter 15 (Lazy Evaluation). The cond special form has no direct Python equivalent — the closest is an if/elif chain.