Enum Language 

#[non_exhaustive]
pub enum Language {
    Asm,
    Awk,
    Batch,
    Bash,
    C,
    CSharp,
    Clojure,
    CMake,
    Cobol,
    CommonLisp,
    Cpp,
    Css,
    Dart,
    Diff,
    Dockerfile,
    Elixir,
    Erlang,
    Go,
    Groovy,
    Haskell,
    Hcl,
    Html,
    Ini,
    Java,
    JavaScript,
    Jinja2,
    Json,
    Julia,
    Kotlin,
    Lua,
    Markdown,
    Matlab,
    ObjectiveC,
    Ocaml,
    Perl,
    Php,
    Postscript,
    Powershell,
    Prolog,
    Python,
    R,
    Ruby,
    Rust,
    Scala,
    Scss,
    Solidity,
    Sql,
    Starlark,
    Swift,
    TextProto,
    Toml,
    TypeScript,
    Vb,
    Verilog,
    Vhdl,
    Vue,
    Xml,
    Yaml,
    Zig,
}

Source language predicted by the embedded Magika student model.

Languages parse from their public 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

Arborium slug "asm".

Awk

Arborium slug "awk".

Batch

Arborium slug "batch".

Bash

Arborium slug "bash".

C

Arborium slug "c".

CSharp

Arborium slug "c-sharp".

Clojure

Arborium slug "clojure".

CMake

Arborium slug "cmake".

Cobol

Arborium slug "cobol".

CommonLisp

Arborium slug "commonlisp".

Cpp

Arborium slug "cpp".

Css

Arborium slug "css".

Dart

Arborium slug "dart".

Diff

Arborium slug "diff".

Dockerfile

Arborium slug "dockerfile".

Elixir

Arborium slug "elixir".

Erlang

Arborium slug "erlang".

Go

Arborium slug "go".

Groovy

Arborium slug "groovy".

Haskell

Arborium slug "haskell".

Hcl

Arborium slug "hcl".

Html

Arborium slug "html".

Ini

Arborium slug "ini".

Java

Arborium slug "java".

JavaScript

Arborium slug "javascript".

Jinja2

Arborium slug "jinja2".

Json

Arborium slug "json".

Julia

Arborium slug "julia".

Kotlin

Arborium slug "kotlin".

Lua

Arborium slug "lua".

Markdown

Arborium slug "markdown".

Matlab

Arborium slug "matlab".

ObjectiveC

Arborium slug "objc".

Ocaml

Arborium slug "ocaml".

Perl

Arborium slug "perl".

Php

Arborium slug "php".

Postscript

Arborium slug "postscript".

Powershell

Arborium slug "powershell".

Prolog

Arborium slug "prolog".

Python

Arborium slug "python".

R

Arborium slug "r".

Ruby

Arborium slug "ruby".

Rust

Arborium slug "rust".

Scala

Arborium slug "scala".

Scss

Arborium slug "scss".

Solidity

Arborium slug "solidity".

Sql

Arborium slug "sql".

Starlark

Arborium slug "starlark".

Swift

Arborium slug "swift".

TextProto

Arborium slug "textproto".

Toml

Arborium slug "toml".

TypeScript

Arborium slug "typescript".

Vb

Arborium slug "vb".

Verilog

Arborium slug "verilog".

Vhdl

Arborium slug "vhdl".

Vue

Arborium slug "vue".

Xml

Arborium slug "xml".

Yaml

Arborium slug "yaml".

Zig

Arborium slug "zig".

Implementations

impl Language

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

Arborium/tree-sitter language 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 Debug for Language

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

Formats the value using the given formatter.

impl FromStr for Language

Parses a Language from its public 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

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 Language

impl Eq for Language

impl StructuralPartialEq for Language