High-level introduction to state monad and lenses by building an Enigma machine with functional programming in Scala.

1. Building Enigma with
State Monad & Lens
Timothy Perrett
SF Scala, December 2014

2. Hello.

4. 73 years today.

5. Steckerbrett.
(Plugboard)

7. Walzen.
(Rotor)

9. Umkehrwalze.
(Reflector)

11. Process.

13. 158,962,555,217,826,360,000.
(158 quintillion)

14. Process.
๏ Distributed with typically a month of
configuration settings.
๏ Kriegsmarine vessels often had two
Enigmas onboard to account for delivery
delay due to being submersed

15. Demo.

16. Design.

17. Design.

18. Design.
Char => Char
Char => Char
Char => Char
Char => Char

19. Code.

20. case class Plugboard(shuffled: Seq[Char]){ ... }
case class Rotor(
wiring: String,
ring: Char,
notch: Char,
posistion: Char
){ ... }
case class Machine(
plugboard: Plugboard,
right: Rotor,
middle: Rotor,
left: Rotor,
reflector: Reflector
){ ... }
Algebra.

21. for {
Program.
_ <- get[Machine]
_ <- modify((m: Machine) => right(m))
_ <- modify((m: Machine) => middle(m))
_ <- modify((m: Machine) => left(m))
o <- get[Machine]
} yield
o.plugboard.transform _ andThen
rtl(o) andThen
o.reflector.transform andThen
ltr(o) andThen o.plugboard.transform apply(c)

22. State.
S => (S, A)
๏ Given a state S, compute a resulting S
(i.e. make any needed modifications to
the state) and produce a resulting A
๏ Explicit state handling in every type
signature can be tedious.

23. trait State[S,A] {
def get[S]: State[S,S]
def put[S](s: S): State[S, Unit]
def modify[S](f: S => S): State[S, Unit]
def run(s: S): (S,A)
def map[B](f: A => B): State[S,B]
def flatMap[B](f: A => State[S, B]): State[S,B]
}
object State {
def apply[S,A](f: S => (S,A)): State[S, A] =
new State[S,A]{
def run(s: S): (S,A) = f(s)
}
}
State.

24. trait State[S,A] {
def run(s: S): (S,A)
def map[B](f: A => B): State[S,B] = State { s =>
val (x,a) = run(s)
(x,f(a))
}
def flatMap[B](f: A => State[S, B]): State[S,B] =
State { s =>
val (x,a) = run(s)
f(a).run(s)
}
}
State.

25. State.
type State[S,A]
๏ State monad threads S through your
computation for you.
๏ Actual implementation in Scalaz is in
terms of the monad transformer for State
through Id.
๏ Avoid overflow by using:
type State[S,A] = StateT[Trampoline,S,A]

26. for {
Program.
_ <- get[Machine]
_ <- modify((m: Machine) => right(m))
_ <- modify((m: Machine) => middle(m))
_ <- modify((m: Machine) => left(m))
o <- get[Machine]
} yield
o.plugboard.transform _ andThen
rtl(o) andThen
o.reflector.transform andThen
ltr(o) andThen o.plugboard.transform apply(c)

27. Program.
def stepRotor(r: Rotor): Rotor =
rotorL.modify(r, Alphabet.nextLetter)
def right(m: Machine): Machine =
m |-> rightL modify(stepRotor)
def middle(m: Machine): Machine =
m |-> middleL modify(r =>
if(m.right.notch == r.position ||
m.left.notch == r.position) stepRotor(r)
else r)
def left(m: Machine): Machine =
m |-> leftL modify(r =>
if(r.position == m.middle.notch) stepRotor(r)
else r)

28. Lens.
get: A => B
set: (A,B) => A
๏ Comprised of two functions: “getter” and
“setter”, where the latter returns the
updated value.
๏ Using lenses, updates compose

29. m.copy(
right = m.right.copy(
position = m.right.position + 1
),
middle = m.middle.copy(
position = m.middle.position + 1
),
left = m.left.copy(
position = m.left.position + 1
)
)
Lens.

30. Lens.
case class Lens[A,B](
get: A => B,
set: (A, B) => A
)
val rotorL = Lens[Rotor, Char](
_.position,
(a, b) => a.copy(position = b)
)
rotorL.set(m.right)

31. Lens.
type Lens[A,B]
๏ Build modular functions to compose
updates to complex domain types.
๏ Scalaz ships with a Lens
implementation, but Monocle is really
where its at for Lenses

32. Monocle.
https://github.com/julien-truffaut/Monocle
๏ Scalaz Lens is great, but has boilerplate
๏ Monocle removes said boilerplate by
using macros
๏ Provides powerful abstractions in the
same space as Lens (Prism, Iso, Getter)
๏ Convenient syntax for bedazzlement
of lenses

33. Monocle.
val lenserM = Lenser[Machine]
val rightL = lenserM(_.right)
val middleL = lenserM(_.middle)
val leftL = lenserM(_.left)
val lenserR = Lenser[Rotor]
val rotorL: Lens[Rotor,Rotor,Char,Char] =
lenserR(_.position)
m |-> rightL |-> rotorL modify(_ + 1)

34. Roundup.
๏ FP gives you a frame to reason about
problems in a straight-forward, explicit
and easy manner.
๏ State monad gives you explicit,
immutable control over state changes
๏ Lenses make updating nested domain
types convenient and composable.
๏ Enigma was an incredible piece of
engineering in 1918!

35. EOF
@timperrett
github.com/timperrett/enigma
timperrett.com