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: 
      let inline internal tell   x = Inline.instance  Tell x
      let inline internal listen m = Inline.instance (Listen, m) ()
      let inline internal pass   m = Inline.instance (Pass  , m) ()
  
negative.code: module MonadCont =
      type CallCC = CallCC with
          static member instance (CallCC, _:OptionT<Cont<'r,option<'a>>>) = fun (f:((_ -> OptionT<Cont<_,'b>>) -> _)) -> OptionT(Cont.callCC <| fun c -> OptionT.run(f (OptionT << c << Some)))     :OptionT<Cont<'r,option<'a>>>
          static member instance (CallCC, _:ListT<Cont<'r ,  List<'a>>> ) = fun (f:((_ -> ListT<Cont<_,'b>>  ) -> _)) -> ListT  (Cont.callCC <| fun c ->   ListT.run(f (ListT << c << List.singleton))):ListT<Cont<'r, List<'a>>>
          static member instance (CallCC, _: SeqT<Cont<'r ,  seq<'a>>>  ) = fun (f:((_ -> SeqT<Cont<_,'b>>   ) -> _)) -> SeqT   (Cont.callCC <| fun c ->   SeqT.run (f (SeqT  << c << Seq.singleton ))):SeqT<Cont<'r ,  seq<'a>>>
          static member instance (CallCC, _:Cont<'r,'a>) = Cont.callCC : (('a -> Cont<'r,'b>) -> _) -> _
  
      let inline internal callCC f = Inline.instance CallCC f
  