Stat Docs

MAIN
	// This is how you create a regular expression literal
	// This statement doesn't do anything
	// other than create the regular expression literal, but this
	// is a valid statement, albeit a bit useless
	/john/

MAIN
	let pattern = /john/

MAIN
	// Matches the word "hello" anywhere in a string or binary value
	let pattern = /hello/

MAIN
	// Matches a literal dot followed by a literal question mark
	let pattern = /\.\?/

MAIN
	// These both match a watermelon emoji character
	let pattern = /🍉/
	pattern = /\u{1f349}/

MAIN
	// This matches abcn because "n" in hex is 6e
	let pattern = /abc\x6e/

	// Matches abc followed by a binary x98 (152) byte
	pattern = /abc\x98/

MAIN
	// Matches a digit character followed by any white space character
	let pattern = /\d\s/

MAIN
	// Matches abc but only if the next character is
	// not a word character. Like abc@. Also matches
	// abc at the end of the string
	let pattern = /abc\b/

	// Matches abc but only if the next character is
	// also a word character. Like abcd
	pattern = /abc\B/

MAIN
	// Matches abc followed by any character except a new line character
	let pattern = /abc./

	// Matches abc followed by any character, even a new line character
	pattern = /abc./s

MAIN
	// Matches abc followed by any digit
	let pattern = /abc[0-9]/

	// Matches abc followed by one of x, y, or z
	pattern = /abc[xyz]/

	// Matches abc followed by any character
	// except a lower case letter
	pattern = /abc[^a-z]/

MAIN
	// Matches abc or def
	let pattern = /abc|def/

	// Matches abd, def, or xyz
	pattern = /abc|def|xyz/

MAIN
	// Matches abc followed by either def or ghi
	let pattern = /abc(def|ghi)/

MAIN
	// Captures the sequence abc
	let pattern = /(abc)/

	// Matches abc in a group, followed by def,
	// followed by a 2nd group of ghi
	pattern = /(abc)def(ghi)/

	// Groups can be nested
	pattern = /(a group that (contains another group) suffix)/

	// Matches abc but doesn't store the match
	pattern = /(?:abc)/

	// Matches abc only if it is followed by def
	pattern = /abc(?=def)/

	// Matches abc only if it is not followed by def
	pattern = /abc(?!def)/

MAIN
	// Matches "hello there hello" or "bye there bye"
	let pattern = /(hello|bye) there \1/

	// Matches abc yy or abc zz
	pattern = /(abc) ([yz])\2/

MAIN
	// Matches ab followed by an optional c
	let pattern = /abc?/

	// Matches ab followed by 1 or more c characters
	pattern = /abc+/

	// Matches ab followed by 0 or more c characters
	pattern = /abc*/

	// Matches ab followed by 1 or more
	// white-space characters, followed by def
	pattern = /abc\s+def/

	// Matches abc followed by 2 or more groups
	// of def. So abcdefdef or abcdefdefdef, etc...
	pattern = /abc(def){2,}/

	// Matches abcdddef or abcddddef or abcdddddef
	pattern = /abcd{3,5}ef/

MAIN
	// Matches abc followed by 2 or more d characters
	// Since it is greedy, it'll match as many as possible.
	let pattern = /abcd{2,}/

	// This makes the quantifier non-greedy which means
	// it'll match as little as 2 d characters
	pattern = /abcd{2,}?/

	// Matches abc followed by 0 or 1 d characters
	// which it'll prefer 0, followed by e
	pattern = /abcd??e/

	// Matches a dash followed by as many characters
	// as possible followed by another dash.
	// Given this string: -abcd-efgh-
	// It'll match the entire string
	pattern = /-.*-/

	// Matches a dash followed by as little characters
	// as possible followed by another dash.
	// Given this string: -abcd-efgh-
	// It'll match -abcd-
	pattern = /-.*?-/

MAIN
	// Matches abc, but only at the start
	let pattern = /^abc/

	// Matches abc, but only at the end
	pattern = /abc$/

	// Matches only abc, not abcd or 123abc
	pattern = /^abc$/

MAIN
	// Matches abc, but only at the start
	// of the string or start of a line
	let pattern = /^abc/m

	// Matches abc, but only at the end
	// of a line or end of the string
	pattern = /abc$/m

	// Matches any line in the string
	// that is abc
	pattern = /^abc$/m

MAIN
	// Matches abc followed by 1 or more new
	// line characters, followed by def at the
	// beginning of a line
	let pattern = /abc\n+(^def)/m

	// Matches abc at the end of a line
	// followed by 1 or more new line characters,
	// followed by def
	pattern = /(abc$)\n+def/m

	// Matches 123 followed by 1 or more
	// new line characters, followed by abc on
	// a single line, followed by 1 or more newline
	// characters, followed by def
	pattern = /123\n+(^abc$)\n+def/m

