NAME

Kind::Subset::Parametric - Support for generic subsets

SYNOPSIS

use Kind::Subset::Parametric;

# Arrays don't type their elements by default:
my @untyped = 1, 2, 3;
say @untyped.^name; # OUTPUT: Array

# You can make it so they do by parameterizing Array:
my Int:D @typed = 1, 2, 3;
say @typed.^name; # OUTPUT: Array[Int:D]

# But you can't typecheck untyped arrays using these parameterizations:
say @typed ~~ Array[Int:D];   # OUTPUT: True
say @untyped ~~ Array[Int:D]; # OUTPUT: False

# So let's make our own array type that handles this using a parametric subset:
subset TypedArray of Array will parameterize -> ::T {
    proto sub check(Array) {*}
    multi sub check(Array[T] --> True) { }
    multi sub check(Array:U --> False) { }
    multi sub check(Array:D $topic) { so $topic.all ~~ T }
    &check
} where { !!! };

# Now they can both be typechecked:
given TypedArray[Int:D] -> \IntArray {
    say @typed ~~ IntArray;        # OUTPUT: True
    say @untyped ~~ IntArray;      # OUTPUT: True
    say <foo bar baz> ~~ IntArray; # OUTPUT: False
}

DESCRIPTION

Kind::Subset::Parametric enhances subsets with support for parameterization. This allows you to write subsets with generic where clauses.

Kind::Subset::Parametric is documented. You can refer to the documentation for its trait and MetamodelX::ParametricSubset at any time using WHY.

TRAITS

will parameterize

multi sub trait_mod:<will>(Mu \T where Subset, &body_block, :parameterize($)!)

This trait mixes the MetamodelX::ParametricSubset metarole into the HOW of the type it is applied to, which may only be a subset of some sort. Afterwards, the subset will be instantiated with its &body_block, which is what makes it possible to parameterize the subset.

The main metamethod of interest this metarole provides is parameterize, which accepts arbitrary type argumentss. This is created using a name (generated similarly to how the name of a parametric role is generated), the refinee of the parametric subset (the value of of), and the return value of the body block when invoked with the arguments as its refinement (the value of where).

For example, given an identity type:

subset Identity will parameterize { $_ } where { !!! };

Identity[Any] may be written to produce:

subset ::('Identity[Any]') where Any;

Note the stubbed where clause. Parametric subsets can still be given a refinement when this trait is applied, which handles typechecking against the subset when it has not been parameterized. If it's not desirable for a parametric subset to typecheck without being parameterized, the !!! stub will throw. Historically, ... was used, but failures don't necessarily sink when the typechecker's nqp is involved.

The body block may be introspected with the body_block metamethod, which returns the body block it was parameterized with given a subset type. set_body_block must be called after being instantiated either by mixin on a HOW or by &trait_mod:<does> in order to replace this.

Refer to t/02-will.t for more examples of how to use this trait.

AUTHOR

Ben Davies (Kaiepi)

COPYRIGHT AND LICENSE

Copyright 2022 Ben Davies

This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.