view release on metacpan or  search on metacpan

lib/Aion/Types.md  view on Meta::CPAN

!ru:en
# NAME

Aion::Types - библиотека стандартных валидаторов и служит для создания новых валидаторов

# SYNOPSIS

```perl
use Aion::Types;

BEGIN {
	subtype SpeakOfKitty => as StrMatch[qr/\bkitty\b/i],
		message { "Speak is'nt included kitty!" };
}

"Kitty!" ~~ SpeakOfKitty # -> 1
"abc"    ~~ SpeakOfKitty # -> ""

SpeakOfKitty->validate("abc", "This") # @-> Speak is'nt included kitty!


BEGIN {
	subtype IntOrArrayRef => as (Int | ArrayRef);
}

[] ~~ IntOrArrayRef  # -> 1
35 ~~ IntOrArrayRef  # -> 1
"" ~~ IntOrArrayRef  # -> ""


coerce IntOrArrayRef, from Num, via { int($_ + .5) };

IntOrArrayRef->coerce(5.5) # => 6
```

# DESCRIPTION

Этот модуль экспортирует подпрограммы:

* `subtype`, `as`, `init_where`, `where`, `awhere`, `message` — для создания валидаторов.
* `SELF`, `ARGS`, `A`, `B`, `C`, `D`, `M`, `N` — для использования в валидаторах типа и его аргументов.
* `coerce`, `from`, `via` — для создания конвертора значений из одного класса в другой.

Иерархия валидаторов:

```text
Any
	Control
		Union[A, B...]
		Intersection[A, B...]
		Exclude[A...]
		Option[A]
		Wantarray[A, B]
	Item
		External[type]
		Bool
		BoolLike
		Enum[e...]
		Maybe[A]
		Undef
		Defined
			Value
				Version
				Str
					Uni
					Bin
					NonEmptyStr
					StartsWith[start]
					EndsWith[end]
					Email
					Tel
					Url
					Path
					Html
					StrDate
					StrDateTime
					StrMatch[regexp]
					ClassName
					RoleName
					Join[separator]
					Split[separator]
					StrRat
					Num
						PositiveNum
						Int
							PositiveInt
							Nat
			Ref
				Tied`[class]
				LValueRef
				FormatRef
				CodeRef
					NamedCode[subname]
					ProtoCode[prototype]
					ForwardRef
					ImplementRef
					Isa[A...]
				RegexpRef
				ValueRef`[A]
					ScalarRef`[A]
					RefRef`[A]
				GlobRef
					FileHandle
				ArrayRef`[A]
				HashRef`[A]
				Object`[class]
					Me
					Rat
				Map[A => B]
				Tuple[A...]

lib/Aion/Types.md  view on Meta::CPAN

Int->coerce(2.5)  # -> 3
Int->coerce(-2.5) # -> -3

# Bool from Any — 1 or ""
Bool->coerce([]) # -> 1
Bool->coerce(0)  # -> ""
```

## from ($type)

Синтаксический сахар для `coerce`.

## via ($code)

Синтаксический сахар для `coerce`.

# ATTRIBUTES

## :Isa (@signature)

Проверяет сигнатуру подпрограммы: аргументы и результаты.

```perl
sub minint($$) : Isa(Int => Int => Int) {
	my ($x, $y) = @_;
	$x < $y? $x : $y
}

minint 6, 5; # -> 5
eval {minint 5.5, 2}; $@ # ~> Arguments of method `minint` must have the type Tuple\[Int, Int\]\.

sub half($) : Isa(Int => Int) {
	my ($x) = @_;
	$x / 2
}

half 4; # -> 2
eval {half 5}; $@ # ~> Return of method `half` must have the type Int. The it is 2.5
```

# TYPES

## Any

Тип верхнего уровня в иерархии. Сопоставляет всё.

## Control

Тип верхнего уровня в конструкторах иерархии создает новые типы из любых типов.

## Union[A, B...]

Союз нескольких типов. Аналогичен оператору `$type1 | $type2`.

```perl
33  ~~ Union[Int, Ref] # -> 1
[]  ~~ Union[Int, Ref]	# -> 1
"a" ~~ Union[Int, Ref]	# -> ""
```

## Intersection[A, B...]

Пересечение нескольких типов. Аналогичен оператору `$type1 & $type2`.

```perl
15 ~~ Intersection[Int, StrMatch[/5/]] # -> 1
```

## Exclude[A, B...]

Исключение нескольких типов. Аналогичен оператору `~ $type`.

```perl
-5  ~~ Exclude[PositiveInt] # -> 1
"a" ~~ Exclude[PositiveInt] # -> 1
5   ~~ Exclude[PositiveInt] # -> ""
5.5 ~~ Exclude[PositiveInt] # -> 1
```

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

```perl
-5  ~~ Exclude[PositiveInt, Enum[-2]] # -> 1
-2  ~~ Exclude[PositiveInt, Enum[-2]] # -> ""
0   ~~ Exclude[PositiveInt, Enum[-2]] # -> ""
```

## Option[A]

Дополнительные ключи в `Dict`.

```perl
{a=>55} ~~ Dict[a=>Int, b => Option[Int]]          # -> 1
{a=>55, b=>31} ~~ Dict[a=>Int, b => Option[Int]]   # -> 1
{a=>55, b=>31.5} ~~ Dict[a=>Int, b => Option[Int]] # -> ""
```

## Wantarray[A, S]

Если подпрограмма возвращает разные значения в контексте массива и скаляра, то используется тип `Wantarray` с типом `A` для контекста массива Ð...

```perl
sub arr : Isa(PositiveInt => Wantarray[ArrayRef[PositiveInt], PositiveInt]) {
	my ($n) = @_;
	wantarray? 1 .. $n: $n
}

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

\@a # --> [1,2,3]
$s  # -> 3
```

## Item

Тип верхнего уровня в иерархии скалярных типов.

## External[type]

Правращает `type` в `Aion::Type`.

* Если `type` - `Aion::Type`, то возвращает его без изменений.
* Если `type` строка, то оборачивает его в `Object`.
* Если `type` можно вызвать, то оборачивает его в `Aion::Type->new(test => $type, ...)`. А если он имеет метод `coerce`, то будет его использовать для преобразован...