anchor.diff:  
               ]
   
  +
  +        let rec (|SeqCons|_|) (e : Expr) =
  +            match e with
  +                | Unit ->
  +                    None
  +
  +                | Sequential(SeqCons(head, tail), r) ->
  +                    let tail = 
  +                        match tail with
  +                            | Some t -> Expr.Sequential(t, r) |> Some
  +                            | None -> Some r
  +                    Some (head, tail)
  +                    
  +
  +                | e -> 
  +                    Some (e, None)
  +  
  +        let rec (|SeqCons2|_|) (e : Expr) =
  +            match e with
  +                | SeqCons(a, Some (SeqCons(b, c))) ->
  +                    Some (a,b,c)
  +                | _ ->
  +                    None
  +   
           let rec evaluateConstantsS (e : Expr) =
               state {
                   match e with
  
positive.code:                                 return Expr.Value(mi.Invoke(lambda, [|arg|]), e.Type)
                              | _ ->
                                  return Expr.Application(lambda, arg)
  
                      | ForInteger(v, first, step, last, body) ->
                          let! first = evaluateConstantsS first
  
negative.code: 
                      | DefaultValue t ->
                          return Expr.DefaultValue t
  
                      | FieldGet(None, f) ->
                          let! n = State.needsField f
  