Global

class method Compile(expr: string): tuple of (Memory<Regexp>, error)

static (Memory<Regexp>, error) Compile(string expr)

static func Compile(_ expr: string) -> tuple of (Memory<Regexp>, error)

func Compile(expr string) tuple of (Memory<Regexp>, error)

Shared Function Compile(expr As string) As Tuple (Of Memory<Regexp>, error)

class method CompilePOSIX(expr: string): tuple of (Memory<Regexp>, error)

static (Memory<Regexp>, error) CompilePOSIX(string expr)

static func CompilePOSIX(_ expr: string) -> tuple of (Memory<Regexp>, error)

func CompilePOSIX(expr string) tuple of (Memory<Regexp>, error)

Shared Function CompilePOSIX(expr As string) As Tuple (Of Memory<Regexp>, error)

class method Match(pattern: string; b: Slice<Byte>): tuple of (matched: Boolean, err: error)

static (Boolean matched, error err) Match(string pattern, Slice<Byte> b)

static func Match(_ pattern: string, _ b: Slice<Byte>) -> tuple of (Boolean, error)

func Match(pattern string, b Slice<Byte>) tuple of (|name=matched| Boolean, |name=err| error)

Shared Function Match(pattern As string, b As Slice<Byte>) As Tuple (Of Boolean, error)

class method MatchReader(pattern: string; r: RuneReader): tuple of (matched: Boolean, err: error)

static (Boolean matched, error err) MatchReader(string pattern, RuneReader r)

static func MatchReader(_ pattern: string, _ r: RuneReader) -> tuple of (Boolean, error)

func MatchReader(pattern string, r RuneReader) tuple of (|name=matched| Boolean, |name=err| error)

Shared Function MatchReader(pattern As string, r As RuneReader) As Tuple (Of Boolean, error)

class method MatchString(pattern: string; s: string): tuple of (matched: Boolean, err: error)

static (Boolean matched, error err) MatchString(string pattern, string s)

static func MatchString(_ pattern: string, _ s: string) -> tuple of (Boolean, error)

func MatchString(pattern string, s string) tuple of (|name=matched| Boolean, |name=err| error)

Shared Function MatchString(pattern As string, s As string) As Tuple (Of Boolean, error)

class method MustCompile(str: string): Memory<Regexp>

static Memory<Regexp> MustCompile(string str)

static func MustCompile(_ str: string) -> Memory<Regexp>

func MustCompile(str string) Memory<Regexp>

Shared Function MustCompile(str As string) As Memory<Regexp>

class method MustCompilePOSIX(str: string): Memory<Regexp>

static Memory<Regexp> MustCompilePOSIX(string str)

static func MustCompilePOSIX(_ str: string) -> Memory<Regexp>

func MustCompilePOSIX(str string) Memory<Regexp>

Shared Function MustCompilePOSIX(str As string) As Memory<Regexp>

class method QuoteMeta(s: string): string

static string QuoteMeta(string s)

static func QuoteMeta(_ s: string) -> string

func QuoteMeta(s string) string

Shared Function QuoteMeta(s As string) As string