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:     let names = List.map snd proto.VPPars
      match (findDuplicates names) with
      | [] -> ok proto
      | ds -> Bad <| List.map (fun d -> VPEDuplicateParam (proto, d)) ds
  
  /// Checks a view prototype and converts it to an associative pair.
  let modelViewProto proto =
  
negative.code:                        DefViews = ()
                         Axioms = () }
  
             let! constraints = modelConstraints imod collated
                                |> mapMessages MEConstraint
  
             (* Now add in the constraints.  This is a different type from
              * imod, so it isn't convenient to use mutation or
              * {imod with...}.  For now, we create an entirely new model.
              *)
             let pmod = {Context = ctx
                         Globals = globals
                         Locals = locals
                         VProtos = vprotos
                         DefViews = constraints
                         Axioms = () }
             let! axioms = modelAxioms pmod collated.CMethods
                           |>mapMessages MEAxiom
  
             return (withAxioms axioms pmod) }
  
  /// Converts a collated script to a model.
  let model = modelWith (new Context ())
  