anchor.diff:  
       type Tfm = PlatformMatching.ParsedPlatformPath
       type Rid = Paket.Rid
  -    let scanners =
  +    let scanners : list<AdvancedScanner<UnparsedPackageFile>> =
           [ { FolderScanner.AdvancedScanner.Name = "noSeperator";
  -            FolderScanner.AdvancedScanner.Parser = FolderScanner.check "seperator not allowed" (fun s -> not (s.Contains "/" || s.Contains "\\")) >> FolderScanner.ParseResult.box }
  +            FolderScanner.AdvancedScanner.Parser =
  +                fun upf -> 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.Parser =
  +                (fun upf ->
  +                    (FolderScanner.choose "invalid tfm" (fun plats ->
  +                    let parsed = PlatformMatching.extractPlatforms false plats
  +                    if parsed.IsNone then
  +                        traceWarnfn "Could not detect any platforms from '%s' in '%s'" plats upf.FullPath
  +                    parsed)) >> 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
  +            FolderScanner.AdvancedScanner.Parser =
  +                fun upl -> (fun rid -> { Rid = rid }) >> FolderScanner.ParseResult.ParseSucceeded >> FolderScanner.ParseResult.box }]
  +    let trySscanf pf ctx =
  +        FolderScanner.trySscanfExt ctx scanners { FolderScanner.ScanOptions.Default with IgnoreCase = true } pf ctx.PathWithinPackage
   
       let getCompileRefAssembly (p:UnparsedPackageFile) =
  -        (trySscanf "ref/%A{tfm}/%A{noSeperator}" p.PathWithinPackage : (Tfm * string) option)
  +        (trySscanf "ref/%A{tfm}/%A{noSeperator}" p : (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)
  +        (trySscanf "lib/%A{tfm}/%A{noSeperator}" p : (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)
  +            (trySscanf "runtimes/%A{rid}/lib/%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 "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 getCompileLibAssembly (p:UnparsedPackageFile) =
           // %s because 'native' uses subfolders...
  -        (trySscanf "lib/%A{tfm}/%s" p.PathWithinPackage : (Tfm * string) option)
  +        (trySscanf "lib/%A{tfm}/%s" p : (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
  
positive.code:             else
              { Path = l; File = p; Runtime = None })
          |> Option.orElseWith (fun _ ->
              (trySscanf "lib/%A{noSeperator}" p.PathWithinPackage : 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)
          |> 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)
              |> 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)
          |> Option.map (fun (l,_) -> { Path = l; File = p; Runtime = None })
          |> Option.orElseWith (fun _ ->
              (trySscanf "build/%A{noSeperator}" p.PathWithinPackage : string option)
              |> Option.map (fun (_) -> { Path = Tfm.Empty; File = p; Runtime = None }))
  
      // Build up InstallModel
  
negative.code:     let private findSpecifiers = Regex(@"%(?<formatSpec>.)({(?<inside>.*?)})?")
  
      // Extends the syntax of the format string with %A{scanner}, and uses the corresponding named scanner from the advancedScanners parameter.
      let private sscanfExtHelper context (advancedScanners:AdvancedScanner<'Context> seq) opts (pf:PrintfFormat<_,_,_,_,'t>) s : ScanResult =
          let scannerMap =
              advancedScanners
              |> Seq.map (fun s -> s.Name, s)
  