anchor.diff:  open FParsec
   open TypeShape
   
  -type Parser<'T> = Parser<'T, unit>
  +[<AutoOpen>]
  +module Utils =
  +    type Parser<'T> = Parser<'T, unit>
   
  -let inline delay (f : unit -> 'T) : Parser<'T> =
  -    fun stream -> Reply(f ())
  +    let inline delay (f : unit -> 'T) : Parser<'T> =
  +        fun stream -> Reply(f ())
   
  -let fold (folder : 'S -> 'T -> 'S) 
  -            (init : Parser<'S>) (parsers : Parser<'T> []) 
  -            (sep : Parser<'Sep>) : Parser<'S> =
  +    /// Parser folding combinator with separator support
  +    let fold (folder : 'State -> 'T -> 'State) 
  +                (init : Parser<'State>) (parsers : Parser<'T> []) 
  +                (sep : Parser<'Sep>) : Parser<'State> =
   
  -    fun stream ->
  -        let mutable state = init stream
  -        if state.Status <> Ok then state else
  -        let mutable success = true
  -        let mutable i = 0
  -        let n = parsers.Length
  -        while i < n && success do
  -            if i > 0 then 
  -                let r = sep stream 
  -                if r.Status <> Ok then
  -                    success <- false
  -                    state <- Reply(r.Status, r.Error)
  +        fun stream ->
  +            let mutable state = init stream
  +            if state.Status <> Ok then state else
  +            let mutable success = true
  +            let mutable i = 0
  +            let n = parsers.Length
  +            while i < n && success do
  +                if i > 0 then 
  +                    let r = sep stream 
  +                    if r.Status <> Ok then
  +                        success <- false
  +                        state <- Reply(r.Status, r.Error)
   
  -            if success then
  -                let r = parsers.[i] stream
  -                if r.Status <> Ok then
  -                    success <- false
  -                    state <- Reply(r.Status, r.Error)
  -                else
  -                    state <- Reply(folder state.Result r.Result)
  +                if success then
  +                    let r = parsers.[i] stream
  +                    if r.Status <> Ok then
  +                        success <- false
  +                        state <- Reply(r.Status, r.Error)
  +                    else
  +                        state <- Reply(folder state.Result r.Result)
   
  -            i <- i + 1
  +                i <- i + 1
   
  -        state
  +            state
   
  +
  +/// Generates a parser for given type
   let rec mkParser<'T> () : string -> 'T = 
       let fp = mkFParser<'T>() in 
       fun inp -> 
  
positive.code: 
  type Foo = { A : int ; B : string }
  
  and Bar =
      | Foo of Foo
      | Bar of int
  
  let p3 = mkParser<Bar list []>()
  
  p3 """ [| [ Bar(42) ; Foo({ A = 12 ; B = "Foof" })] |] """
negative.code:                 let init = delay shape.CreateUninitialized
                  let eps = shape.Elements |> Array.map mkMemberParser
                  let composed = combineMemberParsers init eps (token ",")
                  wrap(paren composed) }
  
      | Shape.FSharpRecord s ->
          s.Accept { new IFSharpRecordVisitor<Parser<'T>> with
  