Trait snarkvm_circuit::Add

1.0.0 · source · 
pub trait Add<Rhs = Self> {
    type Output;

    fn add(self, rhs: Rhs) -> Self::Output;
}
Expand description

The addition operator +.

Note that Rhs is Self by default, but this is not mandatory. For example, std::time::SystemTime implements Add<Duration>, which permits operations of the form SystemTime = SystemTime + Duration.

Examples

Addable points

use std::ops::Add;

#[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,
        }
    }
}

assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
           Point { x: 3, y: 3 });

Implementing Add with generics

Here is an example of the same Point struct implementing the Add trait using generics.

use std::ops::Add;

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

// Notice that the implementation uses the associated type `Output`.
impl<T: Add<Output = T>> Add for Point<T> {
    type Output = Self;

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

assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },
           Point { x: 3, y: 3 });

Required Associated Types

The resulting type after applying the + operator.

Required Methods

Performs the + operation.

Example
assert_eq!(12 + 1, 13);

Trait Implementations

Returns the number of constants, public inputs, private inputs, and constraints.
Returns the number of constants, public inputs, private inputs, and constraints.
Returns the number of constants, public inputs, private inputs, and constraints.
Returns the number of constants, public inputs, private inputs, and constraints.
Returns the mode of the output.
Returns the mode of the output.
Returns the mode of the output.
Returns the mode of the output.

Implementors

Implements the + operator for concatenating two strings.

This consumes the String on the left-hand side and re-uses its buffer (growing it if necessary). This is done to avoid allocating a new String and copying the entire contents on every operation, which would lead to O(n^2) running time when building an n-byte string by repeated concatenation.

The string on the right-hand side is only borrowed; its contents are copied into the returned String.

Examples

Concatenating two Strings takes the first by value and borrows the second:

let a = String::from("hello");
let b = String::from(" world");
let c = a + &b;
// `a` is moved and can no longer be used here.

If you want to keep using the first String, you can clone it and append to the clone instead:

let a = String::from("hello");
let b = String::from(" world");
let c = a.clone() + &b;
// `a` is still valid here.

Concatenating &str slices can be done by converting the first to a String:

let a = "hello";
let b = " world";
let c = a.to_string() + b;

UTerm + B0 = UTerm

UTerm + B1 = UInt<UTerm, B1>

Z0 + I = I

UInt<U, B0> + B1 = UInt<U + B1>

UInt<U, B1> + B1 = UInt<U + B1, B0>

NInt + Z0 = NInt

PInt + Z0 = PInt

UTerm + U = U

U + B0 = U

UInt<U, B> + UTerm = UInt<U, B>

N(Ul) + N(Ur) = N(Ul + Ur)

P(Ul) + N(Ur): We resolve this with our PrivateAdd

N(Ul) + P(Ur): We resolve this with our PrivateAdd

P(Ul) + P(Ur) = P(Ul + Ur)

UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>

UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>

UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>

UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>