anchor.diff:  let whitespace = [| " "; "\r"; "\n"; "\t"; |]
   
   let (|Num|_|) (text: StringWindow) =
  -//    let numChars = [| '0'; '1'; '2'; '3'; '4'; '5'; '6'; '7'; '8'; '9' |]
       let isnumchar c = c >= '0' && c <= '9' 
       let sb = new StringBuilder()
       if isnumchar text.[0] then
  
positive.code: 
  let parseProgram (startText: string) = 
      let rec parseProgramInner (str: StringWindow) (result: ExprTypes list) (currentCaptures: SubexpressionType list) : (StringWindow * ExprTypes) =
          match result with
          | SubExpression cSubExpr :: rSubExprs -> 
              match str with
              | FinishOpenExpression currentCaptures (subtype, crem) ->
                  let innerResult = SubExpression (cSubExpr |> List.rev) :: rSubExprs  
                  let value = innerResult |> List.rev |> subtype.Func in crem, value         
              | _ when str.Length = 0 -> str, SubExpression (SubExpression (cSubExpr |> List.rev) :: rSubExprs)            
              | OngoingExpression currentCaptures (captures, crem) ->
                  match captures with
                  // Expression is Finished
                  | { Pattern = []; Func = func } :: parents -> 
                      let innerResult = SubExpression (cSubExpr |> List.rev) :: rSubExprs  
                      let value = innerResult |> List.rev |> func in crem, value   
                  // Expression Continues
                  | { Pattern = h :: rest; Func = _ } :: parents -> parseProgramInner crem (SubExpression [] :: SubExpression (cSubExpr |> List.rev) :: rSubExprs) captures
                  | [] -> failwith "Unexpected output from OngoingExpression"
              | RefineOpenExpression currentCaptures (subtype, crem) ->
                  // Mid-Expression we've realized we're actually in a different kind.
                  let rem, value = parseProgramInner crem (SubExpression [] :: cSubExpr) (subtype :: currentCaptures)               
                  parseProgramInner rem (SubExpression ([value]) :: rSubExprs) currentCaptures    
              | NewExpression currentCaptures (subtype, crem) ->
                  let rem, value = parseProgramInner crem [SubExpression []] (subtype :: currentCaptures)               
                  parseProgramInner rem (SubExpression (value :: cSubExpr) :: rSubExprs) currentCaptures
              | Skip whitespaceVocabulary res
              | MapSymbol res
              | CaptureString '"' res
              | CaptureString ''' res 
              | Num res
              | CaptureUnknown endUnknownChars res ->
                  let v, rem = res 
                  match v with
                  | Some value -> parseProgramInner rem (SubExpression (value :: cSubExpr) :: rSubExprs) currentCaptures
                  | None -> parseProgramInner rem result currentCaptures
              | str -> parseProgramInner (str.Subwindow(1)) result currentCaptures
          | _ -> failwith "Expected a SubExpression"
      let _, res = parseProgramInner (StringWindow(startText, 0)) [SubExpression []] [] in res
  
negative.code: open Barb.Helpers
  open Barb.Interop
  open Barb.Representation
  
  type BarbParsingException (message, index) = 
      inherit Exception (message)
      member t.Index = index
  
  type StringWindow =
      struct
  