A function declaration.

A function declaration declares the name, type, parameters,
type parameters and type constraints of the value, but doesn’t provide a definition for it. There are several possible reasons for this:

  • The function can be a formal() method of an abstract() class or an interface, and subtypes have to provide the definition.
  • The function can be the declaration of a class or function parameter that only listed the name.
  • The function can be forward-declared, and the definition will be provided later.

In any case, the declaration must explicitly specify a type; a function’ modifier (FunctionModifier) indicating type inference cannot be used. (The ’dynamic’ modifier counts as a “type” here, indicating not the inference, but rather the absense of typing information.)

no subtypes hierarchy

Initializer
FunctionDeclaration(MemberName name, Type|DynamicModifier|VoidModifier type, [Parameters+] parameterLists, TypeParameters? typeParameters = null, TypeConstraint[] typeConstraints = [], Annotations annotations = ...)
Parameters:
  • name

    The name of the declared program element.

  • type

    The type of the declared function.

    This can be:

    • a Type,
    • a void’ modifier (VoidModifier) for a function that does not return a value, or
    • a dynamic’ modifier (DynamicModifier) for a dynamically typed function.
  • parameterLists

    The parameter lists. A function must have at least one, but may also have several parameter lists.

  • typeParameters = null

    The type parameters of the function, if any.

  • typeConstraints = []

    The type constraints placed upon the function’s type parameters, if any.

  • annotations = Annotations()

    The annotations on the declaration.

Attributes
annotationsSource Codeshared actual Annotations annotations

The annotations on the declaration.

childrenSource Codeshared actual [Annotations, Type|DynamicModifier|VoidModifier, LIdentifier, <TypeParameters|TypeConstraint>*] children

The child nodes of this node.

Refines AnyFunction.children ultimately refines Node.children
definitionSource Codeshared actual Null definition

A function declaration has no definition.

hashSource Codeshared actual Integer hash

The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that:

  • if x==y then x.hash==y.hash.

Therefore, a class which refines equals must also refine hash.

Refines Object.hash
nameSource Codeshared actual MemberName name

The name of the declared program element.

Refines AnyFunction.name ultimately refines Declaration.name
parameterListsSource Codeshared actual [Parameters+] parameterLists

The parameter lists. A function must have at least one, but may also have several parameter lists.

typeSource Codeshared actual Type|DynamicModifier|VoidModifier type

The type of the declared function.

This can be:

  • a Type,
  • a void’ modifier (VoidModifier) for a function that does not return a value, or
  • a dynamic’ modifier (DynamicModifier) for a dynamically typed function.
Refines AnyFunction.type ultimately refines TypedDeclaration.type
typeConstraintsSource Codeshared actual TypeConstraint[] typeConstraints

The type constraints placed upon the function’s type parameters, if any.

typeParametersSource Codeshared actual TypeParameters? typeParameters

The type parameters of the function, if any.

Inherited Attributes
Attributes inherited from: Node
Attributes inherited from: Object
Methods
copySource Codeshared FunctionDeclaration copy(MemberName name = ..., Type|DynamicModifier|VoidModifier type = ..., [Parameters+] parameterLists = ..., TypeParameters? typeParameters = ..., TypeConstraint[] typeConstraints = ..., Annotations annotations = ...)
Parameters:
  • name = this.name
  • type = this.type
  • parameterLists = this.parameterLists
  • typeParameters = this.typeParameters
  • typeConstraints = this.typeConstraints
  • annotations = this.annotations
equalsSource Codeshared actual Boolean equals(Object that)

Determine if two values are equal. Implementations should respect the constraints that:

  • if x===y then x==y (reflexivity),
  • if x==y then y==x (symmetry),
  • if x==y and y==z then x==z (transitivity).

Furthermore it is recommended that implementations ensure that if x==y then x and y have the same concrete class.

A class which explicitly refines equals() is said to support value equality, and the equality operator == is considered much more meaningful for such classes than for a class which simply inherits the default implementation of identity equality from Identifiable.

transformSource Codeshared actual Result transform<out Result>(Transformer<Result> transformer)

Transform this node with the given transformer by calling the appropriate transformX method on the transformer.

If you have a Node node that’s actually an LIdentifier instance, then the runtime will call LIdentifier.transform; therefore, this method is by nature narrowing. This means that if transformer is a NarrowingTransformer, calling node.transform(transformer) is equivalent to calling transformer.transformNode(node). On the other hand, if transformer is a WideningTransformer, then the two operations are very different.

Inherited Methods
Methods inherited from: Node