This is awesome! How is this not a billion times more popular than it is?? Thanks for sharing!

"I don't think anybody likes writing it."
=> I do !

RegEx are life, RegEx are everything !

I don't like this syntax. It seems overly bloated compared to the equivalent regex. Your example also doesn't include grouping, which is vital to extracing information from regex parsed strings. It also doesn't show how counted repitions, like in the regex graphic, would be used.

I'm afraid this would be ridiculously verbose for non-trival expressions.

Wow man! you've made my life 100x easier!
Thanks

A few months ago, I needed a really complicated Regex for a project that I was working on. After struggling for a very long time with the syntax, I ended up writing a small library to generate the Regex for me. The thing is: I never used it again, so I never got to write a decent documentation.

Using my library, your example would look like that:

import { is, start, end, maybe, not } from 'frogjs';

new Regex(is(
  start, 
  'http', maybe('s'), '://',
  notBefore(' ', maybe('www.'))
  end
));

If you wanna check it out, take a look here: github.com/danielbastos11/frogjs
The test fold is quite complete (I'm surprised, actually).

Man I freaking hate regex because it makes me feel so dumb. No matter how much I try to learn it, I never seem to really understand it. I hate it lol

I think this is a very bad idea, it is much better to learn regex from regular-expressions.info.

I think having a single line complex regex is a code smell. It is a much better approach to build it from sub-patterns or use multiple regex patterns or don't use regex at all. I Have a small example as evidence (note that the code is not tested or not even written in an editor):

Using a single complex pattern (common golden hammer mistake):

function checkIP(address){
    if (!(/^(?:\d|[1-9]\d|1\d{2,2}|2[0-4]\d|25[0-5])(?:\.(?:\d|[1-9]\d|1\d{2,2}|2[0-4]\d|25[0-5])){3,3}$/).test(address))
        throw new InvalidIP();
}

Using multiple small patterns in combination with language features:

function checkIP(address){
    let parts = address.split(".");
    if (parts.length != 4)
        throw new InvalidIP();
    parts.forEach((part){
        if (!(/^\d{1,3}$/).test(part))
            throw new InvalidIP();
        if ((/^0./).test(part))
            throw new InvalidIP();
        let num = parseInt(part);
        if (num>255)
            throw new InvalidIP();
    });
}

Building the pattern from sub-patterns:

function checkIP(address){
    let lessThan256 = "(?:\d|[1-9]\d|1\d{2,2}|2[0-4]\d|25[0-5])";
    let pattern = `^${lessThan256}(?:\.${lessThan256}){3,3}$`;
    if (!(new RegExp(pattern)).test(address))
        throw new InvalidIP();
}

Don't use the email regex given in example, this one is wrong.
Here are some valid email address according to RFC822 that will not match the regex :

• me@example.museum (the tld contains 6 characters)
• John Smith <john@smith.com> (Yes, you can put a name in front of an enclosed email address like that)

Some times, using RegEx (or VerbalExpression) is not appropriate. In this case, you should probably write a parser. Here is the implementation of this parser in go : golang.org/src/net/mail/message.go...