anchor.diff:          }
   
       let application<'TMessage, 'TModel, 'TView> initMessage handleMessage handleReplay configureProducers createInitApp =
  +        /// State of the application
  +        /// we are using closure to store the Application state in memory
           let mutable state = None
   
  +        /// Helper function used to notify subscribers
           let notifySubs msg =
  +            /// Only notify the subscribers if the application is running
               match state with
               | Some s ->
                   s.Subscribers |> List.iter (fun sub -> sub msg)
               | None -> ()
   
  +        /// Function responsible of running the application 
           let rec handleEvent (evt:AppMessage<'TMessage, 'TModel>) =
               let (state', actions)  : App<'TModel, 'TMessage, 'TView>*(unit -> unit) list =
  +                // Pattern matching overt the type of the AppMessage
                   match evt with
                   | Message message ->
  +                    // This is a standard message
                       handleMessage handleEvent notifySubs message (state |> Option.get)
                   | Replay (model, messages) ->
  +                    // We are asking to replay a state
                       handleReplay handleEvent notifySubs (model, messages) (state |> Option.get)
  +            // Update the 
               state <- Some state'
               actions |> List.iter (fun x -> x())
   
           let post = (Message >> handleEvent)
  +        /// Initialise the application
           state <- createInitApp post |> Some
  +        /// Send the init message into the application
           initMessage post
   
  +        /// Configure the producers give them an Handler
  +        /// This is the Handler they will use to push message in the application
           configureProducers handleEvent
  +        // Start the application
           handleEvent
   
       let render post viewFn app =
  
positive.code: 
      let createActions post = List.map (fun a -> fun () -> a (Message >> post))
  
      let handleMessage update viewFn post notifySubs message app =
          notifySubs (ActionReceived message)
          let (model, actions) = update app.Model message
  
  
negative.code: 
  [<AutoOpen>]
  module Types =
  
      /// An handler is a function used to send a message in the application.
      type Handler<'TMessage> = 'TMessage -> unit
  
      /// Representation of a change in the model
      type ModelChanged<'TMessage, 'TModel> =
          {
              PreviousState: 'TModel
  