anchor.diff: -﻿namespace FsControl.Core.Abstractions
  +namespace FsControl.Core.Abstractions
   
   open System
  +open System.Collections
  +open Microsoft.FSharp.Quotations
   open FsControl.Core.Prelude
   open FsControl.Core.Types
   open Monoid
  
positive.code: // Functor class ----------------------------------------------------------
  
  module Functor =
      type DefaultImpl =         
          static member inline MapFromApplicative f x = pure' f <*> x
          static member inline MapFromMonad f x = x >>= (pure' << f)
  
      type Map = Map with
          static member instance (Map, x:option<_>    , _) = fun f -> Option.map  f x
          static member instance (Map, x:List<_>      , _:List<'b>) = fun f -> List.map f x :List<'b>
          static member instance (Map, g:_->_         , _) = (>>) g
          static member instance (Map, (m,a)          , _) = fun f -> (m, f a)
          static member instance (Map, x:array<_>     , _) = fun f -> Array.map   f x
          static member instance (Map, x:_ [,]        , _) = fun f -> Array2D.map f x
          static member instance (Map, x:_ [,,]       , _) = fun f -> Array3D.map f x
          static member instance (Map, x:_ [,,,]      , _) = fun f ->
              Array4D.init (x.GetLength 0) (x.GetLength 1) (x.GetLength 2) (x.GetLength 3) (fun a b c d -> f x.[a,b,c,d])
          static member instance (Map, x:Async<_>   , _) = fun f -> DefaultImpl.MapFromMonad f x
          static member instance (Map, x:Nullable<_>, _) = fun f -> if x.HasValue then Nullable(f x.Value) else Nullable()
          static member instance (Map, x:Choice<_,_>, _) = fun f -> Error.map f x
          static member instance (Map, x:Map<'a,'b> , _) = fun (f:'b->'c) -> Map.map (const' f) x : Map<'a,'c>
  
      let inline internal fmap   f x = Inline.instance (Map, x) f
  
      
      let inline internal sequence ms =
          let k m m' = m >>= fun (x:'a) -> m' >>= fun xs -> (pure' :list<'a> -> 'M) (List.Cons(x,xs))
          List.foldBack k ms ((pure' :list<'a> -> 'M) [])
  
negative.code:             | (Choice1Of2 a, Choice1Of2 b) -> Choice1Of2 (a b)
              | (Choice2Of2 a, _)            -> Choice2Of2 a
              | (_, Choice2Of2 b)            -> Choice2Of2 b :Choice<'b,'e>
  
          static member        instance (Apply, f:Map<'k,_>   , x:Map<'k,'a>   , _:Map<'k,'b>   ) :unit->Map<'k,'b> = fun () -> Map.ofSeq (seq {
              for e in f do
                  let k,v = e.Key, e.Value
                  if Map.containsKey k x then yield (k, f.[k] x.[k])})
  
          static member        instance (Apply, f:_ Expr      , x:'a Expr      , _:'b Expr      ) = fun () -> <@ (%f) %x @> :'b Expr
  
          static member        instance (Apply, f:('a->'b) Generic.List, x:'a Generic.List, _:'b Generic.List) = fun () ->
              new Generic.List<'b>(Seq.collect (fun x1 -> Seq.collect (fun x2 -> Seq.singleton (x1 x2)) x) f) :'b Generic.List
  
          
     
      let inline internal (<*>) x y = Inline.instance (Apply, x, y) ()
  
  open Applicative
  
  
  module Alternative =
      type Empty = Empty with
  