anchor.diff:  
   [<AutoOpen>]
   module Operators =
  -    [<Arrow>]
  -    let (-->) (source:'T) (value:'T) = ()+    let [<Arrow>] (-->) (source:'T) (value:'T) = ()
positive.code:         | expr -> 
              raise <| NotSupportedException(expr.ToString())
      /// Converts expression to a tuple of MethodInfo, Arg array and Result
      let rec toCallValue abstractType = function
          | Sequential(x,y) ->
              toCallValue abstractType x @ toCallValue abstractType y
          | Call(None, mi, [lhs;rhs]) when hasAttribute typeof<ArrowAttribute> mi -> 
              let mi, args = toCall abstractType lhs
              let returns = ReturnValue(rhs.EvalUntyped(), mi.ReturnType)
  
negative.code:         // Generate body
          genBody il
          il.Emit(OpCodes.Ret)
  
      /// Defines method
      let defineMethod (typeBuilder:TypeBuilder) (abstractMethod:MethodInfo) =
          let attr = MethodAttributes.Public ||| MethodAttributes.HideBySig ||| MethodAttributes.Virtual
          let args = abstractMethod.GetParameters() |> Array.map (fun arg -> arg.ParameterType)
          typeBuilder.DefineMethod(abstractMethod.Name, attr, abstractMethod.ReturnType, args)
  
      /// Generates method overload args match
      let generateArgs 
          (il:ILGenerator) (argsLookup:ResizeArray<Value[]>,argsField:FieldBuilder) 
  