txt: ## signature.md
  class Signature
  
  Parameter list pattern
  
  ```raku
  class Signature { }
  ```
  
  A signature is a static description of the [parameter](/type/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`](/type/Capture), to the signature.
  
  For information on signature literals, see [here](/language/signatures).
  
  # [Methods](#class_Signature "go to top of document")[§](#Methods "direct link")
  
  ## [method params](#class_Signature "go to top of document")[§](#method_params "direct link")
  
  ```raku
  method params(Signature:D: --> Positional)
  ```
  
  Returns the list of [`Parameter`](/type/Parameter) objects that make up the signature.
  
  ## [method arity](#class_Signature "go to top of document")[§](#method_arity "direct link")
  
  ```raku
  method arity(Signature:D: --> Int:D)
  ```
  
  Returns the *minimal* number of positional arguments required to satisfy the signature.
  
  ## [method count](#class_Signature "go to top of document")[§](#method_count "direct link")
  
  ```raku
  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](#class_Signature "go to top of document")[§](#method_returns "direct link")
  
  Whatever the Signature's return constraint is:
  
  ```raku
  :($a, $b --> Int).returns # OUTPUT: «(Int)»
  ```
  
  ## [method ACCEPTS](#class_Signature "go to top of document")[§](#method_ACCEPTS "direct link")
  
  ```raku
  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`:
  
  ```raku
  :($a, $b) ~~ :($foo, $bar, $baz?);   # OUTPUT: «True»
  :(Int $n) ~~ :(Str);                 # OUTPUT: «False»
  ```
  
  The `$topic` is a [`Capture`](/type/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`:
  
  ```raku
  \(1, 2, :foo) ~~ :($a, $b, :foo($bar)); # OUTPUT: «True»
  \(1, :bar)    ~~ :($a);                 # OUTPUT: «False»
  ```
  
  Lastly, the candidate with `Mu \topic` converts `topic` to [`Capture`](/type/Capture) and follows the same semantics as [`Capture`](/type/Capture) `$topic`:
  
  ```raku
  <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](/language/signatures#index-entry-where_clause) are not introspectable, the method cannot determine whether two signatures [ACCEPTS](/type/Signature#method_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:
  
  ```raku
  say :(42) ~~ :($ where 42)    # OUTPUT: «False␤»
  ```
  
  ## [method Capture](#class_Signature "go to top of document")[§](#method_Capture "direct link")
  
  ```raku
  method Capture()
  ```
  
  Throws [`X::Cannot::Capture`](/type/X/Cannot/Capture).
  
  # [Runtime creation of Signature objects (6.d, 2019.03 and later)](#class_Signature "go to top of document")[§](#Runtime_creation_of_Signature_objects_(6.d,_2019.03_and_later) "direct link")
  
  ```raku
  Signature.new(params => (...), returns => Type, arity => 1, count => 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`](/type/Parameter) objects for this signature.
  
  * returns
  
  Any constraint the return value should match. Defaults to [`Mu`](/type/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`](/type/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`](/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`](/type/Int).
  
  # [Typegraph](# "go to top of document")[§](#typegraphrelations "direct link")
  
  Type relations for `Signature`
  
  
  
  raku-type-graph
  
  
  
  Signature
  Signature
  
  
  Any
  Any
  
  
  Signature->Any
  
  
  
  Mu
  Mu
  
  
  Any->Mu
  
  [Expand chart above](/assets/typegraphs/Signature.svg)
  