# Brian Beckman: The Zen of Stateless State - The State Monad - Part 2

## The Discussion

• Can anyone (Brian?) suggest a good book(s) as a introduction to category theory? I'm really looking for just enough to underpin monad theory.
and monism
http://en.wikipedia.org/wiki/Monism
was helpful to me to get my head around what the heck a monad "is" (it turns out its pretty hard to define )

•

// F# code

#light
open System
open System.Text

//  label a binary tree to demonstrate state-monad

type Tree<'a> =
| Leaf of string*'a
| Branch of Tree<'a>*Tree<'a>

// prints binary tree
// val printTree : Tree<'a> -> unit
let printTree(a)=
let rec print(a,level)=
let emptyString =new String(' ',level*2)
printfn "%s" emptyString
match a with
|Leaf (sym,e)-> Console.Write(emptyString)
Console.Write("Leaf: "+sym+" ")
Console.Write(e.ToString())
Console.WriteLine()
|Branch (left,right) -> Console.Write(emptyString)
Console.WriteLine("Branch:");
print(left,level+1)
print(right,level+1)
print(a,2)

let rec labelTreeNM(t,s) =
match t with
|Leaf(sym,_)-> let l=Leaf(sym,s)
(s+1,l)
|Branch(left,right)-> let(sL,nLeft)=labelTreeNM(left,s)
let(sR,nRight)=labelTreeNM(right,sL)
(sR+1,Branch(nLeft,nRight))

let demoTree=Branch(Leaf("A",0),Branch(Leaf("B",0),Branch(Leaf("C",0),Leaf("D",0))))

let (_,demoTreeNM)=labelTreeNM(demoTree,0)
//printTree(demoTreeNM)

type State<'s,'a> = State of ('s ->'s*'a)

//  class
//    new : unit -> StateMonad
//    static member
//      Bind : sm:State<'a,'b> * f:('b -> State<'a,'c>) -> State<'a,'c>
//    static member Return : a:'a -> State<'b,'a>
//  end

static member Return(a) = State (fun s -> s, a)
static member Bind(sm,f) =
State (fun s0 ->let (s1,a1)= match sm with
| State h -> h s0
let (s2,a2)= match f a1 with
| State h->h s1
(s2,a2))

// succinct functors for state monad

//val ( >>= ) : State<'a,'b> -> ('b -> State<'a,'c>) -> State<'a,'c>
let (>>=)m  f = StateMonad.Bind( m, f)
//val Return : 'a -> State<'b,'a>

// Tree<'a> -> State<int,Tree<int>>
=match t with
|Leaf(sym,_) -> State(fun s->((s+1),Leaf(sym,s)))
fun newR->Return(Branch(newL,newR)))

| State f-> f(s)
nT

printTree(mTree)

• Look on YouTube.  Category theory is used in Linear Algebra and most importantly quantum mechanics.  You I suggest the Stanford University Open Course ware on Quantum Mechanics, there is also probability some good Linear Algebra open course wear at Stanford as well.  Quantum Mechanics II Lecture series starts with a good opener on linear algebra, as it pertains to QED.  All linear algebra operations are function operations of observable events.  It does get much into category theory and complex math, but it is the 'real' stuff that is observable and that is what the course shows how to design mathematical proofs of.  Here is the link to the courses:

Lecture 1 | Modern Physics: Quantum Mechanics (Stanford)

Linerar Algerbra:

Lecture 1 | Introduction to Linear Dynamical Systems

~Proto-Bytes