class Signature { }

A signature is a static description of the parameter list of a code object. That is, it describes what and how many arguments you need to pass to the code or function in order to call it.

Passing arguments to a signature binds the arguments, contained in a Capture, to the signature.

For information on signature literals, see here.

Methods

method params

method params(Signature:D: --> Positional)

Returns the list of parameter objects that make up the signature.

method arity

method arity(Signature:D: --> Int:D)

Returns the minimal number of positional arguments required to satisfy the signature.

method count

method count(Signature:D: --> Real:D)

Returns the maximal number of positional arguments which can be bound to the signature. Returns Inf if there is a slurpy positional parameter.

method returns

Whatever the Signature's return constraint is:

:($a$b --> Int).returns # OUTPUT: Ā«(Int)Ā»

method ACCEPTS

multi method ACCEPTS(Signature:D: Signature $topic)
multi method ACCEPTS(Signature:D: Capture $topic)
multi method ACCEPTS(Signature:D: Mu \topic)

If $topic is a Signature returns True if anything accepted by $topic would also be accepted by the invocant, otherwise returns False:

:($a$b~~ :($foo$bar$baz?);   # OUTPUT: Ā«TrueĀ» 
:(Int $n~~ :(Str);                 # OUTPUT: Ā«FalseĀ»

The $topic is a Capture, returns True if it can be bound to the invocant, i.e., if a function with invocant's Signature would be able to be called with the $topic:

\(12:foo~~ :($a$b:foo($bar)); # OUTPUT: Ā«TrueĀ» 
\(1:bar)    ~~ :($a);                 # OUTPUT: Ā«FalseĀ»

Lastly, the candidate with Mu \topic converts topic to Capture and follows the same semantics as Capture $topic:

<a b c d>  ~~ :(Int $a);      # OUTPUT: Ā«FalseĀ» 
42         ~~ :(Int);         # OUTPUT: Ā«FalseĀ» (Int.Capture throws) 
set(<a b>~~ :(:$a:$b);    # OUTPUT: Ā«TrueĀ»

Since where clauses are not introspectable, the method cannot determine whether two signatures ACCEPTS the same sort of where-constrained parameters. Such comparisons will return False. This includes signatures with literals, which are just sugar for the where-constraints:

say :(42~~ :($ where 42)    # OUTPUT: Ā«Falseā¤Ā»

method Capture

method Capture()

Throws X::Cannot::Capture.

Runtime creation of Signature objects (6.d, 2019.03 and later)

Signature.new(params => (...), returns => Typearity => 1count => 1.Num)

In some situations, specifically when working with the MetaObject Protocol, it makes sense to create Signature objects programmatically. For this purpose, you can call the new method with the following named parameters:

  • params

A list of parameter objects for this signature.

  • returns

Any constraint the return value should match. Defaults to Mu, which effectively implies no return value constraint check.

  • arity

The minimal number of positional arguments required to satisfy the signature. Defaults to the number of Parameter objects given with the params parameter.

  • count

The maximal number of positional arguments which can be bound to the signature. Defaults to the arity if not specified. Specify Inf if there is a slurpy positional parameter.

Warning: although the logical type of the count parameter is integer, the value assigned to it must explicitly be of type Num. If any other type is used, the new method silently fails and returns an empty signature. The same trouble occurs when the value assigned to the arity parameter is not of type Int.