anchor.diff:  //        { Pattern = [SCap "loop"; SCap "{"; SCap "}"];              Func = generateLoop }
       ]
   
  -let startingExpressionType =
  -    { Pattern = [Open]; Func = (fun exprs -> SubExpression exprs) }
  -
  -let (|FirstExpression|_|) (typesStack: SubexpressionType list) (text: StringWindow) =
  -    match typesStack with
  -    | [] -> Some (startingExpressionType, text)
  -    | _ -> None
  +let allSimpleTypes = 
  +    [
  +        ["."], Invoke
  +        ["()"], Unit
  +        ["null"], Obj null
  +        ["true"], Obj true
  +        ["false"], Obj false
  +        ["=="; "="], Infix (3, objectsEqual)
  +        ["<>"; "!="], Infix (3, objectsNotEqual)
  +        [">="], Infix (3, compareObjects (>=))
  +        ["<="], Infix (3, compareObjects (<=))
  +        [">"], Infix (3, compareObjects (>))
  +        ["<"], Infix (3, compareObjects (<))
  +        ["!"; "not"], Prefix notOp
  +        ["&"; "&&"; "and"], Infix (4, andOp)
  +        ["|"; "||"; "or"], Infix (4, orOp)
  +        ["/"], Infix (1, divideObjects)
  +        ["*"], Infix (1, multObjects)
  +        ["+"], Infix (2, addObjects)
  +        ["-"], Infix (2, subObjects)
  +    ]
  +
  +let (|Skip|_|) (skipStrs: string list) (text: StringWindow) =
  +    skipStrs 
  +    |> List.tryFind (fun sstr -> text.StartsWith(sstr))
  +    |> Option.map (fun m -> None, text.Subwindow(m.Length))
  +
  +
  +let (|MapSymbol|_|) (text: StringWindow) =
  +    let matches, str = 
  +        [
  +            for matchStrs, expr in allSimpleTypes do
  +                for matchStr in matchStrs do
  +                    if text.StartsWith(matchStr) then yield matchStr, expr
  +        ] |> List.allMaxBy (fun (m, expr) -> m.Length)
  +    match matches with
  +    | [] -> None
  +    | [(matched, expr)] -> Some (Some(expr), text.Subwindow(matched.Length))
  +    | _ -> failwith (sprintf "Ambiguous symbol match: %A" matches)
   
   let (|NewExpression|_|) (typesStack: SubexpressionType list) (text: StringWindow) =
       let matches, str = 
  
positive.code:             | NewExpression currentCaptures (subtype, crem) ->
                  let rem, value = parseProgramInner crem [SubExpression []] (subtype :: currentCaptures)               
                  parseProgramInner rem (SubExpression (value :: cSubExpr) :: rSubExprs) currentCaptures
              | Skip " " res
              | Skip "\t" res
              | Skip "\r" res
              | Skip "\n" res
              | StrToVal "." Invoke res
              | StrToVal "()" Unit res
              | StrToVal "null" (Obj null) res
              | StrToVal "true" (Obj true) res 
              | StrToVal "false" (Obj false) res 
              | StrsToVal ["=="; "="] (Infix (3, objectsEqual)) res 
              | StrsToVal ["<>"; "!="] (Infix (3, objectsNotEqual)) res
              | StrToVal ">=" (Infix (3, compareObjects (>=))) res
              | StrToVal "<=" (Infix (3, compareObjects (<=))) res
              | StrToVal ">" (Infix (3, compareObjects (>))) res
              | StrToVal "<" (Infix (3, compareObjects (<))) res 
              | StrsToVal ["!"; "not"] (Prefix notOp) res
              | StrsToVal ["&"; "&&"; "and"] (Infix (4, andOp)) res
              | StrsToVal ["|"; "||"; "or"] (Infix (4, orOp)) res 
              | StrToVal "/" (Infix (1, divideObjects)) res
              | StrToVal "*" (Infix (1, multObjects)) res
              | StrToVal "+" (Infix (2, addObjects)) res 
              | StrToVal "-" (Infix (2, subObjects)) res
              | TextCapture '"' res
              | TextCapture ''' res 
              | Num res ->
  
negative.code:         member t.Item with get(x) = t.Text.[x + t.Offset]
          override t.ToString () = t.Text.Substring(t.Offset) 
  
  
  type DelimType =
      | Open
  