anchor.diff:          s.Accept {
               new IFSharpOptionVisitor<Parser<'T>> with
                   member __.Visit<'t> () =
  -                    let tp = mkFParser<'t>() |>> Some
  +                    let tp = genParser<'t>() |>> Some
                       let nP = stringReturn "None" None
                       let vp = attempt (paren tp) <|> tp
                       let sP = token "Some" >>. vp
  
positive.code:     | _ -> failwithf "unsupported type '%O'" typeof<'T>
  
  
  // examples
  
  let p1 = mkParser<int * int list>()
  
negative.code: open FParsec
  open TypeShape
  
  type Parser<'T> = Parser<'T, unit>
  
  let inline delay (f : unit -> 'T) : Parser<'T> =
      fun _ -> Reply(f())
  
  let (<*>) (f : Parser<'T -> 'S>) (t : Parser<'T>) : Parser<'S> = 
      parse {
          let! tv = t
          let! fv = f
          return fv tv
      }
  
  /// Generates a parser for supplied type
  let rec genParser<'T> () : Parser<'T> =
      let spaced p = between spaces spaces p
      let token str = spaced (pstring str) >>% ()
      let paren p = between (token "(") (token ")") p
      let wrap (p : Parser<'a>) = unbox<Parser<'T>>(spaced p)
  
      let mkMemberParser (shape : IShapeWriteMember<'Class>) =
          shape.Accept { new IWriteMemberVisitor<'Class, Parser<'Class -> 'Class>> with
              member __.Visit (shape : ShapeWriteMember<'Class, 'Field>) =
                  let fp = genParser<'Field>()
                  fp |>> fun f dt -> shape.Inject dt f
          }
  
      let combineMemberParsers 
          (init : Parser<'Class>) 
          (injectors : Parser<'Class -> 'Class> [])
          (separator : Parser<'Sep>) =
  
          match Array.toList injectors with
          | [] -> init
          | hd :: tl -> List.fold (fun acc i -> (separator >>. i) <*> acc) (hd <*> init) tl
  
      match shapeof<'T> with
      | Shape.Unit -> wrap(paren spaces)
  