Here is a version of the evaluator the uses sprintf for those in prior versions of F#:

    let escape s = (RegularExpressions.Regex.Escape s).Replace("]", "\]")    // changed

    let rec evaluate = function
        | Literal string  -> escape string
        | LiteralRegex rx -> rx   // added

        | AnyChar         -> @"."
        | Bell            -> @"\a"
        | Backspace       -> @"\b"
        | Tab             -> @"\t"
        | VerticalTab     -> @"\v"
        | CarriageReturn  -> @"\r"
        | NewLine         -> @"\n"
        | Escaped         -> @"\e"
        | Octal oct       -> sprintf @"\%s"  (string oct  )
        | Hexadecimal hex -> sprintf @"\x%s" (string hex  )
        | ASCII ascii     -> sprintf @"\u%s" (string ascii)

        // Anchors
        | Start         -> @"\A"
        | StartOfLine   -> @"^"
        | End           -> @"\z"
        | EndOfLine     -> @"$"
        | Boundary      -> @"\b"
        | NotBoundary   -> @"\B"
        | AfterMatch    -> @"\G"

        // CHAR CLASSES
        | OneOf chars          ->
                                  let string = new string(chars |> List.toArray) |> escape
                                  sprintf @"[%s]" string
        | OneOfEscaped  string -> sprintf @"[%s]" string   // added
        | InRange (first,last) -> sprintf @"[%s-%s]" (string first |> escape) (string last |> escape)
        | InUnicodeBlock block -> sprintf @"\p{{%s}}" (block)
        | LetterOrDigit        -> @"\w"
        | WhitespaceChar       -> @"\s"
        | Digit                -> @"\d"

        | NotOneOf chars           ->
                                      let string = new string(chars |> List.toArray) |> escape
                                      sprintf @"[^%s]" (string)
        | NotOneOfEscaped   string -> sprintf @"[^%s]" string   // added
        | NotInRange (first, last) -> sprintf @"[^%s-%s]" (string first |> escape) (string last |> escape)
        | NotInUnicodeBlock block  -> sprintf @"\P{{%s}}" (block)
        | NotLetterOrDigit         -> @"\W"
        | NotWhitespaceChar        -> @"\S"
        | NotDigit                 -> @"\D"

        // Capturing
        | Capturing                regex  -> sprintf @"(%s)" (regex |> evaluate)
        | CapturingWithName (name, regex) -> sprintf @"(?<%s>%s)" (name) (regex |> evaluate)
        | ReferenceTo reference ->
            match reference with
            | Positional number -> sprintf @"\%s" (number |> string |> escape)
            | Named string -> sprintf @"\k<%s>" (string |> escape)
        // Non capturing
        | Grouping regex -> sprintf @"(?:%s)" (regex |> evaluate)
        | NonBacktrackingGrouping regex -> sprintf @"(?>%s)" (regex |> evaluate)
        // Options
        | WithOptions (modes, regex) ->
            let modeList = modes |> List.map (modeChar>>string) |> String.concat ""
            sprintf @"(?%s:%s)" (modeList) (regex |> evaluate)
        // Lookaround
        | LookingAheadFor regex -> sprintf @"(?=%s)" (regex |> evaluate)
        | LookingAheadAgainst regex -> sprintf @"(?!%s)" (regex |> evaluate)
        | LookingBehindFor regex -> sprintf @"(?<=%s)" (regex |> evaluate)
        | NotLookingBehindAgainst regex -> sprintf @"(?<!%s)" (regex |> evaluate)

        // Balancing
        | UnCapturing (reference,regex) ->
            sprintf @"(?<-%s>%s)" (reference |>referenceString) (regex |> evaluate)
        | Balancing (newName, reference, regex) ->
            sprintf @"(?<%s-%s>%s)" (newName |> escape) (reference |>referenceString) (regex |> evaluate)

        // Combination
        | Either regexs -> regexs |> List.map evaluate |> String.concat "|"
        | Sequence regexs -> regexs |> List.map evaluate |> String.concat ""

        // Ternaries
        | If (condition,yes,no) ->
            sprintf @"(?(%s)%s|%s)" (condition |> evaluate) (yes |> evaluate) (no |> evaluate)
        | IfGroup (reference,yes,no) ->
            sprintf @"(?(%s)%s|%s)" (reference |> referenceString) (yes |> evaluate) (no |> evaluate)

        // QUANTIFICATION
        | OneTimeOrNone          regex  -> sprintf @"%s?"          (regex |> quantifiable |> evaluate)
        | MoreThanOnce           regex  -> sprintf @"%s+"          (regex |> quantifiable |> evaluate)
        | ManyTimesOrNone        regex  -> sprintf @"%s*"          (regex |> quantifiable |> evaluate)
        | Exactly       (amount ,regex) -> sprintf @"%s{{%s}}"     (regex |> quantifiable |> evaluate) (string amount)
        | AtLeast       (amount ,regex) -> sprintf @"%s{{%s,}}"    (regex |> quantifiable |> evaluate) (string amount)
        | Between       (min,max,regex) -> sprintf @"%s{{%s,%s}}"  (regex |> quantifiable |> evaluate) (string min) (string max)

        | OneTimeOrNoneLazily    regex  -> sprintf @"%s??"         (regex |> quantifiable |> evaluate)
        | MoreThanOnceLazily     regex  -> sprintf @"%s+?"         (regex |> quantifiable |> evaluate)
        | ManyTimesOrNoneLazily  regex  -> sprintf @"%s*?"         (regex |> quantifiable |> evaluate)
        | ExactlyLazily (amount, regex) -> sprintf @"%s{{%s}}?"    (regex |> quantifiable |> evaluate) (string amount)
        | AtLeastLazily (amount, regex) -> sprintf @"%s{{%s,}}?"   (regex |> quantifiable |> evaluate) (string amount)
        | BetweenLazily (min,max,regex) -> sprintf @"%s{{%s,%s}}?" (regex |> quantifiable |> evaluate) (string min) (string max)

