anchor.diff:          validators
           |> List.map (function
                           | CommandValidator validator -> validator cmd |> (toChoiceValidator cmd)
  -                        | StateValidator validator -> validator state |> (toChoiceValidator cmd)
  +                        | StateValidator validator -> 
  +                            let registration = 
  +                                { new IStateValidatorRegistration<_,_> with 
  +                                    member x.Register
  +                                }
  +                            validator state |> (toChoiceValidator cmd)
                           | CombinedValidator validator -> validator cmd state |> (toChoiceValidator cmd))
            |> List.map (fun x -> x)
            |> List.fold (fun s validator -> v.apl validator s) (Choice.returnM cmd) 
  
positive.code:     GetId : 'TCommandContext -> 'TCmd -> 'TId
      StateBuilder : IStateBuilder<'TCommandState, 'TMetadata, 'TId>
      StateValidation : 'TCommandState -> Choice<'TValidatedState, NonEmptyList<ValidationFailure>> 
      Validators : Validator<'TCmd,'TCommandState> list
      Handler : 'TValidatedState -> 'TCommandContext -> 'TCmd -> Choice<seq<'TEvent * 'TMetadata>, NonEmptyList<ValidationFailure>>
      SystemConfiguration : SystemConfiguration<'TMetadata>
  }
  
negative.code: open FSharpx
  open Eventful.Validation
  
  type IStateValidatorRegistration<'TMetadata,'TKey> =
      abstract member Register<'TState> : IStateBuilder<'TState, 'TMetadata, 'TKey>  -> ('TState -> seq<ValidationFailure>) -> unit
  
  type Validator<'TCmd,'TState, 'TMetadata, 'TKey> = 
  | CommandValidator of ('TCmd -> seq<ValidationFailure>)
  | StateValidator of (IStateValidatorRegistration<'TMetadata,'TKey> -> unit)
  | CombinedValidator of ('TCmd -> 'TState -> seq<ValidationFailure>)
  
  type SystemConfiguration<'TMetadata> = {
  