Programming in Scala”

Chapter notes 18
case class Moore[S, I, A](t: (S, I) => S, g: S => A)
Together with an initial state s of type S. Here:
• S is the set of states.
• I is the input alphabet.
• A is the output alphabet.
• t is the transition function mapping the state and an input value to the next state.
• g is the output function mapping each state to the output alphabet.
As with Mealy machines, we could model the transition function and the output function as a single
function:
type Moore[S, I, A] = S => (I => S, A)
Since both the transition function t and the output function g take a value of type S, we can take
that value as a single argument and from it determine the transition function of type I => S as well
as the output value of type A at the same time.
Mealy and Moore machines are related in a way that is interesting to explore.
Lenses
If we specialize Moore so that the input and output types are the same, we get a pair of functions t:
(S, A) => S and g: S => A. We can view these as (respectively) a “getter” and a “setter” of A values
on the type S:
get: S => A
set: (S, A) => S
Imagine for example where S is Person and A is Name.
type Name = String
case class Person(name: Name, age: Int)
A function getName would have the type Person => Name, and setName would have the type
(Person, Name) => Person. In the latter case, given a Person and a Name, we can set the name
of the Person and get a new Person with the new name.
The getter and setter together form what’s called a lens. A lens “focuses” on a part of a larger
structure, and allows us to modify the value under focus. A simple model of lenses is: