# Lecture 3 — 2015-09-09

## Laziness, higher-order functions, and semantics

We started the class by talking about what BSTs are for, and how to figure out how to define `insertBST` in the first homework.

We also went over how to use the `and` function to write a bunch of tests for your code.

``````module Lec03 where

import Lec01 (Day(..),isWeekday,nextDay)

import qualified Data.Map as Map
import Data.Map (Map)``````

The code part of the lecture focused mainly on laziness and higher order functions.

``````incAll = map (+1)

test_empty = incAll [] == []
test_123 = incAll [1,2,3] == [2,3,4]

runTests = and [test_empty,test_123]

test_error = error "uh oh"

ignore _ = ()

diverge 0 = diverge 1
diverge n = diverge (n+1)

diverge' = diverge'``````

We defined our own version of `.`, like so:

``````compose :: (b -> c) -> (a -> b) -> a -> c
compose f g = \x -> f (g x)``````

We also used `.` to define a few functions without having to mention any of those pesky variable names:

``````isWeekend = not . isWeekday

postponeWeekday :: [Day] -> [Day]
postponeWeekday =
filter isWeekday . map nextDay``````

The remaining forty five minutes of class focused on syntax and semantics.

We defined a simple arithmetic language over the integers—I mistakenly said naturals at first—with few operations: addition, multiplication, and negation. Its grammar was like so:

``````m, n are Integers

e is an Expression ::=
n
| e1 plus e2
| e1 times e2
| negate e``````

In lecture I used the traditional mathematical notations for the operations. Here I’ll use prose to make it clear what’s syntax and what’s math.

We gave semantics to this syntax in two ways: denotationally and with a rewrite system.

The denotational semantics looked like so:

``````[[-]] : Expression -> Integer

[[n]]       = n
[[e1 plus e2]] = [[e1] + [[e2]]
[[e1 times e2]] = [[e1] * [[e2]]
[[negate e]] = - [[e]]``````

We interpreted each expression as the integer it evaluates to. Direct, succinct—this looks a lot like an interpreter for this arithmetic language!

The rewriting semantics was defined as an inductive series of inference rules, like so:

``````-> is a relation between Expressions and Expressions
i.e. -> is a subset of 2^{Expr x Expr}

---------------- Plus
n plus  m -> n+m

---------------- Times
n times m -> n*m

--------------- Negate
negate n  -> -n

e1 -> e1'
------------------------- PlusLeft
e1 plus e2 -> e1' plus e2

e2 -> e2'
------------------------- PlusRight
e1 plus e2 -> e1 plus e2'

e1 -> e1'
--------------------------- TimesLeft
e1 times e2 -> e1' times e2

e2 -> e2'
--------------------------- TimesRight
e1 times e2 -> e1 times e2'

e -> e'
--------------------- NegateInner
negate e -> negate e'``````

We then constructed some derivations using this rewrite system. It’s less obvious what these have to do with implementation, but it gave us a clear notion of what precise steps happened to evaluate an expression.