anchor.diff:  
   /// Converts a collated script to a model with the given context.
   let modelWith ctx collated =
  -    trial {let! vprotos = mapMessages MEVProto (modelViewProtos collated.CVProtos)
  -           let! globals = mapMessages MEVar (makeVarMap ctx collated.CGlobals)
  -           let! locals = mapMessages MEVar (makeVarMap ctx collated.CLocals)
  -
  +    trial {let! vprotos = modelViewProtos collated.CVProtos |> mapMessages MEVProto 
  +           // Make variable maps out of the global and local variable definitions.
  +           let! globals = makeVarMap ctx collated.CGlobals
  +                          |> mapMessages MEVar
  +           let! locals = makeVarMap ctx collated.CLocals
  +                         |> mapMessages MEVar
  +
  +           (* We use a 'partial' model, with no defining views or
  +            * axioms, in the creation of the constraints.
  +            *)
              let imod = {Context = ctx
                          Globals = globals
                          Locals = locals
  
positive.code:  *)
  
  /// Active pattern classifying bops as to whether they create
  /// arithmetic or Boolean expressions
  let (|ArithOp|BoolOp|) bop =
      match bop with
      | Mul -> ArithOp
      | Div -> ArithOp
      | Add -> ArithOp
      | Sub -> ArithOp
      | Gt -> BoolOp
      | Ge -> BoolOp
      | Le -> BoolOp
      | Lt -> BoolOp
      | Eq -> BoolOp
      | Neq -> BoolOp
      | And -> BoolOp
      | Or -> BoolOp
  
  /// Active pattern classifying bops as to whether they take in
  /// arithmetic, Boolean, or indeterminate operands.
  let (|ArithIn|BoolIn|AnyIn|) bop =
      match bop with
      | Mul -> ArithIn
      | Div -> ArithIn
      | Add -> ArithIn
      | Sub -> ArithIn
      | Gt -> ArithIn
      | Ge -> ArithIn
      | Le -> ArithIn
      | Lt -> ArithIn
      | Eq -> AnyIn
      | Neq -> AnyIn
      | And -> BoolIn
      | Or -> BoolIn
  
  /// Active pattern classifying expressions as to whether they are
  /// arithmetic, Boolean, or indeterminate.
  
negative.code:     let names = List.map snd proto.VPPars
      match (findDuplicates names) with
      | [] -> ok proto
      | ds -> List.map (fun d -> VPEDuplicateParam (proto, d)) ds |> Bad
  
  /// Checks a view prototype and converts it to an associative pair.
  let modelViewProto proto =
  