NAME

Venus::Regexp - Regexp Class

ABSTRACT

Regexp Class for Perl 5

SYNOPSIS

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new(
    qr/(?<greet>\w+) (?<username>\w+)/u,
  );
  # $regexp->search;

DESCRIPTION

This package provides methods for manipulating regexp data.

INHERITS

This package inherits behaviors from:

Venus::Kind::Value

METHODS

This package provides the following methods:

cast

  cast(string $kind) (object | undef)

The cast method converts "value" objects between different "value" object types, based on the name of the type provided. This method will return "undef" if the invocant is not a Venus::Kind::Value.

Since 0.08

cast example 1

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('array');
  # bless({ value => [qr/(?^u:)/] }, "Venus::Array")

cast example 2

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('boolean');
  # bless({ value => 1 }, "Venus::Boolean")

cast example 3

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('code');
  # bless({ value => sub { ... } }, "Venus::Code")

cast example 4

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('float');
  # bless({ value => "1.0" }, "Venus::Float")

cast example 5

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('hash');
  # bless({ value => { "0" => qr/(?^u:)/ } }, "Venus::Hash")

cast example 6

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('number');
  # bless({ value => 5 }, "Venus::Number")

cast example 7

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('regexp');
  # bless({ value => qr/(?^u:)/ }, "Venus::Regexp")

cast example 8

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('scalar');
  # bless({ value => \qr/(?^u:)/ }, "Venus::Scalar")

cast example 9

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('string');
  # bless({ value => "qr//u" }, "Venus::String")

cast example 10

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new;
  my $cast = $regexp->cast('undef');
  # bless({ value => undef }, "Venus::Undef")

default

  default() (regexp)

The default method returns the default value, i.e. "qr//".

Since 0.01

default example 1

  # given: synopsis;
  my $default = $regexp->default;
  # qr/(?^u:)/

eq

  eq(any $arg) (boolean)

The eq method performs an "equals" operation using the argument provided.

Since 0.08

eq example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->eq($rvalue);
  # 0

eq example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->eq($rvalue);
  # 0

eq example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->eq($rvalue);
  # 0

eq example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->eq($rvalue);
  # 0

eq example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->eq($rvalue);
  # 0

eq example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->eq($rvalue);
  # 1

eq example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->eq($rvalue);
  # 0

eq example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->eq($rvalue);
  # 0

eq example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->eq($rvalue);
  # 0

ge

  ge(any $arg) (boolean)

The ge method performs a "greater-than-or-equal-to" operation using the argument provided.

Since 0.08

ge example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->ge($rvalue);
  # 1

ge example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->ge($rvalue);
  # 0

ge example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->ge($rvalue);
  # 1

ge example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->ge($rvalue);
  # 0

ge example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->ge($rvalue);
  # 1

ge example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->ge($rvalue);
  # 1

ge example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->ge($rvalue);
  # 1

ge example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->ge($rvalue);
  # 1

ge example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->ge($rvalue);
  # 1

gele

  gele(any $arg1, any $arg2) (boolean)

The gele method performs a "greater-than-or-equal-to" operation on the 1st argument, and "lesser-than-or-equal-to" operation on the 2nd argument.

Since 0.08

gele example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gele example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->gele($rvalue);
  # 0

gt

  gt(any $arg) (boolean)

The gt method performs a "greater-than" operation using the argument provided.

Since 0.08

gt example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->gt($rvalue);
  # 1

gt example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->gt($rvalue);
  # 0

gt example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->gt($rvalue);
  # 1

gt example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->gt($rvalue);
  # 0

gt example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->gt($rvalue);
  # 1

gt example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->gt($rvalue);
  # 0

gt example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->gt($rvalue);
  # 1

gt example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->gt($rvalue);
  # 1

gt example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->gt($rvalue);
  # 1

gtlt

  gtlt(any $arg1, any $arg2) (boolean)

The gtlt method performs a "greater-than" operation on the 1st argument, and "lesser-than" operation on the 2nd argument.

Since 0.08

gtlt example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

gtlt example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->gtlt($rvalue);
  # 0

le

  le(any $arg) (boolean)

The le method performs a "lesser-than-or-equal-to" operation using the argument provided.

Since 0.08

le example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->le($rvalue);
  # 0

le example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->le($rvalue);
  # 1

le example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->le($rvalue);
  # 0

le example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->le($rvalue);
  # 1

le example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->le($rvalue);
  # 0

le example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->le($rvalue);
  # 1

le example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->le($rvalue);
  # 0

le example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->le($rvalue);
  # 0

le example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->le($rvalue);
  # 0

lt

  lt(any $arg) (boolean)

The lt method performs a "lesser-than" operation using the argument provided.

Since 0.08

lt example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->lt($rvalue);
  # 0

lt example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->lt($rvalue);
  # 1

lt example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->lt($rvalue);
  # 0

