^sub \w+\( results from the CPAN

^sub \w+\(

Carrot

view release on metacpan or search on metacpan

lib/Carrot/Continuity/Coordination/Episode/Loop.pm view on Meta::CPAN


	$class_names->assign_anchor('[=project_pkg=]');

	$distinguished_exceptions->provide(
		my $non_reentrant = 'non_reentrant');

	$expressiveness->declare_provider;

# =--------------------------------------------------------------------------= #

sub T_ETERNITY() { 2**31 -1; };

sub attribute_construction
# /type method
# /effect "Constructs the attribute(s) of a newly created instance."
# //parameters
#	timeout         ::Personality::Abstract::Seconds
# //returns
{
	my ($this) = @ARGUMENTS;

lib/Carrot/Continuity/Coordination/Episode/Paragraph/FDx2_IO.pm view on Meta::CPAN

	use bytes;
	use POSIX qw(:errno_h);

	my $expressiveness = Carrot::individuality;
	$expressiveness->provide(
		my $loop = '::Continuity::Coordination::Episode::Loop',
		my $customized_settings = '::Individuality::Controlled::Customized_Settings');

# =--------------------------------------------------------------------------= #

sub BST_CLOSED() { 0 };
sub BST_BUSY() { 1 };
sub BST_IDLE() { 2 };

$OS_SIGNALS{'PIPE'} = 'IGNORE'; # enables EPIPE globally to avoid sysaction() flooding

#WARNING: This module is not symmetric!
# Reading is not the opposite, reverse or mirror of writing.

$customized_settings->provide_plain_value(
	my $sysread_size = 'sysread_size',
	my $syswrite_size = 'syswrite_size');

lib/Carrot/Continuity/Coordination/Episode/Paragraph/TCP_Socket_IO.pm view on Meta::CPAN

		my $syswrite_size = 'syswrite_size',
		my $maximum_error_retries = 'maximum_error_retries');

	$class_names->provide(
		'[=project_pkg=]::Paragraph::TCP_Socket_IO::Buffer::',
			my $input_buffer_class = '::Input',
			my $output_buffer_class = '::Output');

# =--------------------------------------------------------------------------= #

sub INOUT_STOP() { -1 }
sub INOUT_NOCHANGE() { 0 }
sub INOUT_START() { 1 }

sub BUF_CONTENT() { 0 };
sub BUF_OFFSET() { 1 };
sub BUF_LEFT() { 2 };
sub BUF_IS_FILE() { 3 };

$OS_SIGNALS{'PIPE'} = 'IGNORE'; # enables EPIPE globally to avoid sysaction() flooding

# =--------------------------------------------------------------------------= #

sub attribute_construction
# /type method
# /effect "Constructs the attribute(s) of a newly created instance."
# //parameters
#	socket

lib/Carrot/Continuity/Coordination/Episode/Paragraph/TCP_Socket_IO/Buffer/Input.pm view on Meta::CPAN

		my $customized_settings = '::Individuality::Controlled::Customized_Settings');

	$customized_settings->provide_plain_value(
		my $maximum_buffer_size = 'maximum_buffer_size',
		my $separate_chunk_size = 'separate_chunk_size');

	# to a file using sendfile

# =--------------------------------------------------------------------------= #

sub FEED_MORE() { -1 }
sub FEED_ABORT() { 0 }
sub FEED_SUCCESS() { 1 }

# =--------------------------------------------------------------------------= #

sub attribute_construction
# /type method
# /effect "Constructs the attribute(s) of a newly created instance."
# //parameters
#	protocol
# //returns
{

lib/Carrot/Continuity/Coordination/Episode/Source/Signals.pm view on Meta::CPAN


	$class_names->provide_instance(
		my $loop = '[=project_pkg=]::Loop');
	$class_names->provide(
		my $targets_class = '[=component_pkg=]::_Targets');

	$OS_SIGNALS{'PIPE'} = 'IGNORE'; # not ignoring would disable the required EPIPE

# =--------------------------------------------------------------------------= #

sub BYS_IDX_FORMER() { 0 };
sub BYS_IDX_TARGETS() { 1 };
sub BYS_IDX_RECEIVED() { 2 };
sub BYS_IDX_DATA() { 3 };

# =--------------------------------------------------------------------------= #

sub attribute_construction
# /type method
# /effect "Constructs the attribute(s) of a newly created instance."
# //parameters
# //returns
{
	my ($this) = @ARGUMENTS;

lib/Carrot/Continuity/Coordination/Episode/Source/_Corporate.pm view on Meta::CPAN

{
	use strict;
	use warnings 'FATAL' => 'all';

	my $expressiveness = Carrot::individuality;
	$expressiveness->class_names->provide_instance(
		my $loop = '[=project_pkg=]::Loop');

# =--------------------------------------------------------------------------= #

sub T_ETERNITY() { 2**31 -1; };

sub max_timeout
# /type method
# /effect ""
# //parameters
# //returns
#	::Personality::Abstract::Seconds
{
	return(T_ETERNITY);
}

lib/Carrot/Continuity/Coordination/Episode/Synopsis.pm view on Meta::CPAN

#	class
#	instance
# //returns
#	?
{
	my ($class, $instance) = splice(\@ARGUMENTS, 0, 2);

	return([map(_recognize($instance, $_), @ARGUMENTS)]);
}

sub _recognize($$)
# /type function
# /effect ""
# //parameters
#	instance
#	value
# //returns
#	::Personality::Abstract::Instance
{
	my ($instance, $value) = @ARGUMENTS;

lib/Carrot/Continuity/Operation/Program/Data_Potential/Process.pm view on Meta::CPAN

# //returns
#	?
{
	my ($this) = @ARGUMENTS;

	return([
		['pid', \&syp_pid]
		]);
}

sub syp_pid($$)
# function ()
{
	return($PROCESS_PID);
}

# =--------------------------------------------------------------------------= #

	return(PERL_FILE_LOADED);
}
# //revision_control

lib/Carrot/Diversity/Attribute_Type./manual_modularity.pl view on Meta::CPAN


use strict;
use warnings;

*IS_FALSE = \&Carrot::Modularity::Constant::Global::Boolean::IS_FALSE;
*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;
*IS_EXISTENT = \&Carrot::Modularity::Constant::Global::Boolean::IS_EXISTENT;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;

sub ATR_PARENT_CLASSES() { 0 }
sub ATR_TYPE() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared::Ordered');

package main_ {
        *Carrot::Diversity::Attribute_Type::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Attribute_Type/Many_Declared/Obfuscated/Access./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::Many_Declared::Obfuscated::Access;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;

*ADX_FIRST_ELEMENT = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_FIRST_ELEMENT;

sub SPX_NAME() { 1 }
sub SPX_VALUE() { 2 }

package main_ {
	*Carrot::Diversity::Attribute_Type::Many_Declared::Obfuscated::Access::ARGUMENTS = *_;
}

return(1);

lib/Carrot/Diversity/Attribute_Type/Many_Declared/Ordered./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::Many_Declared::Ordered;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*THAT = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THAT;

*ADX_NO_ELEMENTS = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_NO_ELEMENTS;

sub SPX_PKG_NAME() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared');
package main_ {
        *Carrot::Diversity::Attribute_Type::Many_Declared::Ordered::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Attribute_Type/Many_Declared/Ordered/Access./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::Many_Declared::Ordered::Access;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;

*ADX_FIRST_ELEMENT = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_FIRST_ELEMENT;

sub SPX_POSITION() { 1 }
sub SPX_VALUE() { 2 }

package main_ {
	*Carrot::Diversity::Attribute_Type::Many_Declared::Ordered::Access::ARGUMENTS = *_;
}

return(1);

lib/Carrot/Diversity/Attribute_Type/One_Anonymous/Array./manual_modularity.pl view on Meta::CPAN

*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;
*IS_EXISTENT = \&Carrot::Modularity::Constant::Global::Boolean::IS_EXISTENT;

*ADX_FIRST_ELEMENT = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_FIRST_ELEMENT;
*ADX_LAST_ELEMENT = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_LAST_ELEMENT;
*ADX_NO_ELEMENTS = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_NO_ELEMENTS;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*THAT = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THAT;

sub SPX_VALUE() { 1 }
sub SPX_VALUES() { 1 }
sub SPX_POSITION() { 1 }
sub SPX_ELEMENT() { 2 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::One_Anonymous');
package main_ {
        *Carrot::Diversity::Attribute_Type::One_Anonymous::Array::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Attribute_Type/One_Anonymous/Existing_Reference./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::One_Anonymous::Existing_Reference;
use strict;
use warnings;

sub SPX_CLASS() { 0 }
sub SPX_VALUE_REF() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::One_Anonymous');
package main_ {
        *Carrot::Diversity::Attribute_Type::One_Anonymous::Existing_Reference::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Attribute_Type/One_Anonymous/Hash./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::One_Anonymous::Hash;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*THAT = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THAT;

sub SPX_VALUE() { 1 }
sub SPX_KEY() { 1 }
sub SPX_NAME() { 2 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::One_Anonymous');
package main_ {
        *Carrot::Diversity::Attribute_Type::One_Anonymous::Hash::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Attribute_Type/One_Anonymous/Regular_Expression./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::One_Anonymous::Regular_Expression;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;

sub SPX_VALUE() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::One_Anonymous');
package main_ {
        *Carrot::Diversity::Attribute_Type::One_Anonymous::Regular_Expression::ARGUMENTS = *_;
        *Carrot::Diversity::Attribute_Type::One_Anonymous::Regular_Expression::LAST_MATCH_START = *-;
        *Carrot::Diversity::Attribute_Type::One_Anonymous::Regular_Expression::LAST_MATCH_END = *+;
}
return(1);

lib/Carrot/Diversity/Attribute_Type/One_Anonymous/Scalar./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::One_Anonymous::Scalar;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*THAT = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THAT;

*IS_TRUE = \&Carrot::Modularity::Constant::Global::Boolean::IS_TRUE;

sub SPX_CLASS() { 0 }
sub SPX_VALUE() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::One_Anonymous');
package main_ {
        *Carrot::Diversity::Attribute_Type::One_Anonymous::Scalar::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Attribute_Type/One_Anonymous/Scalar/Access./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::One_Anonymous::Scalar::Access;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*THAT = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THAT;

*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;

sub SPX_VALUE() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::One_Anonymous::Scalar');

return(1);

lib/Carrot/Diversity/Attribute_Type/One_Anonymous/Scalar/Class_Default./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Attribute_Type::One_Anonymous::Scalar::Class_Default;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*THAT = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THAT;

*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;

sub SPX_VALUE() { 1 }

return(1);

lib/Carrot/Diversity/Block_Modifiers./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Block_Modifiers;
use strict;
use warnings;

#*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;

sub ATR_PLUGINS() { 0 }
sub ATR_MONADS() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared::Ordered');
package main_ {
        *Carrot::Diversity::Block_Modifiers::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Block_Modifiers/Monad./manual_modularity.pl view on Meta::CPAN

use strict;
use warnings;

our $DEBUG_FLAG //= 0;
*DEBUG_FLAG = Carrot::Meta::Greenhouse::Static_Flags::true_or_false($DEBUG_FLAG);

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*IS_TRUE = \&Carrot::Modularity::Constant::Global::Boolean::IS_TRUE;
*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;

sub ATR_ALL_BLOCKS() { 0 }
sub ATR_TRIGGER() { 1 }
sub ATR_PARSER() { 2 }

sub SPX_TRIGGER() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared::Ordered');
package main_ {
        *Carrot::Diversity::Block_Modifiers::Monad::EVAL_ERROR = *@;
        *Carrot::Diversity::Block_Modifiers::Monad::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Block_Modifiers/Monad/Blocks./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Block_Modifiers::Monad::Blocks;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;

sub MLX_BLOCK_TYPE() { 0 }
sub MLX_BLOCK_NAME() { 1 }
sub MLX_BLOCK_KEYWORD() { 2 }

sub SPX_KEY() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::One_Anonymous::Hash');
package main_ {
        *Carrot::Diversity::Block_Modifiers::Monad::Blocks::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Block_Modifiers/Monad/Parser./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Block_Modifiers::Monad::Parser;
use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;
*ADX_FIRST_ELEMENT = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_FIRST_ELEMENT;
*ADX_LAST_ELEMENT = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_LAST_ELEMENT;
*ADX_NO_ELEMENTS = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_NO_ELEMENTS;
*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;

sub ATR_MONAD() { 0 }
sub ATR_ALL_BLOCKS() { 1 }

sub MLX_BLOCK_OPEN_CLOSE() { 0 }
sub MLX_BLOCK_MODIFIER() { 1 }
sub MLX_BLOCK_END() { 2 }

sub MLX_BLOCK_TYPE() { 0 }
sub MLX_BLOCK_NAME() { 1 }
sub MLX_BLOCK_KEYWORD() { 2 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared::Ordered');
package main_ {
        *Carrot::Diversity::Block_Modifiers::Monad::Parser::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Block_Modifiers/Plugin/Subroutine/Parameters/Specification./manual_modularity.pl view on Meta::CPAN

use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;

*IS_UNDEFINED = \&Carrot::Modularity::Constant::Global::Boolean::IS_UNDEFINED;
*IS_EXISTENT = \&Carrot::Modularity::Constant::Global::Boolean::IS_EXISTENT;
*ADX_NO_ELEMENTS = \&Carrot::Modularity::Constant::Global::Array_Indices::ADX_NO_ELEMENTS;
*PKY_SPLIT_IGNORE_EMPTY_TRAIL = \&Carrot::Modularity::Constant::Global::Parameter::Keys::Split::PKY_SPLIT_IGNORE_EMPTY_TRAIL;

sub ATR_MINIMUM() { 0 }
sub ATR_MAXIMUM() { 1 }
sub ATR_MULTIPLE() { 2 }
sub ATR_WILD() { 3 }
sub ATR_TYPES() { 4 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared::Ordered');
package main_ {
        *Carrot::Diversity::Block_Modifiers::Plugin::Subroutine::Parameters::Specification::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Block_Modifiers/Plugin/_Prototype./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Block_Modifiers::Plugin::_Prototype;

use strict;
use warnings;

*THIS = \&Carrot::Modularity::Constant::Global::Parameter::Indices::Generic::Class::THIS;

sub ATR_BLOCK_ID() { 0 }
sub ATR_VALUE() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared::Ordered');
package main_ {
        *Carrot::Diversity::Block_Modifiers::Plugin::_Prototype::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/Block_Modifiers/Plugins./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::Block_Modifiers::Plugins;
use strict;
use warnings;

sub ATR_PLUGINS() { 0 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package(
	'::Diversity::Attribute_Type::Many_Declared::Ordered');
package main_ {
        *Carrot::Diversity::Block_Modifiers::Plugins::ARGUMENTS = *_;
}
return(1);

lib/Carrot/Diversity/English/Regular_Expression./manual_modularity.pl view on Meta::CPAN

ï»¿package Carrot::Diversity::English::Regular_Expression;

use strict;
use warnings;

*constructor = \&Carrot::Meta::Greenhouse::Minimal_Constructor::scalar_based;
*IS_TRUE = \&Carrot::Modularity::Constant::Global::Boolean::IS_TRUE;
*PERL_FILE_LOADED = \&Carrot::Meta::Greenhouse::PERL_FILE_LOADED;
*PKY_SPLIT_IGNORE_EMPTY_TRAIL = \&Carrot::Modularity::Constant::Global::Parameter::Keys::Split::PKY_SPLIT_IGNORE_EMPTY_TRAIL;

sub SPX_MODIFIERS() { 1 }

Carrot::Meta::Greenhouse::Shared_Subroutines::add_package_soon(
	'::Diversity::Attribute_Type::One_Anonymous');
Carrot::Meta::Greenhouse::Package_Loader::mark_singular;
package main_ {
        *Carrot::Diversity::English::Regular_Expression::ARGUMENTS = *_;
}

return(1);

lib/Carrot/Individuality/Controlled/Customized_Settings/Structure/Flat/Plain.clp view on Meta::CPAN

ï»¿sub NCV_IPL_FIRST_LINE() { 0 }; #INHERITABLE_CONSTANT#
sub NCV_IPL_JOINED_LINES() { 1 }; #INHERITABLE_CONSTANT#
sub NCV_IPL_ALL_LINES() { 2 }; #INHERITABLE_CONSTANT#

	'[=project_pkg=]::Relation::Discrete::Generic::',
		my $first_line_class = '::First_Line',
		my $joined_lines_class = '::Joined_Lines',
		my $all_lines_class = '::All_Lines'

sub modify
# method (<this>, <raw_data>) public
{
	my ($this, $raw_data) = @_;

lib/Carrot/Individuality/Controlled/Distinguished_Exceptions/Details_Policy.pm view on Meta::CPAN

{
	use strict;
	use warnings 'FATAL' => 'all';

	BEGIN {
		require('Carrot/Individuality/Controlled/Distinguished_Exceptions/Details_Policy./manual_modularity.pl');
	} #BEGIN

# =--------------------------------------------------------------------------= #

sub DEX_POLICY_HIDE() { -1 }
sub DEX_POLICY_BLANK() { 0 }
sub DEX_POLICY_DISCLOSE() { 1 }

my $default_policy = DEX_POLICY_DISCLOSE;

# =--------------------------------------------------------------------------= #

sub attribute_construction
# /type method
# /effect "Constructs the attribute(s) of a newly created instance."
# //parameters
# //returns

lib/Carrot/Individuality/Controlled/Localized_Messages/Constants.pm view on Meta::CPAN

ï»¿package Carrot::Individuality::Controlled::Localized_Messages::Constants
# /type class
# /attribute_type ::One_Anonymous::Scalar
# /capability ""
{
	use strict;
	use warnings 'FATAL' => 'all';

# =--------------------------------------------------------------------------= #

sub HKY_DEX_LINE_COUNT() { "\x{2}\@" }
sub HKY_DEX_LANGUAGE() { "\x{2}!" }
sub HKY_DEX_CALLER_OFFSET() { "\x{2}#" }
sub HKY_DEX_BACKTRACK() { "\x{2}?" }

sub provide_constants
# /type method
# /effect ""
# //parameters
# //returns
#	?
{
	return('HKY_DEX_', [qw(
		LINE_COUNT

( run in 0.525 second using v1.01-cache-2.11-cpan-1f129e94a17 )