anchor.diff:              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 
  
positive.code: open FSharp.Core.Printf
  open System.Collections.Generic
  
  
  let stringParse2 (path:string) ipos fpos = path.Substring(ipos,fpos - ipos)
  
  let intParse2 (path:string) ipos fpos =
      let mutable result = 0
      for pos in ipos .. fpos do 
          let charDiff = int path.[pos] //- '0'
          if -1 < charDiff && charDiff < 10 then
              result <- (result * 10) + charDiff
      result
  
  let floatParse2 (path:string) ipos fpos =
      let mutable result = 0.
      let mutable decPlaces = 0.
      let negNumber = path.[ipos] = '-'
      for pos in ipos .. fpos do
          if path.[pos] = '.' then
              decPlaces <- 1.
          else
              let charDiff = float path.[pos] // - '0'
              if -1. < charDiff && charDiff < 10. then
                  if decPlaces = 0. then 
                      result <- (result * 10.) + float charDiff
                  else
                      result <- result + ((float charDiff) / (10. * decPlaces))
      if negNumber then result * -1. else result
  
  let formatStringMap =
      dict [
      // Char    Regex                    Parser
      // ----------------------------------------------------------
          'b', (bool.Parse >> box)  // bool
          'c', (char       >> box)  // char
          's', (              box)  // string
          'i', (int32      >> box)  // int
          'd', (int64      >> box)  // int64
          'f', (float      >> box)  // float
      ]
  
  type Node(iRouteFn:RouteCont<'T>) = 
      let edges = Dictionary<char,Node>()
  
negative.code: and RouteCont<'T> =
  | EmptyMap
  | HandlerMap of HttpHandler
  | MatchMap of ( (char list) * (Node option) * ('T -> HttpHandler) )
  
  // test construction of Node Trie using node mapping functions
  ////////////////////////////////////////////////////
  
  // Simple route that iterates down nodes and if function found, execute as normal
  let tRoute (path:string) (fn:HttpHandler) (root:Node)=
      let last = path.Length - 1 
      let rec go i (node:Node) =
          if i = last then
              node.Add path.[i] (HandlerMap fn)
          else
              let nextNode = node.Add path.[i] EmptyMap
              go (i + 1) nextNode
      go 0 root
  
  // parsing route that iterates down nodes, parses, and then continues down further notes if needed
  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] = '%' && i + 1 < fin then
                  let fmtChar = path.Value.[i + 1]
                  if formatStringMap.ContainsKey fmtChar then
                      let nMatchMap = fmtChar :: fMap
                      let newNodeBranch = Node(EmptyMap) //doublr check logic & relation to i + 1 = 2
                      node.RouteFn <- MatchMap( nMatchMap , Some newNodeBranch )
                      go (i + 2) newNodeBranch nMatchMap
                  else
  