Enum WrittenUnit 

#[non_exhaustive]
pub enum WrittenUnit {
    A,
    Aa,
    Ah,
    Ai,
    At,
    B,
    B2,
    C,
    Cc,
    Ch,
    Cp,
    Cr,
    Cs,
    D,
    Db,
    Dd,
    Dh,
    Dp,
    Dt,
    E,
    F,
    G,
    G2,
    G3,
    G4,
    Gc,
    Gh,
    Gp,
    Gx,
    H,
    Hb,
    Hc,
    Hh,
    Hp,
    Hr,
    Hx,
    Hx2,
    I,
    I3,
    Ic,
    Ip,
    Ix,
    Iy,
    J,
    J2,
    Jb,
    Jc,
    K,
    K2,
    Kc,
    Kh,
    Kp,
    L,
    Lv,
    M,
    M2,
    Mvs,
    N,
    N2,
    Nirugu,
    Nx,
    Ny,
    O,
    Ob,
    Oh,
    Op,
    Ot,
    P,
    Pb,
    Pp,
    R,
    R2,
    R3,
    Rh,
    Rr,
    S,
    Sh,
    Sp,
    Sz,
    T,
    Tb,
    Th,
    Tp,
    Tt,
    U,
    Ue,
    Uh,
    Up,
    Ux,
    V,
    W,
    Wb,
    Y,
    Yp,
    Z,
    Zc,
    Zr,
    Zs,
    Zs2,
    Zwj,
    Zz,
}

A written unit: an opaque glyph-form identifier produced by shaping (see docs/data-format.md). The structural tokens Mvs, Nirugu and Zwj are members too: they appear verbatim in Shaper::shape output, exactly as the Python implementation emits them.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

A

Written unit A.

Aa

Written unit Aa.

Ah

Written unit Ah.

Ai

Written unit Ai.

At

Written unit At.

B

Written unit B.

B2

Written unit B2.

C

Written unit C.

Cc

Written unit Cc.

Ch

Written unit Ch.

Cp

Written unit Cp.

Cr

Written unit Cr.

Cs

Written unit Cs.

D

Written unit D.

Db

Written unit Db.

Dd

Written unit Dd.

Dh

Written unit Dh.

Dp

Written unit Dp.

Dt

Written unit Dt.

E

Written unit E.

F

Written unit F.

G

Written unit G.

G2

Written unit G2.

G3

Written unit G3.

G4

Written unit G4.

Gc

Written unit Gc.

Gh

Written unit Gh.

Gp

Written unit Gp.

Gx

Written unit Gx.

H

Written unit H.

Hb

Written unit Hb.

Hc

Written unit Hc.

Hh

Written unit Hh.

Hp

Written unit Hp.

Hr

Written unit Hr.

Hx

Written unit Hx.

Hx2

Written unit Hx2.

I

Written unit I.

I3

Written unit I3.

Ic

Written unit Ic.

Ip

Written unit Ip.

Ix

Written unit Ix.

Iy

Written unit Iy.

J

Written unit J.

J2

Written unit J2.

Jb

Written unit Jb.

Jc

Written unit Jc.

K

Written unit K.

K2

Written unit K2.

Kc

Written unit Kc.

Kh

Written unit Kh.

Kp

Written unit Kp.

L

Written unit L.

Lv

Written unit Lv.

M

Written unit M.

M2

Written unit M2.

Mvs

Structural token: Mongolian vowel separator U+180E (NNBSP U+202F is folded into it).

N

Written unit N.

N2

Written unit N2.

Nirugu

Structural token: nirugu U+180A, the visible stem extender.

Nx

Written unit Nx.

Ny

Written unit Ny.

O

Written unit O.

Ob

Written unit Ob.

Oh

Written unit Oh.

Op

Written unit Op.

Ot

Written unit Ot.

P

Written unit P.

Pb

Written unit Pb.

Pp

Written unit Pp.

R

Written unit R.

R2

Written unit R2.

R3

Written unit R3.

Rh

Written unit Rh.

Rr

Written unit Rr.

S

Written unit S.

Sh

Written unit Sh.

Sp

Written unit Sp.

Sz

Written unit Sz.

T

Written unit T.

Tb

Written unit Tb.

Th

Written unit Th.

Tp

Written unit Tp.

Tt

Written unit Tt.

U

Written unit U.

Ue

Written unit Ue.

Uh

Written unit Uh.

Up

Written unit Up.

Ux

Written unit Ux.

V

Written unit V.

W

Written unit W.

Wb

Written unit Wb.

Y

Written unit Y.

Yp

Written unit Yp.

Z

Written unit Z.

Zc

Written unit Zc.

Zr

Written unit Zr.

Zs

Written unit Zs.

Zs2

Written unit Zs2.

Zwj

Structural token: zero width joiner U+200D.

Zz

Written unit Zz.

Implementations

impl WrittenUnit

pub const ALL: [WrittenUnit; 101]

Every variant, in declaration (sorted contract-name) order.

pub const fn as_str(self) -> &'static str

The contract name used by the Python API, the CLI and the data files.

pub const fn is_structural(self) -> bool

true for the structural tokens Mvs, Nirugu and Zwj.

Trait Implementations

impl Clone for WrittenUnit

fn clone(&self) -> WrittenUnit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for WrittenUnit

impl Debug for WrittenUnit

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

Formats the value using the given formatter.

impl Display for WrittenUnit

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

Formats the value using the given formatter.

impl Eq for WrittenUnit

impl FromStr for WrittenUnit

type Err = Error

The associated error which can be returned from parsing.

fn from_str(name: &str) -> Result<WrittenUnit, Error>

Parses a string s to return a value of this type.

impl Hash for WrittenUnit

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 Ord for WrittenUnit

fn cmp(&self, other: &WrittenUnit) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for WrittenUnit

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for WrittenUnit

fn partial_cmp(&self, other: &WrittenUnit) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for WrittenUnit