anchor.diff:  type CaptureParams = 
       {
           Begin: string
  -        Delim: string option
  +        Delims: DelimType list
           End: string
           Func: ExprTypes list -> ExprTypes
       }
  
positive.code: 
  let captureTypes = 
      [
          { Begin = "(";    Delim = None;       End = ")";  Func = (function | [] -> Unit | exprs -> SubExpression exprs) }
          { Begin = "(";    Delim = Some ",";   End = ")";  Func = (fun exprs -> Tuple exprs) }
          { Begin = "[";    Delim = None;       End = "]";  Func = (fun exprs -> IndexArgs <| SubExpression exprs) }
          { Begin = "let";  Delim = Some "=";   End = "in"; Func = bindFunction }
          { Begin = "var";  Delim = Some "=";   End = "in"; Func = bindFunction }
          { Begin = "(fun"; Delim = Some "->";  End = ")";  Func = generateLambda }
      ]
  
  let (|CaptureDelim|_|) currentCaptures (text: string) =
      let matches, str = [ for cc in currentCaptures do if cc.Delim.IsSome && text.StartsWith cc.Delim.Value then yield cc ] |> List.allMaxBy (fun ct -> ct.Delim.Value.Length)
      match matches with
      | [] -> None
      | onecap :: [] -> Some ([onecap], text.Substring(onecap.Delim.Value.Length))
      | caps -> Some (caps, text.Substring(str))
  
  let (|CaptureEnd|_|) currentCaptures (text: string) =
      let matches, str = [ for cc in currentCaptures do if text.StartsWith cc.End then yield cc ] |> List.allMaxBy (fun ct -> ct.End.Length) 
  
negative.code:                 match captures with
                  | [] -> failwith "Unexpected end of subexpression"
                  | h :: [] -> h
                  | list -> list |> List.filter (fun cap -> List.isEmpty cap.Delims) |> (function | h :: [] -> h | _ -> failwith "Ambiguous end of subexpression")
              let value = subExprs |> List.rev |> exprConstraint.Func 
              parseProgramInner rem (value :: result) currentCaptures
          | CaptureDelim currentCaptures (cParams, crem) -> 
  