Icon HelpCircleForumIcon Link

⌘K

Icon HelpCircleForumIcon Link
Docs /
Sway /
Advanced /
Associated Types

Icon LinkAssociated Types

Associated types in Sway allow you to define placeholder types within a trait, which can be customized by concrete implementations of that trait. These associated types are used to specify the return types of trait methods or to define type relationships within the trait.
Associated types are a powerful feature of Sway's trait system, enabling generic programming and abstraction over types. They help improve code clarity and maintainability by allowing you to define generic traits without committing to specific types.

Icon LinkDeclaring Associated Types

Associated types are declared within a trait using the type keyword. Here's the syntax for declaring an associated type: 
trait MyTrait {
    type AssociatedType;
}

Icon LinkImplementing Associated Types

Concrete implementations of a trait with associated types must provide a specific type for each associated type defined in the trait. Here's an example of implementing a trait with an associated type: 
struct MyStruct;
 
impl MyTrait for MyStruct {
    type AssociatedType = u32; // Implementing the associated type with u32
}
In this example, MyStruct implements MyTrait and specifies that the associated type AssociatedType is u32.

Icon LinkUsing Associated Types

Associated types are used within trait methods or where the trait is used as a bound for generic functions or structs. You can use the associated type like any other type. Here's an example: 
trait MyTrait {
    type AssociatedType;
    
    fn get_value(self) -> Self::AssociatedType;
}
 
struct MyStruct;
 
impl MyTrait for MyStruct {
    type AssociatedType = u32;
 
    fn get_value(self) -> Self::AssociatedType {
        42
    }
}
In this example, get_value is a trait method that returns an associated type AssociatedType.

Icon LinkUse Cases

Associated types are particularly useful in scenarios where you want to define traits that work with different types of data structures or abstractions, allowing the implementer to specify the concrete types. Some common use cases include:
  • Collections: Traits for generic collections that allow users to specify the type of elements.
  • Iterator Patterns: Traits for implementing iterators with varying element types.
  • Serialization and Deserialization: Traits for serializing and deserializing data with different data formats.