Enum Language 

#[non_exhaustive]
#[repr(u8)]
pub enum Language {
    Asm = 0,
    Batch = 1,
    C = 2,
    Clojure = 3,
    CMake = 4,
    Cobol = 5,
    Cpp = 6,
    Cs = 7,
    Css = 8,
    Dart = 9,
    Dockerfile = 10,
    Elixir = 11,
    Erlang = 12,
    Gemfile = 13,
    Gemspec = 14,
    Go = 15,
    Gradle = 16,
    Groovy = 17,
    Haskell = 18,
    Html = 19,
    Ini = 20,
    Java = 21,
    JavaScript = 22,
    Json = 23,
    Julia = 24,
    Kotlin = 25,
    Lisp = 26,
    Lua = 27,
    Markdown = 28,
    ObjectiveC = 29,
    Ocaml = 30,
    Perl = 31,
    Php = 32,
    Powershell = 33,
    Python = 34,
    R = 35,
    Ruby = 36,
    Rust = 37,
    Scala = 38,
    Shell = 39,
    Sql = 40,
    Swift = 41,
    Toml = 42,
    TypeScript = 43,
    Vba = 44,
    Verilog = 45,
    Xml = 46,
    Yaml = 47,
}

Source language predicted by the embedded Magika student model.

Languages parse from their model label slugs with str::parse.

let language = "rust".parse::<betlang::Language>()?;

assert_eq!(language, betlang::Language::Rust);
assert_eq!(language.slug(), "rust");

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.

Asm = 0

Model label "asm".

Batch = 1

Model label "batch".

C = 2

Model label "c".

Clojure = 3

Model label "clojure".

CMake = 4

Model label "cmake".

Cobol = 5

Model label "cobol".

Cpp = 6

Model label "cpp".

Cs = 7

Model label "cs".

Css = 8

Model label "css".

Dart = 9

Model label "dart".

Dockerfile = 10

Model label "dockerfile".

Elixir = 11

Model label "elixir".

Erlang = 12

Model label "erlang".

Gemfile = 13

Model label "gemfile".

Gemspec = 14

Model label "gemspec".

Go = 15

Model label "go".

Gradle = 16

Model label "gradle".

Groovy = 17

Model label "groovy".

Haskell = 18

Model label "haskell".

Html = 19

Model label "html".

Ini = 20

Model label "ini".

Java = 21

Model label "java".

JavaScript = 22

Model label "javascript".

Json = 23

Model label "json".

Julia = 24

Model label "julia".

Kotlin = 25

Model label "kotlin".

Lisp = 26

Model label "lisp".

Lua = 27

Model label "lua".

Markdown = 28

Model label "markdown".

ObjectiveC = 29

Model label "objectivec".

Ocaml = 30

Model label "ocaml".

Perl = 31

Model label "perl".

Php = 32

Model label "php".

Powershell = 33

Model label "powershell".

Python = 34

Model label "python".

R = 35

Model label "r".

Ruby = 36

Model label "ruby".

Rust = 37

Model label "rust".

Scala = 38

Model label "scala".

Shell = 39

Model label "shell".

Sql = 40

Model label "sql".

Swift = 41

Model label "swift".

Toml = 42

Model label "toml".

TypeScript = 43

Model label "typescript".

Vba = 44

Model label "vba".

Verilog = 45

Model label "verilog".

Xml = 46

Model label "xml".

Yaml = 47

Model label "yaml".

Implementations

impl Language

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

Model label slug for this detected language.

assert_eq!(betlang::Language::Rust.slug(), "rust");

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

impl Debug for Language

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

Formats the value using the given formatter.

impl Eq for Language

impl FromStr for Language

Parses a Language from its model label slug.

assert_eq!("rust".parse::<betlang::Language>()?, betlang::Language::Rust);

type Err = ParseLanguageError

The associated error which can be returned from parsing.

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

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

impl Hash for Language

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 Language

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Language