anchor.diff:      let withDeps = 
           deps
           |> List.map (fst >> toDependency)
  -        |> List.fold addDep withOutput
  +        |> List.fold addDependency withOutput
       
       // If project refs will not be packaged, add the assembly to the package
       let withDepsAndIncluded = 
  
positive.code:                 Description = d }
      | _ -> Invalid
  
  let mergeMetadata template md' = 
      match template with
      | { Contents = ProjectInfo(md, opt) } -> 
          let completeCore = 
              match { Id = md.Id ++ md'.Id
                      Version = md.Version ++ md'.Version
                      Authors = md.Authors ++ md'.Authors
                      Description = md.Description ++ md'.Description } with
              | Invalid -> 
                  failwithf 
                      "Incomplete mandatory metadata in template file %s (even including assembly attributes)\nTemplate: %A\nAssembly: %A" 
                      template.FileName md md'
              | Valid c -> c
          { template with Contents = CompleteInfo(completeCore, opt) }
      | _ -> template
  
  let toDependency (templateFile : TemplateFile) = 
      match templateFile with
      | CompleteTemplate(core, opt) -> core.Id, VersionRequirement(Minimum(core.Version), PreReleaseStatus.All)
      | IncompleteTemplate -> failwith "You cannot create a dependency on a template file with incomplete metadata."
  
  let addDep (t : TemplateFile) (d : string * VersionRequirement) = 
      match t with
      | CompleteTemplate(core, opt) -> 
          let deps = 
              match opt.Dependencies with
              | Some ds -> Some(d :: ds)
              | None -> Some [ d ]
          { FileName = t.FileName
            Contents = CompleteInfo(core, { opt with Dependencies = deps }) }
      | IncompleteTemplate -> 
          failwith "You should only try and add dependencies to template files with complete metadata."
  
negative.code:     | Some r -> 
          r.NugetPackages
          |> List.map (fun np -> np.Name.Id, dependencies.DirectDependencies.[np.Name])
          |> List.fold addDependency withDepsAndIncluded
      | None -> withDepsAndIncluded
  