11. Implementations¶
Syntax
Implementation::=InherentImplementation|TraitImplementationInherentImplementation::= implGenericParameterList?ImplementingTypeWhereClause?ImplementationBodyTraitImplementation::= unsafe? implGenericParameterList? !?ImplementedTraitforImplementingTypeWhereClause?ImplementationBodyImplementingType::=TypeSpecificationImplementedTrait::=TypePathImplementationBody::= {InnerAttributeOrDoc*AssociatedItem* }
Legality Rules
11:1 An implementation is an item that supplements an implementing type by extending its functionality.
11:2 An implementing type is the type that the associated items of an implementation are associated with.
11:3
Within an implementation, the type Self acts as a type alias
for the implementing type.
11:4 An implementation body is a construct that encapsulates the associated items, inner attributes, and inner doc comments of an implementation.
11:5 An inherent implementation is an implementation that adds direct functionality.
11:6 Inherent implementations of the same implementing type shall be defined within the same crate.
11:7 A trait implementation is an implementation that adds functionality specified by a trait.
11:8
An unsafe trait implementation is a trait implementation subject to
keyword unsafe.
11:9 An implemented trait is a trait whose functionality has been implemented by an implementing type.
11:10 The type path of a trait implementation shall resolve to a trait.
11:11 A trait implementation shall be an unsafe trait implementation if and only if it implements an unsafe trait.
11:12 Trait implementations are subject to implementation coherence and implementation conformance.
11:13 Inherent implementations of the same implementing type shall not define more than one associated item with the same name in the same namespace.
Examples
trait Shape {
fn area(self) -> f64;
}
11:14
Circle is an implementing type.
struct Circle {
radius: f64
}
11:15 The following is an inherent implementation:
impl Circle {
fn set_radius(mut self, new_radius: f64) {
self.radius = new_radius;
}
}
11:16 The following is a trait implementation:
impl Shape for Circle {
fn area(self) -> f64 {
self.radius.powi(2) * std::f64::consts::PI
}
}
11.1. Implementation Coherence¶
Legality Rules
11.1:1 A trait implementation exhibits implementation coherence when it is valid and does not overlap with another trait implementation.
11.1:2 Two trait implementations of the same implemented trait overlap when the intersection of the implementing types is non-empty.
11.1:3
Given trait implementation
impl<P1, P2, .., PN> Trait<T1, T2, .., TN> for T0, the
trait implementation is considered valid when
11.1:4
Traitis fundamental or a local trait, or11.1:5 All of
11.1:6 At least one of types
T0, T1, .., TNis fundamental or a local type, and11.1:7 No type parameter of
P1, P2, .., PNthat is not used in another type may appear in the non-local types and non-fundamental types ofT0, T1, .., TN.
11.1:8 A trait or type is fundamental when its implementation coherence rules are relaxed and the trait or type is always treated as if it was a local trait or a local type.
11.1:9 The following types are fundamental:
11.1:10 reference types
11.1:11
core::pin::Pin
11.1:12 The following traits are fundamental:
11.1:13
core::ops::Fn11.1:14
core::ops::FnMut11.1:15
core::ops::FnOnce11.1:16
core::marker::Sized
11.1:17 A trait implementation shall be coherent.
11.2. Implementation Conformance¶
Legality Rules
11.2:1 A trait implementation exhibits implementation conformance when it satisfies the constraints of its implemented trait.
11.2:2 An associated trait constant is conformant with an associated constant of an implemented trait when
11.2:3 The names of both associated constants are the same, and
11.2:4 The type of the associated constant in the implementation is a subtype of the type of the associated trait constant.
11.2:5 An associated trait function is conformant with an associated function of an implemented trait when
11.2:6 The function signature of the associated function of the implemented trait is a subtype of the function signature of the associated trait function, and
11.2:7 The bounds of the associated function of the implemented trait are more general that the bounds of the associated trait function.
11.2:8 An associated type of a trait implementation is conformant with an associated type of an implemented trait when
11.2:10 The type specification of the associated type of the implemented trait conforms to the bounds of the associated type of the trait implementation.
11.2:11 A trait implementation is conformant with an implemented trait when:
11.2:12 The trait implementation has a conformant associated constant for each associated constant of the implemented trait, unless the associated constant of the implemented trait has a default value, and
11.2:13 The trait implementation has a conformant associated function for each associated function of the implemented trait, unless the associated function of the implemented trait has a default implementation in the implemented trait, and
11.2:14 The trait implementation has a conformant associated type for each associated type of the implemented trait.
11.2:15 A trait implementation shall be conformant.