usestd::ops::{Add, Sub};#[derive(Debug, Copy, Clone, PartialEq)]structPoint {    x: i32,    y: i32,}implAddforPoint {typeOutput =Self;fnadd(self, other:Self) ->Self{Self{x:self.x + other.x, y:self.y + other.y}    }}implSubforPoint {typeOutput =Self;fnsub(self, other:Self) ->Self{Self{x:self.x - other.x, y:self.y - other.y}    }}assert_eq!(Point {x:3, y:3}, Point {x:1, y:0} + Point {x:2, y:3});assert_eq!(Point {x: -1, y: -3}, Point {x:1, y:0} - Point {x:2, y:3});

fncall_with_one<F>(func: F) -> usizewhereF: Fn(usize) -> usize{    func(1)}letdouble = |x| x *2;assert_eq!(call_with_one(double),2);

fndo_twice<F>(mutfunc: F)whereF: FnMut(){    func();    func();}letmutx: usize =1;{letadd_two_to_x = || x +=2;    do_twice(add_two_to_x);}assert_eq!(x,5);

fnconsume_with_relish<F>(func: F)whereF: FnOnce() -> String{// `func` consumes its captured variables, so it cannot be run more    // than onceprintln!("Consumed: {}", func());println!("Delicious!");// Attempting to invoke `func()` again will throw a `use of moved    // value` error for `func`}letx = String::from("x");letconsume_and_return_x =move|| x;consume_with_relish(consume_and_return_x);// `consume_and_return_x` can no longer be invoked at this point

Structs§

Range

A (half-open) range bounded inclusively below and exclusively above(start..end).

RangeFrom

A range only bounded inclusively below (start..).

RangeFull

An unbounded range (..).

RangeInclusive

A range bounded inclusively below and above (start..=end).

RangeTo

A range only bounded exclusively above (..end).

RangeToInclusive

A range only bounded inclusively above (..=end).

YeetExperimental

ImplementFromResidual<Yeet<T>> on your type to enabledo yeet expr syntax in functions returning your type.

Enums§

Bound

An endpoint of a range of keys.

ControlFlow

Used to tell an operation whether it should exit early or go on as usual.

CoroutineStateExperimental

The result of a coroutine resumption.

OneSidedRangeBoundExperimental

An internal helper forsplit_off functions indicatingwhich end aOneSidedRange is bounded on.

Traits§

Add

The addition operator+.

AddAssign

The addition assignment operator+=.

AsyncFn

An async-aware version of theFn trait.

AsyncFnMut

An async-aware version of theFnMut trait.

AsyncFnOnce

An async-aware version of theFnOnce trait.

BitAnd

The bitwise AND operator&.

BitAndAssign

The bitwise AND assignment operator&=.

BitOr

The bitwise OR operator|.

BitOrAssign

The bitwise OR assignment operator|=.

BitXor

The bitwise XOR operator^.

BitXorAssign

The bitwise XOR assignment operator^=.

Deref

Used for immutable dereferencing operations, like*v.

DerefMut

Used for mutable dereferencing operations, like in*v = 1;.

Div

The division operator/.

DivAssign

The division assignment operator/=.

Drop

Custom code within the destructor.

Fn

The version of the call operator that takes an immutable receiver.

FnMut

The version of the call operator that takes a mutable receiver.

FnOnce

The version of the call operator that takes a by-value receiver.

Index

Used for indexing operations (container[index]) in immutable contexts.

IndexMut

Used for indexing operations (container[index]) in mutable contexts.

Mul

The multiplication operator*.

MulAssign

The multiplication assignment operator*=.

Neg

The unary negation operator-.

Not

The unary logical negation operator!.

RangeBounds

RangeBounds is implemented by Rust’s built-in range types, producedby range syntax like..,a..,..b,..=c,d..e, orf..=g.

Rem

The remainder operator%.

RemAssign

The remainder assignment operator%=.

Shl

The left shift operator<<. Note that because this trait is implementedfor all integer types with multiple right-hand-side types, Rust’s typechecker has special handling for_ << _, setting the result type forinteger operations to the type of the left-hand-side operand. This meansthat thougha << b anda.shl(b) are one and the same from an evaluationstandpoint, they are different when it comes to type inference.

ShlAssign

The left shift assignment operator<<=.

Shr

The right shift operator>>. Note that because this trait is implementedfor all integer types with multiple right-hand-side types, Rust’s typechecker has special handling for_ >> _, setting the result type forinteger operations to the type of the left-hand-side operand. This meansthat thougha >> b anda.shr(b) are one and the same from an evaluationstandpoint, they are different when it comes to type inference.

ShrAssign

The right shift assignment operator>>=.

Sub

The subtraction operator-.

SubAssign

The subtraction assignment operator-=.

CoerceSharedExperimental

Allows reborrowable value to be reborrowed as shared, creating a copythat disables the source for writes for the lifetime of the copy.

CoerceUnsizedExperimental

Trait that indicates that this is a pointer or a wrapper for one,where unsizing can be performed on the pointee.

CoroutineExperimental

The trait implemented by builtin coroutine types.

DerefPureExperimental

Perma-unstable marker trait. Indicates that the type has a well-behavedDeref(and, if applicable,DerefMut) implementation. This is relied on for soundnessof deref patterns.

DispatchFromDynExperimental

DispatchFromDyn is used in the implementation of dyn-compatibility checks (specificallyallowing arbitrary self types), to guarantee that a method’s receiver type can be dispatched on.

FromResidualExperimental

Used to specify which residuals can be converted into whichcrate::ops::Try types.

IntoBoundsExperimental

Used to convert a range into start and end bounds, consuming therange by value.

OneSidedRangeExperimental

OneSidedRange is implemented for built-in range types that are unboundedon one side. For example,a..,..b and..=c implementOneSidedRange,but..,d..e, andf..=g do not.

ReborrowExperimental

Allows value to be reborrowed as exclusive, creating a copy of the valuethat disables the source for reads and writes for the lifetime of the copy.

ReceiverExperimental

Indicates that a struct can be used as a method receiver.That is, a type can use this type as a type ofself, like this:

ResidualExperimental

Allows retrieving the canonical type implementingTry that has this typeas its residual and allows it to hold anO as its output.

TryExperimental

The? operator andtry {} blocks.