anchor.diff:  // this dictionary be created
   let tokens = lazy dict([(0x284ds, "date")])
   let game = ParaValue.Load(path, ``binary header``, ``text header``, tokens)
  -game?date |> asDate
  +game?date >>= ParaValue.asDate
  
positive.code: 
  ## Quickstart
  
  *)
  #r "Pfarah.dll"
  open Pfarah
  open Pfarah.Operators
  
  let obj = ParaValue.Parse "foo=bar"
  (**
  
  `obj` is a [discriminated union][du], and if you're not familiar with
  discriminated unions, it may be best to read up on them because that is how
  one interfaces with the data
  
  [du]: https://msdn.microsoft.com/en-us/library/dd233226.aspx
  
  ## Working with the Data
  
  *)
  
  // Print the property's keys, so this will print "foo"
  match obj with
  | ParaValue.Record properties ->
    printfn "%A" (properties |> Seq.map fst)
  | _ ->
    failwith "Expected `obj` to be a `Record` type"
  
  // Print the property's value of "foo"
  match obj with
  | ParaValue.Record properties ->
    match (Array.tryFind (fst >> (=) "foo") properties) with
    | Some(key, value) ->
      match value with
      | ParaValue.String str -> printfn "%s" str
      | _ -> failwith "Expected foo to be a string"
    | None -> failwith "Expected foo to exist"
  | _ -> failwith "Expected `obj` to be a `Record` type"
  
  (**
  
  ## Convenience Methods
  
  The methods shown are very boilerplate heavy and writing this kind of code can
  make a project become bloated very quickly. Hence why Pfarah provides a bit of
  syntactic sugar and helper methods to make dealing with the data easier.
  
  *)
  
  // The previous example of printing foo's value can be shortened to
  let obj2 = ParaValue.Parse "foo=bar"
  printfn "%s" (obj2?foo |> asString)
  
  let data = ParaValue.Parse "y={1 2 4 8 16 32}"
  printfn "%A" (data?y |> asArray |> Array.map asInteger)
  
  (**
  
  ## Dealing with Multiple Keys
  
  It is often common that the data format will have multiple keys of the same
  name on the same level, but the number of occurrences of the key in an object is
  subject to differ. In cases such as these it is best to use `collect`, which
  will aggregate values in an object with that particular key.
  
  *)
  
  let army = """
  army=
  {
      name="1st army"
      unit={
          name="1st unit"
      }
  }
  army=
  {
      name="2nd army"
      unit={
          name="1st unit"
      }
      unit={
          name="2nd unit"
      }
  }"""
  
  // Let's create a list of tuples such that the result is army name * list of
  // unit names
  let armyData =
    ParaValue.Parse army
    |> collect "army"
    |> asArray
    |> Array.map (fun x ->
      let units = x |> collect "unit" 
                    |> asArray 
                    |> Array.map (fun u -> u?name |> asString)
      x?name |> asString, units)
  printfn "%A" armyData
  
  (**
  
  ## Inconsistent Data
  
  Not all objects of a given instance will have the exact same property keys.
  Some may only have a limited subset of the properties wanted. The `tryFind`
  function will return `Some ParaValue` if the property exists and `None` if it
  doesn't.
  
  *)
  
  let ships = """
  ship={
      name="1st ship"
      patrol=yes
  }
  ship={
    name="2nd ship"
  }"""
  
  // Let's print the name of ships on patrol
  let shipData =
    ParaValue.Parse ships
    |> collect "ship"
    |> asArray
    |> Array.filter (tryFind "patrol" >> Option.isSome)
    |> Array.map (fun x -> x?name |> asString)
  printfn "%A" armyData
  
  (**
  
  `tryFind` is also useful when dealing with nested data. If you have `A.B.C` and
  you aren't sure if `A`, `B`, or `C` exists, you can use `tryFind` in conjuntion
  with `Option.bind` to select `C`'s value or `None`
  
  *)
  
  let nested = "A={B={C=1.000}}"
  let cvalue =
    ParaValue.Parse nested
    |> tryFind "A"
    |> Option.bind (tryFind "B")
    |> Option.bind (tryFind "C")
  
  match cvalue with
  | Some(x) -> printfn "C's value: %f" (x |> asFloat)
  | None -> printfn "C didn't exist!"
  
  // Or a bit more concise if you're just dealing with values.
  printfn "C's value: %f" (cvalue |> floatDefault)
  
  // floatDefault will assume that if the value exists that it is
  // a float. If the value doesn't exist then it will return 0.0
  
  (**
  
  ## Exploring Data
  
  Knowing the data is the first step to any type of analysis. This is made
  difficult when there can be thousands of objects, each one having a subset of
  
negative.code: // This block of code is omitted in the generated HTML documentation. Use
  // it to define helpers that you do not want to show in the documentation.
  #I "../../bin"
  #r "Pfarah.dll"
  open System
  
  (**
  # Introducing Pfarah
  
  This document is a quick overview of the most important features of Pfarah.
  You can also get this page as an [F# script file from GitHub][fscript] and run
  the samples interactively. Type annotations are used in examples to ease
  understanding
  
  [fscript]: https://github.com/nickbabcock/Pfarah/blob/master/docs/content/tutorial.fsx
  
  