NAME

Venus::Scalar - Scalar Class

ABSTRACT

Scalar Class for Perl 5

SYNOPSIS

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  # ${$scalar}

DESCRIPTION

This package provides methods for manipulating scalar data.

INHERITS

This package inherits behaviors from:

Venus::Kind::Value

METHODS

This package provides the following methods:

cast

  cast(Str $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::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('array');

  # bless({ value => [\""] }, "Venus::Array")

cast example 2

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('boolean');

  # bless({ value => 1 }, "Venus::Boolean")

cast example 3

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('code');

  # bless({ value => sub { ... } }, "Venus::Code")

cast example 4

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('float');

  # bless({ value => "1.0" }, "Venus::Float")

cast example 5

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('hash');

  # bless({ value => { "0" => \"" } }, "Venus::Hash")

cast example 6

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('number');

  # bless({ value => 2 }, "Venus::Number")

cast example 7

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('regexp');

  # bless({ value => qr/(?^u:\\\")/ }, "Venus::Regexp")

cast example 8

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('scalar');

  # bless({ value => \"" }, "Venus::Scalar")

cast example 9

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('string');

  # bless({ value => "\\\"" }, "Venus::String")

cast example 10

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new;

  my $cast = $scalar->cast('undef');

  # bless({ value => undef }, "Venus::Undef")

default

  default() (Ref)

The default method returns the default value, i.e. \''.

Since 0.01

default example 1

  # given: synopsis;

  my $default = $scalar->default;

  # \""

eq

  eq(Any $arg) (Bool)

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

Since 0.08

eq example 1

  package main;

  use Venus::Array;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->eq($rvalue);

  # 0

eq example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->eq($rvalue);

  # 0

eq example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->eq($rvalue);

  # 0

eq example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->eq($rvalue);

  # 0

eq example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->eq($rvalue);

  # 0

eq example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->eq($rvalue);

  # 0

eq example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->eq($rvalue);

  # 1

eq example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->eq($rvalue);

  # 0

eq example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->eq($rvalue);

  # 0

ge

  ge(Any $arg) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->ge($rvalue);

  # 0

ge example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->ge($rvalue);

  # 0

ge example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->ge($rvalue);

  # 1

ge example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->ge($rvalue);

  # 0

ge example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->ge($rvalue);

  # 1

ge example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->ge($rvalue);

  # 0

ge example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->ge($rvalue);

  # 1

ge example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->ge($rvalue);

  # 1

ge example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->ge($rvalue);

  # 1

gele

  gele(Any $arg1, Any $arg2) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gele example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->gele($rvalue);

  # 0

gt

  gt(Any $arg) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->gt($rvalue);

  # 0

gt example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->gt($rvalue);

  # 0

gt example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->gt($rvalue);

  # 1

gt example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->gt($rvalue);

  # 0

gt example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->gt($rvalue);

  # 1

gt example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->gt($rvalue);

  # 0

gt example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->gt($rvalue);

  # 0

gt example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->gt($rvalue);

  # 1

gt example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->gt($rvalue);

  # 1

gtlt

  gtlt(Any $arg1, Any $arg2) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

gtlt example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->gtlt($rvalue);

  # 0

le

  le(Any $arg) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->le($rvalue);

  # 0

le example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->le($rvalue);

  # 1

le example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->le($rvalue);

  # 0

le example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->le($rvalue);

  # 0

le example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->le($rvalue);

  # 0

le example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->le($rvalue);

  # 1

le example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->le($rvalue);

  # 1

le example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->le($rvalue);

  # 0

le example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->le($rvalue);

  # 0

lt

  lt(Any $arg) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->lt($rvalue);

  # 0

lt example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->lt($rvalue);

  # 1

lt example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->lt($rvalue);

  # 0

lt example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->lt($rvalue);

  # 0

lt example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->lt($rvalue);

  # 0

lt example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->lt($rvalue);

  # 1

lt example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->lt($rvalue);

  # 0

lt example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->lt($rvalue);

  # 0

lt example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->lt($rvalue);

  # 0

ne

  ne(Any $arg) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->ne($rvalue);

  # 1

ne example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->ne($rvalue);

  # 1

ne example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->ne($rvalue);

  # 1

ne example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->ne($rvalue);

  # 1

ne example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->ne($rvalue);

  # 1

ne example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->ne($rvalue);

  # 1

ne example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->ne($rvalue);

  # 0

ne example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->ne($rvalue);

  # 1

ne example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->ne($rvalue);

  # 1

tv

  tv(Any $arg) (Bool)

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::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Array->new;

  my $result = $lvalue->tv($rvalue);

  # 0

tv example 2

  package main;

  use Venus::Code;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Code->new;

  my $result = $lvalue->tv($rvalue);

  # 0

tv example 3

  package main;

  use Venus::Float;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Float->new;

  my $result = $lvalue->tv($rvalue);

  # 0

tv example 4

  package main;

  use Venus::Hash;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Hash->new;

  my $result = $lvalue->tv($rvalue);

  # 0

tv example 5

  package main;

  use Venus::Number;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Number->new;

  my $result = $lvalue->tv($rvalue);

  # 0

tv example 6

  package main;

  use Venus::Regexp;
  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Regexp->new;

  my $result = $lvalue->tv($rvalue);

  # 0

tv example 7

  package main;

  use Venus::Scalar;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Scalar->new;

  my $result = $lvalue->tv($rvalue);

  # 1

tv example 8

  package main;

  use Venus::Scalar;
  use Venus::String;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::String->new;

  my $result = $lvalue->tv($rvalue);

  # 0

tv example 9

  package main;

  use Venus::Scalar;
  use Venus::Undef;

  my $lvalue = Venus::Scalar->new;
  my $rvalue = Venus::Undef->new;

  my $result = $lvalue->tv($rvalue);

  # 0

OPERATORS

This package overloads the following operators:

operation: (${})

This package overloads the ${} operator.

example 1

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new(\*STDOUT);

  my $value = $$scalar;

  # *::STDOUT

operation: (*{})

This package overloads the *{} operator.

example 1

  package main;

  use Venus::Scalar;

  my $scalar = Venus::Scalar->new(\*STDOUT);

  my $value = *$scalar;

  # *::STDOUT

To install Venus, copy and paste the appropriate command in to your terminal.

cpanm

cpanm Venus

CPAN shell

perl -MCPAN -e shell
install Venus

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

NAME

ABSTRACT

SYNOPSIS

DESCRIPTION

INHERITS

METHODS

cast

default

eq

ge

gele

gt

gtlt

le

lt

ne

tv

OPERATORS

Module Install Instructions