Commit 00df430

[function definition]: ../functions/index.md

A _function_ definition consists of name and code block along with an optional

list of parameters and return value. Functions are declared with the

keyword `fn`. Functions may declare a set of *input* parameters,

through which the caller passes arguments into the function, and

the *output* [*type*][_Types_] of the value the function will return to its caller

on completion.

When referred to, a _function_ yields a first-class *value* of the

corresponding zero-sized [*function type*][_FunctionTypes_], which

when called evaluates to a direct call to the function.

A function header prepends a set or curly brackets `{...}` which contain the function body.

For example, this is a simple function:

Functions can be defined inside of a contract, inside of a struct, or at the

"top level" of a module (that is, not nested within another item).

Example:

Function parameters have optional labels. When a function is called, the

arguments must be labeled and provided in the order specified in the

function definition.

The label of a parameter defaults to the parameter name; a different label

can be specified by adding an explicit label prior to the parameter name.

For example:

Here, the first parameter of the `encrypt` function has the label `msg`,

which is used when calling the function, while the parameter name is

`cleartext`, which is used inside the function body. The parameter name

is an implementation detail of the function, and can be changed without

modifying any function calls, as long as the label remains the same.

When calling a function, a label can be omitted when the argument is

a variable with a name that matches the parameter label. Example:

A parameter can also be specified to have no label, by using `_` in place of a

label in the function definition. In this case, when calling the function, the

corresponding argument must not be labeled. Example:

Functions defined inside of a contract or struct may take [`self`][SELF] as a

parameter. This gives the function the ability to read and write contract

storage or struct fields, respectively. If a function takes `self`

as a parameter, the function must be called via `self`. For example:

`self` is expected to come *first* parameter in the function's parameter list.

Functions can also take a [`Context`][CONTEXT] object which gives access to EVM features that read or write

blockchain and transaction data. `Context` is expected to be *first* in the function's parameter list

unless the function takes `self`, in which case `Context` should come second.

[NEWLINE]: ../lexical_structure/tokens.md#newline

[IDENTIFIER]: ../lexical_structure/identifiers.md

[_Types_]: ../type_system/types/index.md

[_FunctionTypes_]: ../type_system/types/function.md

[SELF]: ./self.md

[CONTEXT]: ./context.md

[_ReturnStatement_]: ../statements/return.md

[_VariableDeclarationStatement_]: ../statements/let.md

[_AssignStatement_]: ../statements/assign.md

[_AugmentedAssignStatement_]: ../statements/augassign.md

[_ForStatement_]: ../statements/for.md

[_WhileStatement_]: ../statements/for.md

[_IfStatement_]: ../statements/if.md

[_AssertStatement_]: ../statements/assert.md

[_BreakStatement_]: ../statements/break.md

[_ContinueStatement_]: ../statements/continue.md

[_RevertStatement_]: ../statements/revert.md

[_Expression_]: ../expressions/index.md

`self` is used to represent the specific instance of a Contract. It is used to access variables that are owned by that specific instance. This works the same way for Fe contracts as for, e.g. `self` in the context of classes in Python, or `this` in Javascript. `self` gives access to constants from the contract code and state variables from contract storage.

If a function takes self as a parameter, the function must be called via self. For example:

let ok: bool = self.transfer(from, to, value)

`self` is immutable and can be used for read-only operations on the contract storage (or `struct` fields). In order to write to the contract storage, you must use `mut self`. This makes the contract instance mutable and allows the contract storage to be updated.

[_Function_]: ../functions/index.md