Struct Key 

pub struct Key { /* private fields */ }

A value used as a dict key or a set member.

Two jobs. It carries the hash, computed once when the key was made, because a dict asks for it on every lookup and a big tuple would otherwise walk itself each time. And it gives Rust’s Hash and Eq Python’s meaning rather than the derived one, so 1, 1.0 and True are one key.

Making one is where an unhashable value is caught, so a Key that exists is a value that had a hash at the time it was made. Nothing here can change afterwards, since the only mutable object in the object model is a list and a list has no hash.

Implementations

impl Key

pub fn new(object: Object) -> Result<Self, Unhashable>

Takes a value as a key.

Errors

The value has no hash, so it cannot be one.

pub const fn object(&self) -> &Object

The value itself, which is what iterating a dict hands back.

pub fn into_object(self) -> Object

The value, giving up the key.

pub const fn hash(&self) -> i64

The hash, computed when this was made.

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Key

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Key

impl FromIterator<Key> for Set

fn from_iter<I: IntoIterator<Item = Key>>(values: I) -> Self

Creates a value from an iterator.

impl Hash for Key

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Key

fn eq(&self, other: &Self) -> bool

What a dict lookup asks, which is not quite ==.

Identity comes first, and that is the whole reason a NaN can be used as a dict key and found again. x == x is false for one, so a lookup that only asked == would store it and then never find it.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.