Aion

 view release on metacpan or  search on metacpan

t/aion/types.t  view on Meta::CPAN

# 
# Если `Exclude` имеет много аргументов, то это аналог `~ ($type1 | $type2 ...)`.
# 

local ($::_g0 = do {-5  ~~ Exclude[PositiveInt, Enum[-2]]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '-5  ~~ Exclude[PositiveInt, Enum[-2]] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $:...
local ($::_g0 = do {-2  ~~ Exclude[PositiveInt, Enum[-2]]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '-2  ~~ Exclude[PositiveInt, Enum[-2]] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef ...
local ($::_g0 = do {0   ~~ Exclude[PositiveInt, Enum[-2]]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0   ~~ Exclude[PositiveInt, Enum[-2]] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef ...

# 
# ## Option[A]
# 
# Дополнительные ключи в `Dict`.
# 
::done_testing; }; subtest 'Option[A]' => sub { 
local ($::_g0 = do {{a=>55} ~~ Dict[a=>Int, b => Option[Int]]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a=>55} ~~ Dict[a=>Int, b => Option[Int]]          # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef...
local ($::_g0 = do {{a=>55, b=>31} ~~ Dict[a=>Int, b => Option[Int]]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a=>55, b=>31} ~~ Dict[a=>Int, b => Option[Int]]   # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0)...
local ($::_g0 = do {{a=>55, b=>31.5} ~~ Dict[a=>Int, b => Option[Int]]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a=>55, b=>31.5} ~~ Dict[a=>Int, b => Option[Int]] # -> ""' or ::diag ::_struct_diff($::_g0, $::...

# 
# ## Wantarray[A, S]
# 
# Если подпрограмма возвращает разные значения в контексте массива и скаляра, то используется тип `Wantarray` с типом `A` для контекста массива...
# 
::done_testing; }; subtest 'Wantarray[A, S]' => sub { 
sub arr : Isa(PositiveInt => Wantarray[ArrayRef[PositiveInt], PositiveInt]) {
	my ($n) = @_;
	wantarray? 1 .. $n: $n
}

my @a = arr(3);
my $s = arr(3);

local ($::_g0 = do {\@a}, $::_e0 = do {[1,2,3]}); ::is_deeply $::_g0, $::_e0, '\@a # --> [1,2,3]' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {$s}, $::_e0 = do {3}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$s  # -> 3' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Item
# 
# Тип верхнего уровня в иерархии скалярных типов.
# 
# ## External[type]
# 
# Правращает `type` в `Aion::Type`.
# 
# * Если `type` - `Aion::Type`, то возвращает его без изменений.
# * Если `type` строка, то оборачивает его в `Object`.
# * Если `type` можно вызвать, то оборачивает его в `Aion::Type->new(test => $type, ...)`. А если он имеет метод `coerce`, то будет его использовать для преобразова...
# 
::done_testing; }; subtest 'External[type]' => sub { 
local ($::_g0 = do {External['Aion']}, $::_e0 = do {Object['Aion']}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'External[\'Aion\'] # -> Object[\'Aion\']' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {External[sub { /^x/ }] ~~ 'xyz'}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'External[sub { /^x/ }] ~~ \'xyz\' # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package MyInt {
	use overload "&{}" => sub {
		sub { /^[+-]?[0-9]+$/ }
	};
	
	sub coerce { /\./? int($_): $_ }
}

my $myint = bless {}, 'MyInt';

local ($::_g0 = do {External([$myint]) ~~ '+123'}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'External([$myint]) ~~ \'+123\' # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {External([$myint])->coerce(10.1)}, $::_e0 = "10"); ::ok $::_g0 eq $::_e0, 'External([$myint])->coerce(10.1) # => 10' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {External([$myint])->coerce('abc')}, $::_e0 = "abc"); ::ok $::_g0 eq $::_e0, 'External([$myint])->coerce(\'abc\') # => abc' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Bool
# 
# `1` is true. `0`, `""` or `undef` is false.
# 
::done_testing; }; subtest 'Bool' => sub { 
local ($::_g0 = do {1 ~~ Bool}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '1 ~~ Bool  # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {0 ~~ Bool}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0 ~~ Bool  # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {undef ~~ Bool}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'undef ~~ Bool # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {"" ~~ Bool}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"" ~~ Bool # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {2 ~~ Bool}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '2 ~~ Bool  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[] ~~ Bool}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ Bool # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Enum[A...]
# 
# Перечисление.
# 
::done_testing; }; subtest 'Enum[A...]' => sub { 
local ($::_g0 = do {3 ~~ Enum[1,2,3];}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '3 ~~ Enum[1,2,3];            # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {"cat" ~~ Enum["cat", "dog"];}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"cat" ~~ Enum["cat", "dog"]; # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {4 ~~ Enum[1,2,3];}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '4 ~~ Enum[1,2,3];            # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Maybe[A]
# 
# `undef` или тип в `[]`.
# 
::done_testing; }; subtest 'Maybe[A]' => sub { 
local ($::_g0 = do {undef ~~ Maybe[Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'undef ~~ Maybe[Int] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {4 ~~ Maybe[Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '4 ~~ Maybe[Int]     # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {"" ~~ Maybe[Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"" ~~ Maybe[Int]    # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Undef
# 
# Только `undef`.
# 
::done_testing; }; subtest 'Undef' => sub { 
local ($::_g0 = do {undef ~~ Undef}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'undef ~~ Undef # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {0 ~~ Undef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0 ~~ Undef     # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Defined
# 
# Всё за исключением `undef`.
# 
::done_testing; }; subtest 'Defined' => sub { 
local ($::_g0 = do {\0 ~~ Defined}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\0 ~~ Defined    # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {undef ~~ Defined}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'undef ~~ Defined # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Value
# 

t/aion/types.t  view on Meta::CPAN

# 
# ## PositiveInt
# 
# Положительные целые числа.
# 
::done_testing; }; subtest 'PositiveInt' => sub { 
local ($::_g0 = do {+0 ~~ PositiveInt}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '+0 ~~ PositiveInt # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {-0 ~~ PositiveInt}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '-0 ~~ PositiveInt # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {55 ~~ PositiveInt}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '55 ~~ PositiveInt # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {-1 ~~ PositiveInt}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '-1 ~~ PositiveInt # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## PositiveBytes[N]
# 
# Рассчитывает максимальное число, которое поместится в `N` байт (полагая, что в байтах нет отрицательного бита) и проверяет ограничение оÑ...
# 
::done_testing; }; subtest 'PositiveBytes[N]' => sub { 
local ($::_g0 = do {-1 ~~ PositiveBytes[1]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '-1 ~~ PositiveBytes[1]  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {0 ~~ PositiveBytes[1]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0 ~~ PositiveBytes[1]   # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {255 ~~ PositiveBytes[1]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '255 ~~ PositiveBytes[1] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {256 ~~ PositiveBytes[1]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '256 ~~ PositiveBytes[1] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {-1 ~~ PositiveBytes[8]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '-1 ~~ PositiveBytes[8]   # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {1.01 ~~ PositiveBytes[8]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '1.01 ~~ PositiveBytes[8] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {0 ~~ PositiveBytes[8]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0 ~~ PositiveBytes[8]    # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

my $N8 = 2 ** (8*Math::BigInt->new(8)) - 1;

local ($::_g0 = do {$N8 . "" ~~ PositiveBytes[8]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$N8 . "" ~~ PositiveBytes[8]     # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {($N8+1) . "" ~~ PositiveBytes[8]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '($N8+1) . "" ~~ PositiveBytes[8] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {-1 ~~ PositiveBytes[17]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '-1 ~~ PositiveBytes[17] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {0 ~~ PositiveBytes[17]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0 ~~ PositiveBytes[17]  # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Nat
# 
# Целые числа 1+.
# 
::done_testing; }; subtest 'Nat' => sub { 
local ($::_g0 = do {0 ~~ Nat}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0 ~~ Nat	# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {1 ~~ Nat}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '1 ~~ Nat	# -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Ref
# 
# Ссылка.
# 
::done_testing; }; subtest 'Ref' => sub { 
local ($::_g0 = do {\1 ~~ Ref}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\1 ~~ Ref # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[] ~~ Ref}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ Ref # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {1 ~~ Ref}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '1 ~~ Ref  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Tied`[A]
# 
# Ссылка на связанную переменную.
# 
::done_testing; }; subtest 'Tied`[A]' => sub { 
package TiedHash { sub TIEHASH { bless {@_}, shift } }
package TiedArray { sub TIEARRAY { bless {@_}, shift } }
package TiedScalar { sub TIESCALAR { bless {@_}, shift } }

tie my %a, "TiedHash";
tie my @a, "TiedArray";
tie my $a, "TiedScalar";
my %b; my @b; my $b;

local ($::_g0 = do {\%a ~~ Tied}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\%a ~~ Tied # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\@a ~~ Tied}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\@a ~~ Tied # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\$a ~~ Tied}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\$a ~~ Tied # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {\%b ~~ Tied}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\%b ~~ Tied  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\@b ~~ Tied}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\@b ~~ Tied  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\$b ~~ Tied}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\$b ~~ Tied  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\\$b ~~ Tied}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\\$b ~~ Tied # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {ref tied %a}, $::_e0 = "TiedHash"); ::ok $::_g0 eq $::_e0, 'ref tied %a     # => TiedHash' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {ref tied %{\%a}}, $::_e0 = "TiedHash"); ::ok $::_g0 eq $::_e0, 'ref tied %{\%a} # => TiedHash' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {\%a ~~ Tied["TiedHash"]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\%a ~~ Tied["TiedHash"]   # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\@a ~~ Tied["TiedArray"]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\@a ~~ Tied["TiedArray"]  # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\$a ~~ Tied["TiedScalar"]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\$a ~~ Tied["TiedScalar"] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {\%a ~~ Tied["TiedArray"]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\%a ~~ Tied["TiedArray"]   # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\@a ~~ Tied["TiedScalar"]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\@a ~~ Tied["TiedScalar"]  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\$a ~~ Tied["TiedHash"]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\$a ~~ Tied["TiedHash"]    # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\\$a ~~ Tied["TiedScalar"]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\\$a ~~ Tied["TiedScalar"] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## LValueRef
# 
# Функция позволяет присваивание.
# 
::done_testing; }; subtest 'LValueRef' => sub { 
local ($::_g0 = do {ref \substr("abc", 1, 2)}, $::_e0 = "LVALUE"); ::ok $::_g0 eq $::_e0, 'ref \substr("abc", 1, 2) # => LVALUE' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {ref \vec(42, 1, 2)}, $::_e0 = "LVALUE"); ::ok $::_g0 eq $::_e0, 'ref \vec(42, 1, 2) # => LVALUE' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {\substr("abc", 1, 2) ~~ LValueRef}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\substr("abc", 1, 2) ~~ LValueRef # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\vec(42, 1, 2) ~~ LValueRef}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\vec(42, 1, 2) ~~ LValueRef # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# Но с `:lvalue` не работает.
# 

sub abc: lvalue { $_ }

abc() = 12;
local ($::_g0 = do {$_}, $::_e0 = "12"); ::ok $::_g0 eq $::_e0, '$_ # => 12' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {ref \abc()}, $::_e0 = "SCALAR"); ::ok $::_g0 eq $::_e0, 'ref \abc()  # => SCALAR' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\abc() ~~ LValueRef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\abc() ~~ LValueRef	# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;


package As {
	sub x : lvalue {
		shift->{x};
	}
}

my $x = bless {}, "As";
$x->x = 10;

local ($::_g0 = do {$x->x}, $::_e0 = "10"); ::ok $::_g0 eq $::_e0, '$x->x # => 10' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {$x}, $::_e0 = do {bless {x=>10}, "As"}); ::is_deeply $::_g0, $::_e0, '$x	# --> bless {x=>10}, "As"' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {ref \$x->x}, $::_e0 = "SCALAR"); ::ok $::_g0 eq $::_e0, 'ref \$x->x			 # => SCALAR' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\$x->x ~~ LValueRef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\$x->x ~~ LValueRef # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# And on the end:
# 

local ($::_g0 = do {\1 ~~ LValueRef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\1 ~~ LValueRef	# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

my $x = "abc";
substr($x, 1, 1) = 10;

local ($::_g0 = do {$x}, $::_e0 = "a10c"); ::ok $::_g0 eq $::_e0, '$x # => a10c' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {LValueRef->include( \substr($x, 1, 1) )}, $::_e0 = "1"); ::ok $::_g0 eq $::_e0, 'LValueRef->include( \substr($x, 1, 1) )	# => 1' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## FormatRef
# 
# Формат.
# 
::done_testing; }; subtest 'FormatRef' => sub { 
format EXAMPLE_FMT =
@<<<<<<   @||||||   @>>>>>>
"left",   "middle", "right"
.

local ($::_g0 = do {*EXAMPLE_FMT{FORMAT} ~~ FormatRef}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '*EXAMPLE_FMT{FORMAT} ~~ FormatRef   # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\1 ~~ FormatRef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\1 ~~ FormatRef				# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## CodeRef
# 
# Подпрограмма.
# 
::done_testing; }; subtest 'CodeRef' => sub { 
local ($::_g0 = do {sub {} ~~ CodeRef}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'sub {} ~~ CodeRef # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\1 ~~ CodeRef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\1 ~~ CodeRef     # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## NamedCode[name]
# 
# Подпрограмма с указанным именем. `name` – строка или регулярка.
# 
::done_testing; }; subtest 'NamedCode[name]' => sub { 
sub code_ex { ... }

local ($::_g0 = do {\&code_ex ~~ NamedCode['main::code_ex']}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\&code_ex ~~ NamedCode[\'main::code_ex\'] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; un...
local ($::_g0 = do {\&code_ex ~~ NamedCode['code_ex']}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\&code_ex ~~ NamedCode[\'code_ex\']       # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef ...
local ($::_g0 = do {\&code_ex ~~ NamedCode[qr/_/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\&code_ex ~~ NamedCode[qr/_/]           # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## ProtoCode[prototype]
# 
# Подпрограмма с указанным прототипом.
# 
::done_testing; }; subtest 'ProtoCode[prototype]' => sub { 
sub codex ($;$);

t/aion/types.t  view on Meta::CPAN

close $fh;

opendir my $dh, ".";
local ($::_g0 = do {$dh ~~ FileHandle}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$dh ~~ FileHandle	         # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
closedir $dh;

use constant { PF_UNIX => 1, SOCK_STREAM => 1 };

socket my $sock, PF_UNIX, SOCK_STREAM, 0;
local ($::_g0 = do {$sock ~~ FileHandle}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$sock ~~ FileHandle	         # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
close $sock;

# 
# ## ArrayRef`[A]
# 
# Ссылки на массивы.
# 
::done_testing; }; subtest 'ArrayRef`[A]' => sub { 
local ($::_g0 = do {[] ~~ ArrayRef}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ ArrayRef	# -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{} ~~ ArrayRef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ ArrayRef	# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[] ~~ ArrayRef[Num]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ ArrayRef[Num]	# -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{} ~~ ArrayRef[Num]}, $::_e0 = do {''}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ ArrayRef[Num]	# -> \'\'' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[1, 1.1] ~~ ArrayRef[Num]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[1, 1.1] ~~ ArrayRef[Num]	# -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[1, undef] ~~ ArrayRef[Num]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[1, undef] ~~ ArrayRef[Num]	# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Lim[A, B?]
# 
# Ограничивает массивы от `A` до `B` элементов или от 0 до `A`, если `B` отсутствует.
# 
::done_testing; }; subtest 'Lim[A, B?]' => sub { 
local ($::_g0 = do {[] ~~ Lim[5]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ Lim[5]     # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[1..5] ~~ Lim[5]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[1..5] ~~ Lim[5] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[1..6] ~~ Lim[5]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[1..6] ~~ Lim[5] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {[1..5] ~~ Lim[1,5]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[1..5] ~~ Lim[1,5] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[1..6] ~~ Lim[1,5]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[1..6] ~~ Lim[1,5] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {[1] ~~ Lim[1,5]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[1] ~~ Lim[1,5] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[] ~~ Lim[1,5]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ Lim[1,5]  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## HashRef`[H]
# 
# Ссылки на хеши.
# 
::done_testing; }; subtest 'HashRef`[H]' => sub { 
local ($::_g0 = do {{} ~~ HashRef}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ HashRef # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\1 ~~ HashRef}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\1 ~~ HashRef # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {[]  ~~ HashRef[Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[]  ~~ HashRef[Int]           # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{x=>1, y=>2}  ~~ HashRef[Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{x=>1, y=>2}  ~~ HashRef[Int] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{x=>1, y=>""} ~~ HashRef[Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{x=>1, y=>""} ~~ HashRef[Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Object`[O]
# 
# Благословлённые ссылки.
# 
::done_testing; }; subtest 'Object`[O]' => sub { 
local ($::_g0 = do {bless(\(my $val=10), "A1") ~~ Object}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $val=10), "A1") ~~ Object # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_...
local ($::_g0 = do {\(my $val=10) ~~ Object}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\(my $val=10) ~~ Object              # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {bless(\(my $val=10), "A1") ~~ Object["A1"]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $val=10), "A1") ~~ Object["A1"] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0...
local ($::_g0 = do {bless(\(my $val=10), "A1") ~~ Object["B1"]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $val=10), "A1") ~~ Object["B1"] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_...

# 
# ## Me
# 
# Благословенные ссылки на объекты текущего пакета.
# 
::done_testing; }; subtest 'Me' => sub { 
package A1 {
 use Aion;
local ($::_g0 = do {bless({}, __PACKAGE__) ~~ Me}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, ' bless({}, __PACKAGE__) ~~ Me  # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {bless({}, "A2") ~~ Me}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, ' bless({}, "A2") ~~ Me         # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
}

# 
# ## Map[K, V]
# 
# Как `HashRef`, но с типом для ключей.
# 
::done_testing; }; subtest 'Map[K, V]' => sub { 
local ($::_g0 = do {{} ~~ Map[Int, Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ Map[Int, Int]               # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{5 => 3} ~~ Map[Int, Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{5 => 3} ~~ Map[Int, Int]         # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {+{5.5 => 3} ~~ Map[Int, Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '+{5.5 => 3} ~~ Map[Int, Int]      # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{5 => 3.3} ~~ Map[Int, Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{5 => 3.3} ~~ Map[Int, Int]       # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{5 => 3, 6 => 7} ~~ Map[Int, Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{5 => 3, 6 => 7} ~~ Map[Int, Int] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Tuple[A...]
# 
# Тьюпл.
# 
::done_testing; }; subtest 'Tuple[A...]' => sub { 
local ($::_g0 = do {["a", 12] ~~ Tuple[Str, Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '["a", 12] ~~ Tuple[Str, Int]    # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {["a", 12, 1] ~~ Tuple[Str, Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '["a", 12, 1] ~~ Tuple[Str, Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {["a", 12.1] ~~ Tuple[Str, Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '["a", 12.1] ~~ Tuple[Str, Int]  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## CycleTuple[A...]
# 
# Тьюпл повторённый один или несколько раз.
# 
::done_testing; }; subtest 'CycleTuple[A...]' => sub { 
local ($::_g0 = do {["a", -5] ~~ CycleTuple[Str, Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '["a", -5] ~~ CycleTuple[Str, Int] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {["a", -5, "x"] ~~ CycleTuple[Str, Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '["a", -5, "x"] ~~ CycleTuple[Str, Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; unde...
local ($::_g0 = do {["a", -5, "x", -6] ~~ CycleTuple[Str, Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '["a", -5, "x", -6] ~~ CycleTuple[Str, Int] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0...
local ($::_g0 = do {["a", -5, "x", -6.2] ~~ CycleTuple[Str, Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '["a", -5, "x", -6.2] ~~ CycleTuple[Str, Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef ...

# 
# ## Dict[k => A, ...]
# 
# Словарь.
# 
::done_testing; }; subtest 'Dict[k => A, ...]' => sub { 
local ($::_g0 = do {{a => -1.6, b => "abc"} ~~ Dict[a => Num, b => Str]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a => -1.6, b => "abc"} ~~ Dict[a => Num, b => Str] # -> 1' or ::diag ::_struct_diff($::_g0, $::...

local ($::_g0 = do {{a => -1.6, b => "abc", c => 3} ~~ Dict[a => Num, b => Str]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a => -1.6, b => "abc", c => 3} ~~ Dict[a => Num, b => Str] # -> ""' or ::diag ::_struc...
local ($::_g0 = do {{a => -1.6} ~~ Dict[a => Num, b => Str]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a => -1.6} ~~ Dict[a => Num, b => Str] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; un...

local ($::_g0 = do {{a => -1.6} ~~ Dict[a => Num, b => Option[Str]]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a => -1.6} ~~ Dict[a => Num, b => Option[Str]] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); un...

# 
# ## HasProp[p...]
# 
# Хэш имеет перечисленные свойства. Кроме них он может иметь и другие.
# 
::done_testing; }; subtest 'HasProp[p...]' => sub { 
local ($::_g0 = do {[0, 1] ~~ HasProp[qw/0 1/]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[0, 1] ~~ HasProp[qw/0 1/] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {{a => 1, b => 2, c => 3} ~~ HasProp[qw/a b/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a => 1, b => 2, c => 3} ~~ HasProp[qw/a b/] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $:...
local ($::_g0 = do {{a => 1, b => 2} ~~ HasProp[qw/a b/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a => 1, b => 2} ~~ HasProp[qw/a b/] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_...
local ($::_g0 = do {{a => 1, c => 3} ~~ HasProp[qw/a b/]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{a => 1, c => 3} ~~ HasProp[qw/a b/] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $:...

local ($::_g0 = do {bless({a => 1, b => 3}, "A") ~~ HasProp[qw/a b/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({a => 1, b => 3}, "A") ~~ HasProp[qw/a b/] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); ...

# 
# ## Like
# 
# Объект или строка.
# 
::done_testing; }; subtest 'Like' => sub { 
local ($::_g0 = do {"" ~~ Like}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"" ~~ Like # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {1 ~~ Like}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '1 ~~ Like  # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {bless({}, "A") ~~ Like}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, "A") ~~ Like # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {bless([], "A") ~~ Like}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless([], "A") ~~ Like # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {bless(\(my $str = ""), "A") ~~ Like}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $str = ""), "A") ~~ Like # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0...
local ($::_g0 = do {\1 ~~ Like}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\1 ~~ Like  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## HasMethods[m...]
# 
# Объект или класс имеет перечисленные методы. Кроме них может иметь и другие.
# 
::done_testing; }; subtest 'HasMethods[m...]' => sub { 
package HasMethodsExample {
	sub x1 {}
	sub x2 {}
}

local ($::_g0 = do {"HasMethodsExample" ~~ HasMethods[qw/x1 x2/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"HasMethodsExample" ~~ HasMethods[qw/x1 x2/]			# -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef ...
local ($::_g0 = do {bless({}, "HasMethodsExample") ~~ HasMethods[qw/x1 x2/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, "HasMethodsExample") ~~ HasMethods[qw/x1 x2/] # -> 1' or ::diag ::_struct_diff($::...
local ($::_g0 = do {bless({}, "HasMethodsExample") ~~ HasMethods[qw/x1/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, "HasMethodsExample") ~~ HasMethods[qw/x1/]	# -> 1' or ::diag ::_struct_diff($::_g0, $...
local ($::_g0 = do {"HasMethodsExample" ~~ HasMethods[qw/x3/]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"HasMethodsExample" ~~ HasMethods[qw/x3/]				# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::...
local ($::_g0 = do {"HasMethodsExample" ~~ HasMethods[qw/x1 x2 x3/]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"HasMethodsExample" ~~ HasMethods[qw/x1 x2 x3/]			# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0)...
local ($::_g0 = do {"HasMethodsExample" ~~ HasMethods[qw/x1 x3/]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"HasMethodsExample" ~~ HasMethods[qw/x1 x3/]			# -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); unde...

# 
# ## Overload`[op...]
# 
# Объект или класс с перегруженными операторами.
# 
::done_testing; }; subtest 'Overload`[op...]' => sub { 
package OverloadExample {
	use overload '""' => sub { "abc" };
}

local ($::_g0 = do {"OverloadExample" ~~ Overload}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"OverloadExample" ~~ Overload            # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {bless({}, "OverloadExample") ~~ Overload}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, "OverloadExample") ~~ Overload # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; un...
local ($::_g0 = do {"A" ~~ Overload}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"A" ~~ Overload                          # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {bless({}, "A") ~~ Overload}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, "A") ~~ Overload               # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# И у него есть операторы указанные операторы.
# 

local ($::_g0 = do {"OverloadExample" ~~ Overload['""']}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"OverloadExample" ~~ Overload[\'""\'] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_...
local ($::_g0 = do {"OverloadExample" ~~ Overload['|']}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"OverloadExample" ~~ Overload[\'|\']  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::...

# 
# ## InstanceOf[A...]
# 
# Класс или объект наследует классы из списка.
# 
::done_testing; }; subtest 'InstanceOf[A...]' => sub { 
package Animal {}
package Cat { our @ISA = qw/Animal/ }
package Tiger { our @ISA = qw/Cat/ }


local ($::_g0 = do {"Tiger" ~~ InstanceOf['Animal', 'Cat']}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"Tiger" ~~ InstanceOf[\'Animal\', \'Cat\'] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; un...
local ($::_g0 = do {"Tiger" ~~ InstanceOf['Tiger']}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"Tiger" ~~ InstanceOf[\'Tiger\']         # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0...
local ($::_g0 = do {"Tiger" ~~ InstanceOf['Cat', 'Dog']}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"Tiger" ~~ InstanceOf[\'Cat\', \'Dog\']    # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; und...

# 
# ## ConsumerOf[A...]
# 
# Класс или объект имеет указанные роли.
# 
::done_testing; }; subtest 'ConsumerOf[A...]' => sub { 
package NoneExample {}
package RoleExample { sub DOES { $_[1] ~~ [qw/Role1 Role2/] } }

local ($::_g0 = do {'RoleExample' ~~ ConsumerOf[qw/Role1/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\'RoleExample\' ~~ ConsumerOf[qw/Role1/] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; unde...
local ($::_g0 = do {'RoleExample' ~~ ConsumerOf[qw/Role2 Role1/]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\'RoleExample\' ~~ ConsumerOf[qw/Role2 Role1/] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef ...
local ($::_g0 = do {bless({}, 'RoleExample') ~~ ConsumerOf[qw/Role3 Role2 Role1/]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, \'RoleExample\') ~~ ConsumerOf[qw/Role3 Role2 Role1/] # -> ""' or ::diag ::...

local ($::_g0 = do {'NoneExample' ~~ ConsumerOf[qw/Role1/]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\'NoneExample\' ~~ ConsumerOf[qw/Role1/] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; un...

# 
# ## BoolLike
# 
# Проверяет 1, 0, "", undef или объект с перегруженным оператором `bool` или `0+` как `JSON::PP::Boolean`. Во втором случае вызывает оператор  `0+` и проверяет р...
# 
# `BoolLike` вызывает оператор `0+` и проверяет результат.
# 
::done_testing; }; subtest 'BoolLike' => sub { 
package BoolLikeExample {
	use overload '0+' => sub { ${$_[0]} };
}

local ($::_g0 = do {bless(\(my $x = 1 ), 'BoolLikeExample') ~~ BoolLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $x = 1 ), \'BoolLikeExample\') ~~ BoolLike # -> 1' or ::diag ::_struct_diff($::_g0, $...
local ($::_g0 = do {bless(\(my $x = 11), 'BoolLikeExample') ~~ BoolLike}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $x = 11), \'BoolLikeExample\') ~~ BoolLike # -> ""' or ::diag ::_struct_diff($::_g0,...

local ($::_g0 = do {1 ~~ BoolLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '1 ~~ BoolLike     # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {0 ~~ BoolLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '0 ~~ BoolLike     # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {"" ~~ BoolLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"" ~~ BoolLike    # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {undef ~~ BoolLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'undef ~~ BoolLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package BoolLike2Example {
	use overload 'bool' => sub { ${$_[0]} };
}

local ($::_g0 = do {bless(\(my $x = 1 ), 'BoolLike2Example') ~~ BoolLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $x = 1 ), \'BoolLike2Example\') ~~ BoolLike # -> 1' or ::diag ::_struct_diff($::_g0,...
local ($::_g0 = do {bless(\(my $x = 11), 'BoolLike2Example') ~~ BoolLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless(\(my $x = 11), \'BoolLike2Example\') ~~ BoolLike # -> 1' or ::diag ::_struct_diff($::_g0,...

# 
# ## StrLike
# 
# Строка или объект с перегруженным оператором `""`.
# 
::done_testing; }; subtest 'StrLike' => sub { 
local ($::_g0 = do {"" ~~ StrLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"" ~~ StrLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package StrLikeExample {
	use overload '""' => sub { "abc" };
}

local ($::_g0 = do {bless({}, "StrLikeExample") ~~ StrLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, "StrLikeExample") ~~ StrLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef ...

local ($::_g0 = do {{} ~~ StrLike}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ StrLike # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## RegexpLike
# 
# Регулярное выражение или объект с перегруженным оператором `qr`.
# 
::done_testing; }; subtest 'RegexpLike' => sub { 
local ($::_g0 = do {ref(qr//)}, $::_e0 = "Regexp"); ::ok $::_g0 eq $::_e0, 'ref(qr//)  # => Regexp' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {Scalar::Util::reftype(qr//)}, $::_e0 = "REGEXP"); ::ok $::_g0 eq $::_e0, 'Scalar::Util::reftype(qr//) # => REGEXP' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

my $regex = bless qr//, "A";
local ($::_g0 = do {Scalar::Util::reftype($regex)}, $::_e0 = "REGEXP"); ::ok $::_g0 eq $::_e0, 'Scalar::Util::reftype($regex) # => REGEXP' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {$regex ~~ RegexpLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$regex ~~ RegexpLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {qr// ~~ RegexpLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'qr// ~~ RegexpLike   # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {"" ~~ RegexpLike}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"" ~~ RegexpLike     # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package RegexpLikeExample {
 use overload 'qr' => sub { qr/abc/ };
}

local ($::_g0 = do {"RegexpLikeExample" ~~ RegexpLike}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '"RegexpLikeExample" ~~ RegexpLike # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {bless({}, "RegexpLikeExample") ~~ RegexpLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'bless({}, "RegexpLikeExample") ~~ RegexpLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $:...

# 
# ## CodeLike
# 
# Подпрограмма или объект с перегруженным оператором `&{}`.
# 
::done_testing; }; subtest 'CodeLike' => sub { 
local ($::_g0 = do {sub {} ~~ CodeLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, 'sub {} ~~ CodeLike     # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {\&CodeLike ~~ CodeLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '\&CodeLike ~~ CodeLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{} ~~ CodeLike}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ CodeLike         # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## ArrayLike`[A]
# 
# Массивы или объекты с перегруженным оператором или `@{}`.
# 
::done_testing; }; subtest 'ArrayLike`[A]' => sub { 
local ($::_g0 = do {{} ~~ ArrayLike}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ ArrayLike      # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {{} ~~ ArrayLike[Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ ArrayLike[Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {[] ~~ ArrayLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ ArrayLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package ArrayLikeExample {
	use overload '@{}' => sub {
		shift->{array} //= []
	};
}

my $x = bless {}, 'ArrayLikeExample';
$x->[1] = 12;
local ($::_g0 = do {$x->{array}}, $::_e0 = do {[undef, 12]}); ::is_deeply $::_g0, $::_e0, '$x->{array} # --> [undef, 12]' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {$x ~~ ArrayLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$x ~~ ArrayLike # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {$x ~~ ArrayLike[Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$x ~~ ArrayLike[Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

$x->[0] = 13;
local ($::_g0 = do {$x ~~ ArrayLike[Int]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$x ~~ ArrayLike[Int] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## HashLike`[A]
# 
# Хэши или объекты с перегруженным оператором `%{}`.
# 
::done_testing; }; subtest 'HashLike`[A]' => sub { 
local ($::_g0 = do {{} ~~ HashLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '{} ~~ HashLike  # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[] ~~ HashLike}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ HashLike  # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {[] ~~ HashLike[Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '[] ~~ HashLike[Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package HashLikeExample {
	use overload '%{}' => sub {
		shift->[0] //= {}
	};
}

my $x = bless [], 'HashLikeExample';
$x->{key} = 12.3;
local ($::_g0 = do {$x->[0]}, $::_e0 = do {{key => 12.3}}); ::is_deeply $::_g0, $::_e0, '$x->[0]  # --> {key => 12.3}' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {$x ~~ HashLike}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$x ~~ HashLike      # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {$x ~~ HashLike[Int]}, $::_e0 = do {""}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$x ~~ HashLike[Int] # -> ""' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;
local ($::_g0 = do {$x ~~ HashLike[Num]}, $::_e0 = do {1}); ::ok defined($::_g0) == defined($::_e0) && $::_g0 eq $::_e0, '$x ~~ HashLike[Num] # -> 1' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# # Coerces
# 
# ## Join\[R] as Str
# 
# Сктроковый тип с преобразованием массивов в строку через разделитель.
# 
::done_testing; }; subtest 'Join\[R] as Str' => sub { 
local ($::_g0 = do {Join([' '])->coerce([qw/a b c/])}, $::_e0 = "a b c"); ::ok $::_g0 eq $::_e0, 'Join([\' \'])->coerce([qw/a b c/]) # => a b c' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package JoinExample { use Aion;
	has s => (isa => Join[', '], coerce => 1);
}

local ($::_g0 = do {JoinExample->new(s => [qw/a b c/])->s}, $::_e0 = "a, b, c"); ::ok $::_g0 eq $::_e0, 'JoinExample->new(s => [qw/a b c/])->s # => a, b, c' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

local ($::_g0 = do {JoinExample->new(s => 'string')->s}, $::_e0 = "string"); ::ok $::_g0 eq $::_e0, 'JoinExample->new(s => \'string\')->s # => string' or ::diag ::_string_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# ## Split\[S] as ArrayRef
# 
::done_testing; }; subtest 'Split\[S] as ArrayRef' => sub { 
local ($::_g0 = do {Split([' '])->coerce('a b c')}, $::_e0 = do {[qw/a b c/]}); ::is_deeply $::_g0, $::_e0, 'Split([\' \'])->coerce(\'a b c\') # --> [qw/a b c/]' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

package SplitExample { use Aion;
	has s => (isa => Split[qr/\s*,\s*/], coerce => 1);
}

local ($::_g0 = do {SplitExample->new(s => 'a, b, c')->s}, $::_e0 = do {[qw/a b c/]}); ::is_deeply $::_g0, $::_e0, 'SplitExample->new(s => \'a, b, c\')->s # --> [qw/a b c/]' or ::diag ::_struct_diff($::_g0, $::_e0); undef $::_g0; undef $::_e0;

# 
# # AUTHOR
# 
# Yaroslav O. Kosmina [dart@cpan.org](mailto:dart@cpan.org)
# 
# # LICENSE
# 
# âš– **GPLv3**
# 
# # COPYRIGHT
# 
# The Aion::Types module is copyright © 2023 Yaroslav O. Kosmina. Rusland. All rights reserved.

	::done_testing;
};

::done_testing;