Module opsCopy item path

use std::ops::{Add, Sub};

#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        Self {x: self.x + other.x, y: self.y + other.y}
    }
}

impl Sub for Point {
    type Output = Self;

    fn sub(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});

fn call_with_one<F>(func: F) -> usize
    where F: Fn(usize) -> usize
{
    func(1)
}

let double = |x| x * 2;
assert_eq!(call_with_one(double), 2);

fn do_twice<F>(mut func: F)
    where F: FnMut()
{
    func();
    func();
}

let mut x: usize = 1;
{
    let add_two_to_x = || x += 2;
    do_twice(add_two_to_x);
}

assert_eq!(x, 5);

fn consume_with_relish<F>(func: F)
    where F: FnOnce() -> String
{
    // `func` consumes its captured variables, so it cannot be run more
    // than once
    println!("Consumed: {}", func());

    println!("Delicious!");

    // Attempting to invoke `func()` again will throw a `use of moved
    // value` error for `func`
}

let x = String::from("x");
let consume_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
  Implement FromResidual<Yeet<T>> on your type to enable do 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.

Traits§

• Add
  The addition operator +.
• AddAssign
  The addition assignment operator +=.
• 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, produced by range syntax like .., a.., ..b, ..=c, d..e, or f..=g.
• Rem
  The remainder operator %.
• RemAssign
  The remainder assignment operator %=.
• Shl
  The left shift operator <<. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ << _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a << b and a.shl(b) are one and the same from an evaluation standpoint, 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 implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ >> _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a >> b and a.shr(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.
• ShrAssign
  The right shift assignment operator >>=.
• Sub
  The subtraction operator -.
• SubAssign
  The subtraction assignment operator -=.
• AsyncFnExperimental
  An async-aware version of the Fn trait.
• AsyncFnMutExperimental
  An async-aware version of the FnMut trait.
• AsyncFnOnceExperimental
  An async-aware version of the FnOnce trait.
• 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-behaved Deref (and, if applicable, DerefMut) implementation. This is relied on for soundness of deref patterns.
• DispatchFromDynExperimental
  DispatchFromDyn is used in the implementation of dyn-compatibility checks (specifically allowing 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 which crate::ops::Try types.
• OneSidedRangeExperimental
  OneSidedRange is implemented for built-in range types that are unbounded on one side. For example, a.., ..b and ..=c implement OneSidedRange, but .., d..e, and f..=g do not.
• ResidualExperimental
  Allows retrieving the canonical type implementing Try that has this type as its residual and allows it to hold an O as its output.
• TryExperimental
  The ? operator and try {} blocks.