MAIN
	// Matches any letter either upper or lower case
	let pattern = /[a-z]/i

	// Matches ab, aB, Ab, or AB on any line
	pattern = /^ab$/mi

	// Matches literally everything
	pattern = /^.*$/s

MAIN
	// Matches abc followed by a new line character
	// followed by def followed by another new
	// line character followed by ghi
	// abc\ndef\nghi
	let pattern = /abc
		def
		ghi/

	// The same thing but with escapes
	pattern = /abc\ndef\nghi/

	// This is here to show how indentation works
	// with multi-line regular expressions
	if true
		// Another regular expression but with
		// a trailing new line character
		pattern = /abc
			def
			ghi
			/

		// The same thing but with escapes
		pattern = /abc\ndef\nghi\n/

	// One more example with indentation
	pattern = /
		This is actually the 2nd line
		    This is the 3rd line and it begins with 4 spaces
		This is the 4th line and does not start with any white-space/

IMPORTS
	myFunction

MAIN
	let name = "John"
	let pattern = /abc \{name} def/

	// You can use any value that evaluates to a string or
	// binary, not just variables. This uses a function call
	pattern = /abc \{myFunction()} def/

	// You can even use other string or binary literals
	// Obviously, you could just use John in the regular expression itself
	// but the purpose of this example is to show you what's possible
	pattern = /Hello \{"John"}/

	// You can even nest interpolations like this
	pattern = /Hello \{name + ". sub \{myFunction()}"}/

MAIN
	let value = ".*"

	// Matches abc followed by a literal dot
	// and a literal asterisk character.
	let pattern = /abc\{value}/

MAIN
	let all = ".*"
	let stringPattern = "abc\{all}"

	// Converts the string to an optional regular expression
	// This will end up being /abc.*/
	let maybeRegExp = stringPattern to: regExp?

	// You can force the conversion if you're sure that it won't fail
	// If it does fail, then it'll evaluate to an empty regular expression that matches nothing
	let forcedRegExp = (stringPattern to: regExp?)!

MAIN
	let stringVal = "Hello World"
	let pattern = /l+o\b/

	// This will be true
	let doesMatch = stringVal ~= pattern

	// You can match against binary values too
	let binVal = `\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64`
	// This will also be true
	doesMatch = binVal ~= pattern

META
	type typeDef
	typeDef: {
		match: string,
		range: range,
		captures: [
			{
				match: string,
				range: range
			}
		]
	}?

META
	type typeDef
	typeDef: {
		match: binary,
		range: range,
		captures: [
			{
				match: binary,
				range: range
			}
		]
	}?

MAIN
	// This will be {
	//		match: "Hello",
	//		range: 1..6,
	//		captures[]
	//	}
	let match = "Hello World" ~> /\w+/

	// This will be {
	//		match: "1.254.987",
	//		range: 1..10,
	//		captures: [{match: "987", range: 7..10}]
	//	}
	matches = "1.254.987 864.0.11210" ~> /(?:(\d+)\.?)+/

MAIN
	// All these statements are the same
	"Hello World" ~> /\w+/
	"Hello World" <~ /\w+/
	/\w+/ ~> "Hello World"
	/\w+/ <~ "Hello World"

META
	type typeDef
	typeDef: [
		{
			match: string,
			range: range,
			captures: [
				{
					match: string,
					range: range
				}
			]
		}
	]

META
	type typeDef
	typeDef: [
		{
			match: binary,
			range: range,
			captures: [
				{
					match: binary,
					range: range
				}
			]
		}
	]

MAIN
	// This will be [
	// 	{match: "Hello", range: 1..6, captures[]}
	// 	{match: "World", range: 7..12, captures[]}
	// ]
	let matches = "Hello World" ~>> /\w+/

	// This will be [
	// 	{
	//		match: "1.254.987",
	//		range: 1..10,
	//		captures: [{match: "987", range: 7..10}]
	// 	},
	// 	{
	//		match: "864.0.11210",
	//		range: 11..22,
	//		captures: [{match: "11210", range: 17..22}]
	// 	}
	// ]
	matches = "1.254.987 864.0.11210" ~>> /(?:(\d+)\.?)+/

MAIN
	// All these statements are the same
	"Hello World" ~>> /\w+/
	"Hello World" <<~ /\w+/
	/\w+/ ~>> "Hello World"
	/\w+/ <<~ "Hello World"