anchor.diff:                  |> List.ofSeq)
               | Sequence (_, _, linkItem) ->
                   let s = value :?> seq<obj>
  -                ([[string (Seq.length s)]], s)
  -                ||> Seq.fold (fun a b -> linkItem b :: a)
  -                |> List.rev
  -                |> List.concat
  +                string (Seq.length s) ::
  +                (value :?> seq<obj>
  +                |> Seq.collect linkItem
  +                |> List.ofSeq)
  +            | Tuple items ->
  +                (items, (value :?> obj[]))
  +                ||> Seq.map2 (fun (_, link) x -> link x)
  +                |> Seq.concat
  +                |> List.ofSeq
   
       static member ``System.String``(x: list<string>) =
           match x with
  
positive.code:     | Base of ParseFunc // assuming string as LinkFunc
      | Object of ctor: (unit -> obj) * name: option<string> * args: RouteObjectArgs
      | Sequence of fromArray: (array<obj> -> obj) * parseItem: ParseFunc * linkItem: LinkFunc
  //    | Tuple of items: array<ParseFunc * LinkFunc>
  
  and private MetaRootShape =
      | MetaBase of parse: Method
      | MetaObject of ctor: Expression * name: option<string> * args: list<string * System.Type>
      | MetaSequence of fromArray: Expression * item: Type
  //    | MetaTuple of items: list<System.Type>
  
  and private RouteMapBuilderMacro(comp: Metadata.Compilation) =
      inherit Macro()
  
negative.code:             let parseArgs (init: unit -> obj) (rest: list<string>) (args: RouteObjectArgs) =
                  let v = init()
                  (Some rest, args)
                  ||> Array.fold (fun rest (name, parse, _) ->
                      match rest with
                      | None -> None
                      | Some rest ->
  