anchor.diff:      let pGlobalSection : Parser<_> = pstring "GlobalSection"
       let pEndGlobalSection : Parser<_> = pstring "EndGlobalSection"
   
  -    let pheader = manyCharsTill anyChar ^ lookAhead pProject
  -
  -    let pGuid: Parser<Guid> = between ``{`` ``}`` ^ manySatisfy isGuid |>> Guid.Parse
  -
  -    let quoteGuid = ``"`` >>. pGuid .>> ``"``
  -
  -    let projGuid: Parser<Guid> = ``(`` >>. quoteGuid .>> ``)``
  -
  -    let quoted: Parser<_> = between ``"`` ``"`` ^ manyCharsTill anyChar ^ lookAhead ``"``
  -
  -    let projectHeading =  skipEqs >>. (quoted .>> skipCom) .>>. (quoted .>> skipCom) .>>. quoteGuid .>> spaces
  -
  -
  -    let internal parseProjectBase itemPsr = 
  -        let projectSection itempsr = 
  -            spaces >>. between (pProjectSection .>> skipRestOfLine true) pEndProjectSection
  -                (manyTill itempsr ^ lookAhead pEndProjectSection)
  -        let solutionItems: Parser<_> = 
  -            let customContentParser = projectSection itemPsr
  -            choice [
  -                customContentParser
  -                preturn [] // when we encounter folders without soultion items return an empty list
  -            ]
  -        projectHeading .>>. solutionItems .>> spaces
  -
  -
  -    let pitem = spaces >>. notspace .>> skipEqs .>>. notspace .>> spaces
  -
  -    let parseFolder = parseProjectBase pitem
  -
  -
  -    let parseProject =
  -        let dependency = spaces >>. pGuid .>> skipRestOfLine true .>> spaces
  -        parseProjectBase dependency
  -
  -
  -    let projectSections : Parser<_> = 
  -        let rawProject = 
  -            spaces >>. between pProject pEndProject 
  -                (projGuid .>>. many1CharsTill  anyChar ^ lookAhead pEndProject) .>> spaces
  -        manyTill rawProject ^ lookAhead pGlobal
  -        |>> fun pls ->
  -        pls |> List.partition ^ fun (guid,_) -> guid = solutionFolderGuid 
  -        |> fun (folders, projects) ->
  -
  -            let runSubParser psr mapfn (xs:(Guid * string) list) =
  -                xs |> List.map (fun (projGuid,txt) -> 
  -                match run psr txt with
  -                | Failure (errormsg, err, _)  -> 
  -                    failwithf  "Could not parse -\n%s\n\n%s" txt errormsg
  -                | Success (result, _, _) -> mapfn projGuid result
  -                )
  -
  -            let makeFolder projGuid (((name,path),guid),solutionItems) =
  -                {   SolutionFolder.ProjectTypeGuid = projGuid
  -                    Name = name
  -                    Path = path
  -                    Guid = guid
  -                    SolutionItems = 
  -                        solutionItems |> List.map (fun (n,p) -> { Name = n; Path = p}) 
  -                }
  -
  -            let makeProject projGuid (((name,path),guid),guids) =
  -                {   Project.ProjectTypeGuid = projGuid
  -                    Name = name
  -                    Path = path
  -                    Guid = guid
  -                    Dependecies = guids
  -                }
  -            let solutionFolders  = folders  |> runSubParser parseFolder makeFolder
  -            let solutionProjects = projects |> runSubParser parseProject makeProject
  -            solutionFolders, solutionProjects
  +
  +    /// Parsers a Guid inside of { }
  +    let pGuid: Parser<Guid> = 
  +        let psr = between ``{`` ``}`` ^ manySatisfy isGuid
  +        fun stream  ->
  +            let reply: _ Reply = psr stream
  +            if  reply.Status <> Ok then Reply (Error,reply.Error) else
  +            try Guid.Parse reply.Result |> Reply 
  +            with ex -> Reply (Error, expected ex.Message)
   
   
       let pSolutionConfigLine =
           spaces >>. manyCharsTill anyChar ``|`` .>>. (manyCharsTill anyChar  pEq)  .>> skipRestOfLine true
           |>> fun (name, plat) -> 
           {   SolutionConfiguration.Name = name
  -            Platform = plat.Trim() |> PlatformType.Parse
  -        }
  +            Platform = plat.Trim() |> PlatformType.Parse }
   
   
       let pProjectConfigLine =
           (spaces >>. pGuid .>> ``.``)
           .>>. (many1CharsTill anyChar ``|``)
           .>>. (many1CharsTill anyChar ``.``)
  -        .>>. (many1CharsTill anyChar ^ (spaces .>> pEq))
  +        .>>. (many1CharsTill anyChar ^ (spaces .>> pEq)) .>> skipRestOfLine true
           |>> fun (((guid,name),plat),prop) ->
               {   ProjectGuid = guid
                   ConfigName = name
                   BuildProperty = BuildProperty.Parse ^ prop.Trim()
  -                Platform = PlatformType.Parse  ^ plat.Trim()
  -            }
  +                Platform = PlatformType.Parse  ^ plat.Trim()  }
   
   
       let pNestedProjectLine : Parser<_> =
  
positive.code:         |>> fun (proj, parent) -> { Project = proj ; Parent = parent }
  
  
      let pPropertyLine = pitem |>> fun (n,v) -> { Name = n ; Value = v }
  
  
      let spwork =  many (attempt (spaces >>. pPropertyLine       .>> spaces ))
      let scwork =  many (attempt (spaces >>. pSolutionConfigLine .>> spaces ))
      let pcwork =  many (attempt (spaces >>. pProjectConfigLine  .>> spaces ))
      let npwork =  many (attempt (spaces >>. pNestedProjectLine  .>> spaces ))
  
  
      let pull_results (target:string) psr (data:(string*string)list) =
          ([],data) ||> List.fold (fun  acc (key,text) ->
              if target = key then
                  match run psr text with
                  | Failure (errormsg, err, _)  -> acc // failwithf  "Could not parse -\n%s\n\n%s" text errormsg
                  | Success (result, _, _) -> List.append acc result            
              else acc
          )
  
  
      let parseSolution = 
          let globalsection =
              spaces >>.  between pGlobalSection pEndGlobalSection
                  ((``(`` >>. many1CharsTill  anyChar  ``)`` .>> skipRestOfLine true)
                      .>>. many1CharsTill  anyChar ^ lookAhead pEndGlobalSection ) .>> spaces
          let parseGlobal = between pGlobal pEndGlobal  (manyTill globalsection ^ lookAhead pEndGlobal)
          pheader .>>.  projectSections .>>. parseGlobal
          |>> fun ((header,(folders,projects)),data) -> 
              {   Header  = header
                  Folders = folders
                  Projects = projects
                  SolutionConfigurationPlatforms = pull_results "SolutionConfigurationPlatforms" scwork data
                  ProjectConfigurationPlatforms = pull_results "ProjectConfigurationPlatforms" pcwork data
                  SolutionProperties = pull_results "SolutionProperties" spwork data
                  NestedProjects = pull_results "NestedProjects" npwork data
              }
negative.code: 
  [<AutoOpen>]
  module internal Parsers =
      let [<Literal>] FolderGuidString = "2150E333-8FDC-42A3-9474-1A3956D46DE8"
      let FolderGuid = Guid "2150E333-8FDC-42A3-9474-1A3956D46DE8"
  
      type UserState = unit
      type Parser<'t> = Parser<'t, UserState>
  