Enum deeprl::Language

pub enum Language {
    BG,
    CS,
    DA,
    DE,
    EL,
    EN,
    ENGB,
    ENUS,
    ES,
    ET,
    FI,
    FR,
    HU,
    ID,
    IT,
    JA,
    KO,
    LT,
    LV,
    NB,
    NL,
    PL,
    PT,
    PTBR,
    PTPT,
    RO,
    RU,
    SK,
    SL,
    SV,
    TR,
    UK,
    ZH,
}

Language variants.

Please note that while many Language variants are interchangeable as both source and target languages, there are exceptions. For example when translating text and documents, the following may only be used as source languages:

• EN
• PT

and the following may only be used as target languages (representing regional variants):

• ENUS
• ENGB
• PTBR
• PTPT

Variants

BG

Bulgarian

CS

Czech

DA

Danish

DE

German

EL

Greek

EN

English (source language)

ENGB

English British (target language)

ENUS

English American (target language)

ES

Spanish

ET

Estonian

FI

Finish

FR

French

HU

Hungarian

ID

Indonesian

IT

Italian

JA

Japanese

KO

Korean

LT

Lithuanian

LV

Latvian

NB

Norwegian

NL

Dutch

PL

Polish

PT

Portuguese (source language)

PTBR

Portuguese Brazilian (target language)

PTPT

Portuguese European (target language)

RO

Romanian

RU

Russian

SK

Slovak

SL

Slovenian

SV

Swedish

TR

Turkish

UK

Ukranian

ZH

Chinese simplified

Trait Implementations

impl AsRef<str> for Language

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Language

fn clone(&self) -> Language

Returns a copy 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

Formats the value using the given formatter.

impl Display for Language

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

Formats the value using the given formatter.

impl FromStr for Language

fn from_str(s: &str) -> Result<Self, Self::Err>

Errors

If a Language cannot be parsed from the input s

type Err = Error

The associated error which can be returned from parsing.

impl PartialEq for Language

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Language

impl StructuralPartialEq for Language