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[len, B]',
		as Int & Range[5, A]
			| ArrayRef[B & Len[A]];
}

35 ~~ IntOrArrayRef[35, Tel] # -> 1
35 ~~ IntOrArrayRef[34, Tel] # -> ""

'+23456789'  ~~ Tel # -> 1
'+234567890' ~~ Tel # -> 1
'+23456789'  ~~ (Tel & Len[9]) # -> 1
'+234567890' ~~ (Tel & Len[9]) # -> ""

['+23456789',  '+23456789'] ~~ IntOrArrayRef[9, Tel] # -> 1
['+234567890', '+23456789'] ~~ IntOrArrayRef[9, Tel] # -> ""

"" ~~ IntOrArrayRef[8, Tel]  # -> ""


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

IntOrArrayRef([35, Str])->coerce(5.5) # => 6

5.5 >> IntOrArrayRef[35, Str] # => 6

(Tel & Len[9]) < (Tel & Len[10]) # => 1
```

# 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

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

			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]
					Tuple[A...]
					CycleTuple[A...]
				HashRef`[A]
					Map[A => B]
					Dict[k => A, ...]
				Object`[class]
					Me
					Rat
				RegexpLike
				CodeLike
				ArrayLike`[A]
					Lim[from?, to]
				HashLike`[A]
					HasProp[p...]
					LimKeys[from?, to]
			Like
				HasMethods[m...]
				Overload`[m...]
				InstanceOf[class...]
				ConsumerOf[role...]
				StrLike
					Len[from?, to]
				NumLike
					Range[from, to]
						Float
						Double
						Bytes[n]
						PositiveBytes[n]
```

# SUBROUTINES

## subtype ($name, @paraphernalia)

Создаёт новый тип.

```perl
BEGIN {
	subtype One => where { $_ == 1 } message { "Actual 1 only!" };
}

1 ~~ One	 # -> 1
0 ~~ One	 # -> ""
eval { One->validate(0) }; $@ # ~> Actual 1 only!
```

`where` и `message` — это синтаксический сахар, а `subtype` можно использовать без них.

```perl
BEGIN {
	subtype Many => (where => sub { $_ > 1 });
}

2 ~~ Many  # -> 1

eval { subtype Many => (where1 => sub { $_ > 1 }) }; $@ # ~> subtype Many unused keys left: where1

eval { subtype 'Many' }; $@ # ~> subtype Many: main::Many exists!
```

## as ($super_type)

Используется с `subtype` для расширения создаваемого типа `$super_type`.

`as` может принимать выражения из типов объединённые множественно-теоритическими операторами. Так же в нём допускаются параметры `A`, `B`, `C`...

```perl
BEGIN {
	subtype 'Top[to]', as Range[0, A];
}

+3.0 ~~ Top[3] # -> 1
+3.1 ~~ Top[3] # -> ""
+0.0 ~~ Top[3] # -> 1
-0.1 ~~ Top[3] # -> ""

BEGIN {
	subtype 'RedColor', as Enum['red'];
	subtype 'BlueColor', as Enum['blue'];
}
BEGIN {
	subtype 'RedBlue', as RedColor | BlueColor;
}

'red'   ~~ RedBlue # -> 1
'blue'  ~~ RedBlue # -> 1
'green' ~~ RedBlue # -> ""

BEGIN {
	subtype 'RedBlueOther[colors...]', as ~RedBlue & Enum[ARGS];
}

'red' ~~ RedBlueOther['red'] # -> ""
'green' ~~ RedBlueOther['red', 'green'] # -> 1
```

## init_where ($code)

Инициализирует тип с новыми аргументами. Используется с `subtype`. 

Инициализация – ленивая. Это значит, что она сработает в методе `test` или подобном.

```perl
BEGIN {
	subtype 'LessThen[n]',
		init_where { Num->validate(A, "Argument LessThen[n]") }
		where { $_ < A };
}

eval { LessThen["string"] }; $@  # ^=> Argument LessThen[n]

5 ~~ LessThen[5]  # -> ""
```

## where ($code)

Использует `$code` как тест. Значение для теста передаётся в `$_`.

```perl
BEGIN {
	subtype 'Two',
		where { $_ == 2 };
}

2 ~~ Two # -> 1
3 ~~ Two # -> ""
```

## awhere ($code)

Используется с `subtype`.

Если тип может быть с аргументами и без, то используется для проверки набора с аргументами, а `where` — без.

```perl
BEGIN {
	subtype 'GreatThen`[num]',
		where { $_ > 0 }
		awhere { $_ > A }
	;
}

0 ~~ GreatThen # -> ""
1 ~~ GreatThen # -> 1

3 ~~ GreatThen[3] # -> ""
4 ~~ GreatThen[3] # -> 1
```

Необходимо, если аргументы необязательны.

```perl
subtype 'Ex`[a]', where {} # @-> subtype Ex`[a]: needs an awhere
subtype 'Ex', awhere {} # @-> subtype Ex: awhere is excess

BEGIN {
	subtype 'MyEnum`[item...]',
		as Str,
		awhere { $_ ~~ scalar ARGS }
	;
}

"ab" ~~ MyEnum[qw/ab cd/] # -> 1
```

## SELF