It is working very well.
Except for ||| that doesn't seem to overload like + does.

• Literal "this" ||| Literal "that" works
• Literal "this" ||| "that" doesn't work
  I'm not sure why

So I changed to '/'. I know is not symmetrical and it doesn't seem commutative. OTOH it confers the meaning well.
For instance: Literal "Err" / "Warn" / "Info" is very readable.

Also RegularExpressions.Regex.Escape doesn't escape the character ] which is a problem when doing OneOf, so I changed it to:

    let escape s = (RegularExpressions.Regex.Escape s).Replace("]", "\]")

Here is an example:

let parseErrWarnInfo = """
Err (1, 7) - (1, 12): "This shows over there as an error".
Warn (2, 7) - (2, 12): "This shows over there as a warning".
Info (3, 7) - (3, 12): "This shows over there as information".
"""

let digitsCap  = MoreThanOnce Digit |> Capturing
let spaces     = ManyTimesOrNone WhitespaceChar 
let coords     = "(" + digitsCap + "," + spaces + digitsCap + ")"
let notOneOf v = Seq.toList v |> NotOneOf 

let errWarnInfo =
    Sequence [
        Capturing(Literal "Err" / "Warn" / "Info")             + " "
        coords                                                 + " - "
        coords                                                 + ": "
        "\"" + Capturing (notOneOf "\"" |> MoreThanOnceLazily) + "\"."
    ]
    |> evaluate

printfn "Regex: %s" errWarnInfo  

// (Err|Warn|Info)\ \((\d+),\s*(\d+)\)\ -\ \((\d+),\s*(\d+)\):\ "([^"]+?)"\.

I also changed the operator for Either so it preserves the original order. I doesn't make a difference to the regex, but the rearranging was a little disconcerting.

With a couple of active patterns:

    let (|Regex|_|) pattern input =
        if input = null then None else
        try 
            let m = RegularExpressions.Regex.Match(input, pattern)
            if m.Success then Some(List.tail [ for g in m.Groups -> g.Value ])
            else None
        with e -> None

    let (|Regexs|) pattern input =
        if input = null then [| |] else
        try 
            let ms = RegularExpressions.Regex.Matches(input, pattern)
            [| for m in ms do yield (List.tail [ for g in m.Groups -> g.Value ]) |] 
        with e -> [| |]

then it can be used very nicely like this:

match parseErrWarnInfo with Regexs errWarnInfo r -> printfn "Matches found:\n%A" r

match parseErrWarnInfo with
| Regex errWarnInfo r -> printfn "First Match: %A" r
| _ -> printfn "No match found"

match parseErrWarnInfo with Regexs errWarnInfo r -> printfn "Matches found:\n%A" r

//  Matches found:
//  [|["Err"; "1"; "7"; "1"; "12"; "This shows over there as an error"];
//    ["Warn"; "2"; "7"; "2"; "12"; "This shows over there as a warning"];
//    ["Info"; "3"; "7"; "3"; "12"; "This shows over there as information"]|]

match parseErrWarnInfo with
| Regex errWarnInfo r -> printfn "First Match: %A" r
| _ -> printfn "No match found"

// First Match: ["Err"; "1"; "7"; "1"; "12"; "This shows over there as an error"]

Guid:

let hexDigit    = InRange('0', '9') / InRange('a', 'f')
let hexDigits n = Exactly(uint32 n, hexDigit)

Sequence [
    hexDigits  8      + "-"
    hexDigits  4      + "-"
    InRange('1', '5')
    hexDigits  3      + "-"
    oneOf     "89ab"
    hexDigits  3      + "-"
    hexDigits 12
]
|> evaluate
|> printfn "%s"

//  (?:[0-9]|[a-f]){8}-(?:[0-9]|[a-f]){4}-[1-5](?:[0-9]|[a-f]){3}-[89ab](?:[0-9]|[a-f]){3}-(?:[0-9]|[a-f]){12}

email:

let allowed  = NotOneOfEscaped (escape "<>()[].,;:@" + evaluate WhitespaceChar) |> MoreThanOnce
let listSep sep elems = elems + ManyTimesOrNone (Literal sep + elems)

listSep "." allowed + "@" + listSep "." allowed
|> evaluate
|> printfn "%s"

in this case allowed needed to include \s without further escaping. For this case I added:

...
| LiteralRegex  of string
| OneOfEscaped  of string
| NotOneOfEscaped of string
...
| LiteralRegex rx -> rx
| OneOfEscaped  string -> sprintf @"[%s]" string
| NotOneOfEscaped   string -> sprintf @"[^%s]" string
...

to allow for cases not contemplated or for composing with regex from other sources.