anchor.diff:      static member Append  (WrappedListC l, WrappedListC x) = WrappedListC (l @ x)
       static member Empty   = WrappedListC List.empty
       static member Concat  (lst: seq<WrappedListC<_>>)  = Seq.head lst
  +
  +type WrappedListD<'s> = WrappedListD of 's list with
  +    interface Collections.Generic.IEnumerable<'s> with member x.GetEnumerator() = (let (WrappedListD x) = x in x :> _ seq).GetEnumerator()
  +    interface Collections.IEnumerable             with member x.GetEnumerator() = (let (WrappedListD x) = x in x :> _ seq).GetEnumerator() :> Collections.IEnumerator
  +    static member Return  (x) = WrappedListD [x]
  +    static member Bind ((WrappedListD x):WrappedListD<'T>, f) = WrappedListD (List.collect (f >> (fun (WrappedListD x) -> x)) x)
  +
   
   [<TestClass>]
   type Monoid() =
  
positive.code:     let inline (/>) x = flip x
      let inline choice f g = function Choice2Of2 x -> f x | Choice1Of2 y -> g y
      let inline option n f = function None -> n | Some x -> f x
  
  open Combinators
  
  
  
  
  
  type WrappedListA<'s> = WrappedListA of 's list with
  
negative.code:         let s' = sortBy id s
          Assert.AreEqual (l', [4;6;10;89])
          Assert.AreEqual (s', WrappedListB [4;6;10;89])
  
  
  [<TestClass>]
  type Monad() = 
      [<TestMethod>]
      member x.WorkFlow() =     
          let testVal = 
              monad {
                  let! x1 = WrappedListD [1;2]
                  let! x2 = WrappedListD [10;20]
                  return ((+) x1 x2) }
          Assert.IsInstanceOfType (testVal, typeof<WrappedListD<int>>)
  
  
  
  [<TestClass>]
  