Enum Language 

pub enum Language {
    AB,
    AA,
    AF,
    AK,
    SQ,
    AM,
    AR,
    AN,
    HY,
    AS,
    AV,
    AE,
    AY,
    AZ,
    BM,
    BA,
    EU,
    BE,
    BN,
    BI,
    BS,
    BR,
    BG,
    MY,
    CA,
    CH,
    CE,
    NY,
    ZH,
    CU,
    CV,
    KW,
    CO,
    CR,
    HR,
    CS,
    DA,
    DV,
    NL,
    DZ,
    EN,
    EO,
    ET,
    EE,
    FO,
    FJ,
    FI,
    FR,
    FY,
    FF,
    GD,
    GL,
    LG,
    KA,
    DE,
    EL,
    KL,
    GN,
    GU,
    HT,
    HA,
    HE,
    HZ,
    HI,
    HO,
    HU,
    IS,
    IO,
    IG,
    ID,
    IA,
    IE,
    IU,
    IK,
    GA,
    IT,
    JA,
    JV,
    KN,
    KR,
    KS,
    KK,
    KM,
    KI,
    RW,
    KY,
    KV,
    KG,
    KO,
    KJ,
    KU,
    LO,
    LA,
    LV,
    LI,
    LN,
    LT,
    LU,
    LB,
    MK,
    MG,
    MS,
    ML,
    MT,
    GV,
    MI,
    MR,
    MH,
    MN,
    NA,
    NV,
    ND,
    NR,
    NG,
    NE,
    NO,
    NB,
    NN,
    OC,
    OJ,
    OR,
    OM,
    OS,
    PI,
    PS,
    FA,
    PL,
    PT,
    PA,
    QU,
    RO,
    RM,
    RN,
    RU,
    SE,
    SM,
    SG,
    SA,
    SC,
    SR,
    SN,
    SD,
    SI,
    SK,
    SL,
    SO,
    ST,
    ES,
    SU,
    SW,
    SS,
    SV,
    TL,
    TY,
    TG,
    TA,
    TT,
    TE,
    TH,
    BO,
    TI,
    TO,
    TS,
    TN,
    TR,
    TK,
    TW,
    UG,
    UK,
    UR,
    UZ,
    VE,
    VI,
    VO,
    WA,
    CY,
    WO,
    XH,
    II,
    YI,
    YO,
    ZA,
    ZU,
}

Language enum re-export.

This use statement re-exports from the hidden shared re-export for user convenience on parsing. ISO 639-1 language code implementation with validation

Provides two-way mapping between language codes and names with:

• Case-insensitive parsing
• Strict validation
• Complete ISO 639-1 coverage

Variants

AB

AA

AF

AK

SQ

AM

AR

AN

HY

AS

AV

AE

AY

AZ

BM

BA

EU

BE

BN

BI

BS

BR

BG

MY

CA

CH

CE

NY

ZH

CU

CV

KW

CO

CR

HR

CS

DA

DV

NL

DZ

EN

EO

ET

EE

FO

FJ

FI

FR

FY

FF

GD

GL

LG

KA

DE

EL

KL

GN

GU

HT

HA

HE

HZ

HI

HO

HU

IS

IO

IG

ID

IA

IE

IU

IK

GA

IT

JA

JV

KN

KR

KS

KK

KM

KI

RW

KY

KV

KG

KO

KJ

KU

LO

LA

LV

LI

LN

LT

LU

LB

MK

MG

MS

ML

MT

GV

MI

MR

MH

MN

NA

NV

ND

NR

NG

NE

NO

NB

NN

OC

OJ

OR

OM

OS

PI

PS

FA

PL

PT

PA

QU

RO

RM

RN

RU

SE

SM

SG

SA

SC

SR

SN

SD

SI

SK

SL

SO

ST

ES

SU

SW

SS

SV

TL

TY

TG

TA

TT

TE

TH

BO

TI

TO

TS

TN

TR

TK

TW

UG

UK

UR

UZ

VE

VI

VO

WA

CY

WO

XH

II

YI

YO

ZA

ZU

Trait Implementations

impl Clone for Language

fn clone(&self) -> Language

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Language

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

Formats the value using the given formatter.

impl Display for Language

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

Formats the value using the given formatter.

impl FromStr for Language

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Language, <Language as FromStr>::Err>

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

impl Hash for Language

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

where __H: Hasher,

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 IntoEnumIterator for Language

type Iterator = LanguageIter

fn iter() -> LanguageIter

impl PartialEq for Language

fn eq(&self, other: &Language) -> 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 ToTokens for Language

This implementation converts the tagged union to an equivalent call from the runtime context.

This is exclusively meant to be used from the macro generation context.

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.

impl TryFrom<&str> for Language

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Language, <Language as TryFrom<&str>>::Error>

Performs the conversion.

impl Eq for Language

impl StructuralPartialEq for Language