anchor.diff:                  go (i + 1) nextNode fMap
       go 0 root []
   
  -let chooseRoute (fns:(Node->Node) list)  =
  +// choose root will apply its root node to all route mapping functions to generate Trie at compile time, function produced will take routeState (path) and execute appropriate function
  +let chooseRoute (routeState:RouteState) (fns:(Node->Node) list)  =
       let root = Node(EmptyMap)
       let rec go ls =
           match ls with
  -        | [] -> root
  +        | [] -> ()
           | h :: t ->
               h root |> ignore
               go t
       go fns
  -
  -let builtRoute = 
  -    chooseRoute [
  -        tRoute "/api" (Unchecked.defaultof<HttpHandler>)
  -        tRoute "/test" (Unchecked.defaultof<HttpHandler>)
  -]
  +    // process path fn that returns httpHandler
  +
   
   let processPath (path:string) (ipos:int) (inode:Node) : HttpHandler =
       fun succ fail ctx -> 
   
           let pathLen = path.Length
   
  -        let intParse ipos (c:char) =
  -            let mutable result = 0
  -            let rec go pos =
  -                if pos < pathLen && path.[pos] <> c then
  -                    let charDiff = path.[pos] - '0'
  -                    if -1 < charDiff && charDiff < 10 then
  -                        result <- (result * 10) + charDiff
  -                        go (pos + 1)
  -                else
  -                    (pos,result)
  -            go ipos
  -
  -       
  -
  -        let floatParse ipos (c:char) =
  -            let mutable result = 0.
  -            let rec go pos decDepth =
  -                if pos < pathLen && path.[pos] <> c then
  -                    if path.[pos] = '.' then
  -                        go (pos + 1) 1
  -                    else
  -                        let charDiff = path.[pos] - '0'
  -                        if -1 < charDiff && charDiff < 10 then
  -                            if decDepth = 0 then 
  -                                result <- (result * 10) + float charDiff
  -                                go (pos + 1) 0
  -                            else
  -                                result <- result + ((float charDiff) / (10 * decDepth))
  -
  -                else
  -                    (pos,result)
  -            go ipos 0
  -
  -
  -
  -        let stringParse ipos (c:char) =
  -            let result = System.Text.StringBuilder()
  -            let rec go pos =
  -                if pos < pathLen && path.[pos] <> c  then
  -                    result.Append path.[pos]
  -                    go (pos + 1)
  -                else
  -                    (pos, result.ToString())
  -            go ipos
  -
  -        let stringParse2 path ipos fpos = path.Substring(ipos,fpos - ipos)
   
           let findClosure (path:string) ipos (inode:Node) =
               let pathLen = path.Length
  
positive.code: and RouteCont<'T> =
  | EmptyMap
  | HandlerMap of HttpHandler
  | MatchMap of ( char list * (Node option) * ('T -> HttpHandler))
  
  let tRoute (path:string) (fn:HttpHandler) (root:Node)=
      let fin = path.Length - 1 
      let rec go i (node:Node) =
          if i = fin then
              node.Add path.[i] (HandlerMap fn)
          else
              let nextNode = node.Add path.[i] EmptyMap
              go (i + 1) nextNode
      go 0 root
  
  let tRoutef (path : StringFormat<_,'U>) (fn:'U -> HttpHandler) (root:Node)=
      let fin = path.Value.Length - 1 
      let rec go i (node:Node) (fMap:char list) =
          if i = fin then
              node.Add path.Value.[i] (MatchMap( fMap , None ))
          else
              if path.Value.[i] = '%' then
                  let fmtChar = path.Value.[i + 1] ///HACK fix out of bounds gap
                  if formatStringMap.ContainsKey fmtChar then
                      let nMatchMap = fmtChar :: fMap
                      let newNodeBranch = Node(EmptyMap)
                      node.RouteFn <- MatchMap( nMatchMap , Some newNodeBranch )
                      go (i + 2) newNodeBranch nMatchMap
                  else
  
negative.code:             else None
          go ipos x
  
          /// Multiple Edge designs possible, for now use simple dictionary over sorted array w/ binary search
  
          // let rec go l r = 
          //     if l > r then 
  