Welcome to Comp308: Principles of Programming Languages’s documentation!

Contents:

• Welcome note
• A quick introduction to Racket and Scheme
  • Things
  • S-expressions
  • Procedures
  • Evaluation by substitution
  • Homoiconicity
  • What’s in the box?
  • The end (for now)
  • Exercises
• λ - the everything
  • So what’s λ?
  • Tall claims need taller evidence
  • Interlude on β-abstraction
  • Recursion
• Lambda - via β-abstraction
  • λ-calculus
  • Allowances
  • Making pairs
  • Church numerals
  • Understanding recursion
  • Moral of the story
• A language for pictures
  • Growing a language
  • A plausible vocabulary
  • What is “colour”?
  • So, what is an “image” or “picture”?
  • Composing transformations as functions
  • A first step to making an interpreter
• A language for arithmetic
  • Language structure
  • A plausible vocabulary
  • A first step to making an interpreter
• A mental model for the machine
• Notional machine
  • Instruction sequence
  • Instructions for our “machine”
  • Storage
  • Instruction processor
  • Reflections
  • Introducing identifiers
  • Blocks of instructions
  • Reuse versus encapsulation
• Growing the language
  • Typed racket (advanced / optional)
• Functions and scope
  • Defining functions
  • Applying functions: substitution a.k.a. β-reduction
  • Two evaluation modes
  • Scope
• Functions and scope (arithmetic track)
  • Defining functions
  • Lexical & dynamic environments
• Stacks and scope
  • Adding names to the stack-machine
  • Blocks
  • Which programs are valid blocks?
  • Dynamic scoping
  • Fixing dynamic scoping
• Functions in PicLang
  • No more subst
  • Interpreter with bindings
  • A standard library
  • A superpower
• Mutations
  • The Racket “box”
  • Sequencing
  • Sequencing in the stack machine
  • Terms for boxes
  • Variations
  • Super powers
  • State machines
• Control
  • Motivating control
  • Working up from simple examples
  • (Optional) Yet another perspective
  • Adding continuations to the stack language
• Generators
  • Seeing continuations through β-abstraction
  • Delimited continuations
  • call/cc and let/cc
  • Super power time - generators
  • Differences from Python’s generators
  • Uses for generators
• On the choice between “error” and “do something reasonable” in design
• Polymorphism via dispatch
  • Exploring through “property lists”
  • A prototype based object system
  • It’s tiring
  • Class methods
  • Classes and Types
  • Uniformity considerations
  • Flipping things around
  • Miscellaneous considerations
• Alternative application semantics
  • Solving for goals
  • Goals
  • Structural unification
  • Generalizing “pair”s
  • Prolog
  • Our interpreter expressed in Prolog
  • Adding functions to our interpreter
• Types: Checking some program invariants statically
  • Pure arithmetic expressions
  • When we introduce functions
  • Typing conditional expressions
  • Recursive functions
  • Types and mutation
  • Type soundness
  • A taste of type inference
  • Parametric polymorphism

Indices and tables

• Index

• Module Index

• Search