{syntax-switch source-object
                       [, index:ParseIndex = BOS]
                       [, must-match?:bool = false]
                       [case pattern do statements]
                       [case pattern do statements]...
                       [else statements]
                   } 
            

• expression
  Matches a single curl expression. This greedily consumes the largest expression it can match.
  If this pattern is named, the named source code object will be an object of type Parsed.
  The related pattern expressions matches a sequence of 0 or more expressions.
• statement
  Matches a single curl statement. This greedily consumes the largest statement it can parse.
  Statements in curl are the same as expressions, except that this invokes special parsing rules for let and set expressions, inserting the implicit curly braces around them.
  If this pattern is named, the named source code object will be an object of type Parsed.
  The related pattern statements matches a sequence of 0 or more statements.
• class-member
  Matches a single curl class member.
  A class member is defined as anything than can appear at the top level inside a class definition (field, class variable, class procedure, method, constructor, factory, getter, setter or option).
  If this pattern is named, the named source code object will be an object of type Parsed.
  The related pattern class-members matches a sequence of 0 or more class members.
• identifier
  Matches any curl identifier, such as hello.
  If this pattern is named, the named source code object will be an object of type Identifier.
  The related pattern identifiers matches a sequence of 0 or more identifiers.
• text
  Matches a sequence of text characters, up to the following curly brace expression. This is how to parse arguments as text-procs do. This pattern preserves all whitespace, and processes backslash escapes.
  If this pattern is named, the named source code object will be an object of type BaseText. Its contents as a StringInterface can be retrieved by accessing its contents property. The text with backslash escapes unprocessed can be retrieved by calling the get-text method on it.
  The related pattern texts matches a sequence of 0 or more texts.
• token
  Matches a single curl token, such as 7, +, foo, or "a string literal". Note that prefix expressions, such as {something x, y} count as a single token, because the tokenization rules for the contents of the prefix expression typically depend on the head of the expression; for example, the contents of {text hello 1.2.3} are parsed as a string, and 1.2.3 is not a valid code token at all.
  The related pattern tokens matches a sequence of 0 or more tokens.
• verbatim
  Matches the rest of the source code, preserving white space and other information that the code tokenizer would not. This pattern should be listed last.
  Using it for code can be less efficient than tokens or statements, so typically it should only be used when parsing raw code.
  If this pattern is named, the named source code object will be an object of type CurlSource.
  Since verbatim consumes the rest of the source code, there is no verbatims pattern.

• {pattern pattern-template}
  This is a simple grouping operator that collects a pattern template into a single pattern.
  For example:

  {pattern while ?predicate:expression do ?body:statements}

• literal
  Matches a single curl literal that isa specified type. Matching expressions might include 7, true, null, and "a string literal".
  If this pattern is named, the named source code object will be an object of type Literal.
  For example:

  {pattern include ?filename:{literal String}}

• {one-of pattern1 [, pattern2...]}
  This will match any one of the listed patterns, preferring to match patterns earlier in the list.
  one-of is the only compound pattern that takes patterns as its operands, rather than a sequence pattern template. This is to disambiguate whether commas are separating the operands to the one-of itself, or are simply part of one of the patterns.
  For example:

      {one-of
           {pattern above},
           {pattern below},
           {pattern to},
           {pattern downto}
      }
  

• {optional pattern-template}
  This will match either pattern-template, or nothing, preferring the former.
  For example:

      {pattern
          while ?tag-expr:{optional tag = ?:identifier,}
              ?predicate:expression
          do
              ?body:statements
      }  
  

  optional is equivalent to:
  {one-of {pattern pattern-template},{pattern}}
• {sequence pattern-template}
  This will match 0 or more occurrences of pattern-template, preferring to match as few occurrences as possible (i.e., it is non-greedy).
  Note that many of the simple patterns have shorthand plural forms, e.g. statements is equivalent to {sequence ?:statement}.
  If a sequence pattern is named, the object produced by a match will be a container that you can loop through with for, to see all the matches. You can get the size of the container by accessing its size method.
  Here's an example that matches zero or more keyword arguments, with a comma after each argument:

      {pattern ?keywords:{sequence ?:identifier = ?:expression,}}
  

  sequence is equivalent to:
  {bounded-sequence 0, infinity, pattern-template}
• {comma-sequence pattern-template}
  This will match 0 or more occurrences of pattern-template, with each pair of occurrences separated by commas. It prefers to match as few occurrences as possible (i.e., it is non-greedy).
  If a comma-sequence pattern is named, the object produced by a match will be a container that you can loop through with for, to see all the matches. The commas do not show up when you iterate, but will be present if the container is substituted into an expand-template call. You can get the size of the container by accessing its size method.
  Here's an example that matches zero or more arguments, separated by commas:

  {pattern ?arguments:{comma-sequence ?:expression}}

  comma-sequence is equivalent to:
  {bounded-comma-sequence 0, infinity, pattern-template }
• {bounded-sequence min, max, pattern-template }
  This will match between min and max occurrences of pattern-template, inclusive, preferring to match as few occurrences as possible (i.e., it is non-greedy). Use infinity if you don't want a bound.
  If a bounded-sequence pattern is named, the object produced by a match will be a container that you can loop through with for, to see all the matches. You can get the size of the container by accessing its size method.
  For example, this would match any sequence of two or more identifiers:

  {bounded-sequence 2, infinity, ?:identifier}

• {bounded-comma-sequence min, max, pattern-template }
  This will match between min and max occurrences of pattern-template, inclusive, with each pair of occurrences separated by commas. It prefers to match as few occurrences as possible (i.e., it is non-greedy).
  If a bounded-comma-sequence pattern is named, the object produced by a match will be a container that you can loop through with for, to see all the matches. The commas do not show up when you iterate, but will be present if the container is substituted into an expand-template call. You can get the size of the container by accessing its size method.
  For example, if you wanted a pattern that matched at least two comma-separated expressions, you would write this:

  {bounded-comma-sequence 2, infinity, ?:expression}

    {syntax-switch source
     case {pattern alpha ?id:identifier beta} do
        {output "I matched identifier ", id.name}
     else
        {error "no match"}
    }

    {syntax-switch source
     case {pattern alpha ?ids:identifiers beta} do
        {output "I matched ", ids.size, " identifiers"}
     case {pattern whoops} do
        {output "someone said whoops!"}
     else
        {error "no match"}
    }