lt example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->lt($rvalue);
  # 1

lt example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->lt($rvalue);
  # 0

lt example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->lt($rvalue);
  # 0

lt example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->lt($rvalue);
  # 0

lt example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->lt($rvalue);
  # 0

lt example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->lt($rvalue);
  # 0

ne

  ne(any $arg) (boolean)

The ne method performs a "not-equal-to" operation using the argument provided.

Since 0.08

ne example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->ne($rvalue);
  # 1

ne example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->ne($rvalue);
  # 1

ne example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->ne($rvalue);
  # 1

ne example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->ne($rvalue);
  # 1

ne example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->ne($rvalue);
  # 1

ne example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->ne($rvalue);
  # 0

ne example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->ne($rvalue);
  # 1

ne example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->ne($rvalue);
  # 1

ne example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->ne($rvalue);
  # 1

numified

  numified() (number)

The numified method returns the numerical representation of the object. For regexp objects the method returns the length (or character count) of the stringified object.

Since 0.08

numified example 1

  # given: synopsis;
  my $numified = $regexp->numified;
  # 36

numified example 2

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new(
    qr/.*/u,
  );
  my $numified = $regexp->numified;
  # 7

replace

  replace(string $string, string $substr, string $flags) (Venus::Replace)

The replace method performs a regular expression substitution on the given string. The first argument is the string to match against. The second argument is the replacement string. The optional third argument might be a string representing flags to append to the s///x operator, such as 'g' or 'e'. This method will always return a Venus::Replace object which can be used to introspect the result of the operation.

Since 0.01

replace example 1

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new(
    qr/(?<username>\w+)$/,
  );
  my $replace = $regexp->replace('Hey, unknown', 'awncorp');
  # bless({ ... }, 'Venus::Replace')

search

  search(string $string) (Venus::Search)

The search method performs a regular expression match against the given string, this method will always return a Venus::Search object which can be used to introspect the result of the operation.

Since 0.01

search example 1

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new(
    qr/(?<greet>\w+), (?<username>\w+)/,
  );
  my $search = $regexp->search('hey, awncorp');
  # bless({ ... }, 'Venus::Search')

stringified

  stringified() (string)

The stringified method returns the object, stringified (i.e. a dump of the object's value).

Since 0.08

stringified example 1

  # given: synopsis;
  my $stringified = $regexp->stringified;
  # qr/(?<greet>\w+) (?<username>\w+)/u

stringified example 2

  package main;
  use Venus::Regexp;
  my $regexp = Venus::Regexp->new(
    qr/.*/,
  );
  my $stringified = $regexp->stringified;
  # qr/.*/u

tv

  tv(any $arg) (boolean)

The tv method performs a "type-and-value-equal-to" operation using argument provided.

Since 0.08

tv example 1

  package main;
  use Venus::Array;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Array->new;
  my $result = $lvalue->tv($rvalue);
  # 0

tv example 2

  package main;
  use Venus::Code;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Code->new;
  my $result = $lvalue->tv($rvalue);
  # 0

tv example 3

  package main;
  use Venus::Float;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Float->new;
  my $result = $lvalue->tv($rvalue);
  # 0

tv example 4

  package main;
  use Venus::Hash;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Hash->new;
  my $result = $lvalue->tv($rvalue);
  # 0

tv example 5

  package main;
  use Venus::Number;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Number->new;
  my $result = $lvalue->tv($rvalue);
  # 0

tv example 6

  package main;
  use Venus::Regexp;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Regexp->new;
  my $result = $lvalue->tv($rvalue);
  # 1

tv example 7

  package main;
  use Venus::Regexp;
  use Venus::Scalar;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Scalar->new;
  my $result = $lvalue->tv($rvalue);
  # 0

tv example 8

  package main;
  use Venus::Regexp;
  use Venus::String;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::String->new;
  my $result = $lvalue->tv($rvalue);
  # 0

tv example 9

  package main;
  use Venus::Regexp;
  use Venus::Undef;
  my $lvalue = Venus::Regexp->new;
  my $rvalue = Venus::Undef->new;
  my $result = $lvalue->tv($rvalue);
  # 0

OPERATORS

This package overloads the following operators:

operation: "(eq)"

This package overloads the "eq" operator.

example 1

  # given: synopsis;
  my $result = $regexp eq '(?^u:(?<greet>\\w+) (?<username>\\w+))';
  # 1

operation: "(ne)"

This package overloads the "ne" operator.

example 1

  # given: synopsis;
  my $result = $regexp ne '(?<greet>\w+) (?<username>\w+)';
  # 1

operation: "(qr)"

This package overloads the "qr" operator.

example 1

  # given: synopsis;
  my $result = 'Hello Friend' =~  $regexp;
  # 1

AUTHORS

Awncorp, "awncorp@cpan.org"

LICENSE

This program is free software, you can redistribute it and/or modify it under the terms of the Apache license version 2.0.