Struct Finger 

pub struct Finger {
    pub hand: Hand,
    pub kind: FingerKind,
}

Fields

hand: Hand

kind: FingerKind

Implementations

impl Finger

pub fn new(hand: Hand, kind: FingerKind) -> Finger

pub fn dir_to(self, f: Finger) -> Direction

Returns the direction between self and the argument f.

use keynergy::{Finger, Hand, FingerKind, Direction};
let ri = Finger::new(Hand::Right, FingerKind::Index);
let rm = Finger::new(Hand::Right, FingerKind::Middle);
assert_eq!(Direction::Outward, ri.dir_to(rm));
assert_eq!(Direction::Inward, rm.dir_to(ri));
assert_eq!(Direction::None, ri.dir_to(ri));

Trait Implementations

impl Clone for Finger

fn clone(&self) -> Finger

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Finger

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

Formats the value using the given formatter.

impl Hash for Finger

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 Finger

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Finger

impl Eq for Finger

impl StructuralPartialEq for Finger