Methods and Associated Functions

Methods are similar to functions in that we declare them with the fn keyword and they have parameters and return a value. However, unlike functions, Methods are defined within the context of a struct (or enum), and either refers to that type or mutates it. The first parameter of a method is always self, which represents the instance of the struct the method is being called on.

Associated functions are very similar to methods, in that they are also defined in the context of a struct or enum, but they do not actually use any of the data in the struct and as a result do not take self as a parameter. Associated functions could be standalone functions, but they are included in a specific type for organizational or semantic reasons.

To declare methods and associated functions for a struct or enum, use an impl block. Here, impl stands for implementation.


struct Foo {
    bar: u64,
    baz: bool,

impl Foo {
    // this is a _method_, as it takes `self` as a parameter.
    fn is_baz_true(self) -> bool {

    // this is an _associated function_, since it does not take `self` as a parameter.
    fn new_foo(number: u64, boolean: bool) -> Foo {
        Foo {
            bar: number,
            baz: boolean,

fn main() {
    let foo = ~Foo::new_foo(42, true);

Note the syntax of the associated function call: ~Foo::new_foo(42, true);. This bit of syntax is unique to Sway: when referring to a type directly, you preface the type with a tilde (~). To call an associated function, refer to the type and then the function name. To call a method, simply use dot syntax: foo.iz_baz_true().

Similarly to free functions, methods and associated functions may accept ref mut parameters. For example:

struct Coordinates {
    x: u64,
    y: u64,

impl Coordinates {
    fn move_right(ref mut self, distance: u64) {
        self.x += distance;

and when called:

    let mut point = Coordinates { x: 1, y: 1 };
    assert(point.x == 6);
    assert(point.y == 1);