anchor.diff:      type Get = Get with
           static member inline instance (Get, _:OptionT<_>) = fun () -> lift (State.get())
           static member inline instance (Get, _:ListT<_>  ) = fun () -> lift (State.get())
  +        static member inline instance (Get, _: SeqT<_>  ) = fun () -> lift (State.get())
           static member        instance (Get, _:State<_,_>) = fun () ->      (State.get())
   
       type Put = Put with
           static member inline instance (Put, _:OptionT<_>) = lift << State.put
           static member inline instance (Put, _:ListT<_>  ) = lift << State.put
  +        static member inline instance (Put, _: SeqT<_>  ) = lift << State.put
           static member        instance (Put, _:State<_,_>) =         State.put
   
       let inline internal get() = Inline.instance Get ()
  
positive.code: module MonadReader =
      type Ask = Ask with
          static member instance (Ask, _:OptionT<Reader<'a,option<'a>>>) = fun () -> lift (Reader.ask()) :OptionT<Reader<'a,option<'a>>>
          static member instance (Ask, _:ListT<Reader< 'a,List<   'a>>>) = fun () -> lift (Reader.ask()) :  ListT<Reader<'a,  List<'a>>>
          static member instance (Ask, _:Reader<'r,'r>                 ) = fun () ->      (Reader.ask()) :Reader<'r,'r>
  
      type Local = Local with
          static member inline instance (Local, OptionT m, _:OptionT<_> ) = fun f -> OptionT <| Reader.local f m
          static member inline instance (Local, ListT   m, _: ListT<_>  ) = fun f -> ListT   <| Reader.local f m
          static member        instance (Local,         m, _:Reader<_,_>) = fun f ->            Reader.local f m
  
      let inline internal ask()     = Inline.instance  Ask ()
  
negative.code:             OptionT ( (fun v h -> Inline.instance (CatchError, v) h) (OptionT.run m) (OptionT.run << h) ) :OptionT<'U>
          static member inline instance (CatchError,  m:ListT<'U> , _:ListT<'U>  ) = fun (h:'e -> ListT<'U>) -> 
              ListT ( (fun v h -> Inline.instance (CatchError, v) h) (ListT.run m) (ListT.run << h) ) :ListT<'U>
          static member inline instance (CatchError,  m:SeqT<'U> , _:SeqT<'U>  ) = fun (h:'e -> SeqT<'U>) -> 
              SeqT ( (fun v h -> Inline.instance (CatchError, v) h) (SeqT.run m) (SeqT.run << h) ) :SeqT<'U>
          static member        instance (CatchError, m:Choice<'v,'t>, _:Choice<'v,'e>) = fun (h:'t -> Choice<'v,'e>) -> Error.catch h m
          static member        instance (CatchError, m:'t * 'v, _:'e * 'v) = fun (h:'t -> 'e * 'v) -> h (fst m)
  
      let inline throwError x   = Inline.instance  ThrowError x
      let inline catchError v h = Inline.instance (CatchError, v) h
  