fn pub !=(other: ref Self) -> Bool {
  (self == other).false?
}

fn pub !=(other: ref Self) -> Bool
if
  A: Equal

Returns true if self and the given object are not equal to each other.

fn pub ==(other: ref Tuple1[A]) -> Bool {
  @0 == other.0
}

fn pub ==(other: ref (A)) -> Bool
if
  A: Equal

Returns true if self and the given object are equal to each other.

This operator is used to perform structural equality. This means two objects residing in different memory locations may be considered equal, provided their structure is equal. For example, two different arrays may be considered to have structural equality if they contain the exact same values.

fn pub clone -> Tuple1[move A] {
  (@0.clone,)
}

fn pub clone -> (move A)
if
  A: Clone

Creates a clone of self.

The returned value is an owned value that is the same type as the receiver of this method. For example, cloning a ref Array[Int] results in a Array[Int], not another ref Array[Int].

fn pub fmt(formatter: mut Formatter) {
  formatter.tuple('').field(@0).finish
}

fn pub fmt(formatter: mut Formatter)
if
  A: Format

Formats self in a human-readable format for debugging purposes.

fn pub hash[H: mut + Hasher](hasher: mut H) {
  @0.hash(hasher)
}

fn pub hash[H: mut + Hasher](hasher: mut H: mut)
if
  A: Hash

Writes the hash for self into the given Hasher.