anchor.diff:                      if Set.contains nestedMacroId badMacros then
                           // We have to return something, so return Empty to take the place
                           // of this macro reference.
  -                        Choice1Of2 Regex.empty
  -                        |> cont
  +                        return Choice1Of2 Regex.empty
                       else
  -                        Choice2Of2 [ sprintf "The macro '%s' is not defined." nestedMacroId ]
  -                        |> cont
  +                        return Choice2Of2 [ sprintf "The macro '%s' is not defined." nestedMacroId ]
  +
                   | Some nestedMacro ->
                       // Return the pattern for the nested macro so it'll be "inlined" into this pattern.
  -                    Choice1Of2 nestedMacro
  -                    |> cont
  +                    return Choice1Of2 nestedMacro
   
           (* Characters and character sets *)
           | Pattern.Empty ->
  -            Regex.empty
  -            |> Choice1Of2
  -            |> cont
  +            return
  +                Regex.empty
  +                |> Choice1Of2
   
           | Pattern.Character c ->
               // Make sure the character is an ASCII character unless the 'Unicode' option is set.
               if options.Unicode || int c <= 255 then
  -                Regex.ofChar c
  -                |> Choice1Of2
  -                |> cont
  +                return
  +                    Regex.ofChar c
  +                    |> Choice1Of2
               else
  -                ["Unicode characters may not be used in patterns unless the 'Unicode' compiler option is set."]
  -                |> Choice2Of2
  -                |> cont
  +                return
  +                    ["Unicode characters may not be used in patterns unless the 'Unicode' compiler option is set."]
  +                    |> Choice2Of2
   
           | Pattern.CharacterSet charSet ->
               // Make sure all of the characters in the set are ASCII characters unless the 'Unicode' option is set.
               if options.Unicode || CharSet.forall (fun c -> int c <= 255) charSet then
  -                Regex.CharacterSet charSet
  -                |> Choice1Of2
  -                |> cont
  +                return
  +                    Regex.CharacterSet charSet
  +                    |> Choice1Of2
               else
  -                ["Unicode characters may not be used in patterns unless the 'Unicode' compiler option is set."]
  -                |> Choice2Of2
  -                |> cont
  +                return
  +                    ["Unicode characters may not be used in patterns unless the 'Unicode' compiler option is set."]
  +                    |> Choice2Of2
   
           | Pattern.UnicodeCategory abbrev ->
               if options.Unicode then
                   match UnicodeCharSet.ofAbbreviation abbrev with
                   | None ->
  -                    [ sprintf "Unknown or invalid Unicode category specified. (Category = %s)" abbrev ]
  +                    return
  +                        [ sprintf "Unknown or invalid Unicode category specified. (Category = %s)" abbrev ]
  +                        |> Choice2Of2
  +                | Some categoryCharSet ->
  +                    return
  +                        Regex.CharacterSet categoryCharSet
  +                        |> Choice1Of2
  +            else
  +                return
  +                    ["Unicode category patterns may not be used unless the 'Unicode' compiler option is set."]
                       |> Choice2Of2
  -                    |> cont
  -                | Some categoryCharSet ->
  -                    categoryCharSet
  -                    |> Regex.CharacterSet
  -                    |> Choice1Of2
  -                    |> cont
  -            else
  -                ["Unicode category patterns may not be used unless the 'Unicode' compiler option is set."]
  -                |> Choice2Of2
  -                |> cont
   
           (* Wildcard pattern *)
           | Pattern.Any ->
               // Macros are not allowed to use the wildcard pattern.
  -            ["The wildcard pattern cannot be used within macro definitions."]
  -            |> Choice2Of2
  -            |> cont
  +            return
  +                ["The wildcard pattern cannot be used within macro definitions."]
  +                |> Choice2Of2
  +        }
   
       /// Contains an error if a macro has already been defined with this name; otherwise, None.
       let duplicateNameError =
  
positive.code:             // because we don't add macros to 'macroEnv' until they're successfully preprocessed;
              // however, this separate check allows us to provide a more specific error message.
              if macroId = nestedMacroId then
                  ["Recursive macro definitions are not allowed."]
                  |> Choice2Of2
                  |> cont
              else
                  match Map.tryFind nestedMacroId macroEnv with
                  | None ->
  
negative.code:                 Pattern.Concat (r, Pattern.Star r)
  
              // Process the rewritten expression.
              return! validateAndSimplify rewritten
  
          | Pattern.Optional r ->
              // Rewrite r? as (|r)
  