anchor.diff:              else
               { Path = l; File = p; Runtime = None })
           |> Option.orElseWith (fun _ ->
  -            (trySscanf "lib/%A{noSeperator}" p.PathWithinPackage : string option)
  +            (trySscanf "lib/%A{noSeperator}" p : string option)
               |> Option.map (fun (_) -> { Path = Tfm.Empty; File = p; Runtime = None }))
   
       let getRuntimeLibrary (p:UnparsedPackageFile) =
  -        (trySscanf "runtimes/%A{rid}/nativeassets/%A{tfm}/%A{noSeperator}" p.PathWithinPackage : (Rid * Tfm * string) option)
  +        (trySscanf "runtimes/%A{rid}/nativeassets/%A{tfm}/%A{noSeperator}" p : (Rid * Tfm * string) option)
           |> Option.map (fun (rid, l,_) -> { Path = l; File = p; Runtime = Some rid })
           |> Option.orElseWith (fun _ ->
  -            (trySscanf "runtimes/%A{rid}/native/%A{noSeperator}" p.PathWithinPackage : (Rid * string) option)
  +            (trySscanf "runtimes/%A{rid}/native/%A{noSeperator}" p : (Rid * string) option)
               |> Option.map (fun (rid, _) -> { Path = Tfm.Empty; File = p; Runtime = Some rid }))
   
       let getMsbuildFile (p:UnparsedPackageFile) =
  -        (trySscanf "build/%A{tfm}/%A{noSeperator}" p.PathWithinPackage : (Tfm * string) option)
  +        (trySscanf "build/%A{tfm}/%A{noSeperator}" p : (Tfm * string) option)
           |> Option.map (fun (l,_) -> { Path = l; File = p; Runtime = None })
           |> Option.orElseWith (fun _ ->
  -            (trySscanf "build/%A{noSeperator}" p.PathWithinPackage : string option)
  +            (trySscanf "build/%A{noSeperator}" p : string option)
               |> Option.map (fun (_) -> { Path = Tfm.Empty; File = p; Runtime = None }))
   
       // Build up InstallModel
  
positive.code: 
      type Tfm = PlatformMatching.ParsedPlatformPath
      type Rid = Paket.Rid
      let scanners =
          [ { FolderScanner.AdvancedScanner.Name = "noSeperator";
              FolderScanner.AdvancedScanner.Parser = FolderScanner.check "seperator not allowed" (fun s -> not (s.Contains "/" || s.Contains "\\")) >> FolderScanner.ParseResult.box }
            { FolderScanner.AdvancedScanner.Name = "tfm";
              FolderScanner.AdvancedScanner.Parser = FolderScanner.choose "invalid tfm" (PlatformMatching.extractPlatforms true) >> FolderScanner.ParseResult.box }
            { FolderScanner.AdvancedScanner.Name = "rid";
              FolderScanner.AdvancedScanner.Parser = (fun rid -> { Rid = rid }) >> FolderScanner.ParseResult.ParseSucceeded >> FolderScanner.ParseResult.box }]
      let trySscanf pf s =
          FolderScanner.trySscanfExt scanners { FolderScanner.ScanOptions.Default with IgnoreCase = true } pf s
  
      let getCompileRefAssembly (p:UnparsedPackageFile) =
          (trySscanf "ref/%A{tfm}/%A{noSeperator}" p.PathWithinPackage : (Tfm * string) option)
          |> Option.map (fun (l,_) -> { Path = l; File = p; Runtime = None })
  
      let getRuntimeAssembly (p:UnparsedPackageFile) =
          (trySscanf "lib/%A{tfm}/%A{noSeperator}" p.PathWithinPackage : (Tfm * string) option)
          |> Option.map (fun (l,_) -> { Path = l; File = p; Runtime = None })
          |> Option.orElseWith (fun _ ->
              (trySscanf "runtimes/%A{rid}/lib/%A{tfm}/%A{noSeperator}" p.PathWithinPackage : (Rid * Tfm * string) option)
              |> Option.map (fun (rid, l, _) -> { Path = l; File = p; Runtime = Some rid }))
          |> Option.orElseWith (fun _ ->
              (trySscanf "lib/%A{noSeperator}" p.PathWithinPackage : string option)
              |> Option.map (fun (_) -> { Path = Tfm.Empty; File = p; Runtime = None }))
  
      let getCompileLibAssembly (p:UnparsedPackageFile) =
          // %s because 'native' uses subfolders...
          (trySscanf "lib/%A{tfm}/%s" p.PathWithinPackage : (Tfm * string) option)
          |> Option.map (fun (l,path) ->
              if l.Name = "native" && l.Platforms = [ FrameworkIdentifier.Native(NoBuildMode,NoPlatform) ] then
                  // We need some special logic to detect the platform
  
negative.code:         | ScanSuccess objResults ->
              let results =
                  (objResults, advancedFormatters)
                  ||> Seq.map2 (fun r a -> match a with Some p -> p.Parser context (string r) | None -> ParseSucceeded r)
                  |> Seq.toArray
              match results |> Seq.choose (fun r -> match r with ParseError error -> Some error | _ -> None) |> Seq.tryHead with
              | Some error ->
  