Enum syntastica_parsers::Lang

#[non_exhaustive]
pub enum Lang {
    Asm,
    C,
    CSharp,
    Comment,
    Cpp,
    Css,
    Ebnf,
    Ejs,
    Erb,
    Go,
    Hexdump,
    Java,
    Javascript,
    Json,
    Lua,
    Markdown,
    MarkdownInline,
    Ocaml,
    OcamlInterface,
    Python,
    Regex,
    Ruby,
    Rush,
    Rust,
    Scala,
    Toml,
    Ursa,
}

An enum of every supported language in the current feature set.

An instance of the respective tree-stter Language can be obtained with the get method.

You can also get a Lang from its name using for_name, or for a FileType using for_file_type. See the docs for each variant to see its “name” and the supported file types. Both of these require the SupportedLanguage trait to be in scope.

See LANGUAGES for a list containing all variants and LANGUAGE_NAMES for a list of all valid names.

The enum is marked as non-exhaustive for two reasons:

1. New languages may be added in the future
2. The variants are enabled/disabled by features

Example

use syntastica_parsers::{Lang, LANGUAGES, LANGUAGE_NAMES};
use syntastica_core::language_set::{SupportedLanguage, FileType};

// you can get a `Lang` from its name
assert_eq!(Lang::Rust, Lang::for_name("rust").unwrap());
// and for a file type
assert_eq!(Some(Lang::Rust), Lang::for_file_type(FileType::Rust));

// `LANGUAGES` is a list of all variants,
// `LANGUAGE_NAMES` is a list of all variant names
for (&lang, &name) in LANGUAGES.iter().zip(LANGUAGE_NAMES) {
    assert_eq!(lang, Lang::for_name(name).unwrap());

    // `Lang` instances can be turned into strings
    assert_eq!(lang, Lang::for_name(lang.name()).unwrap());
    assert_eq!(lang, Lang::for_name(lang.to_string()).unwrap());
    assert_eq!(lang, Lang::for_name(lang.as_ref()).unwrap());
    let lang_name: &'static str = lang.into();
    assert_eq!(lang, Lang::for_name(lang_name).unwrap());
}

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

Available on crate features most or asm only.

Provides the asm language, supports these file types: asm, vmasm.

C

Available on crate features some or c only.

Provides the c language, supports these file types: c.

CSharp

Available on crate features most or c_sharp only.

Provides the c_sharp language, supports these file types: csharp.

Comment

Available on crate features most or comment only.

Provides the comment language, supports no file types.

Cpp

Available on (crate features some or cpp) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the cpp language, supports these file types: cpp.

Css

Available on crate features some or css only.

Provides the css language, supports these file types: css.

Ebnf

Available on crate features all or ebnf only.

Provides the ebnf language, supports these file types: ebnf.

Ejs

Available on crate features all or ejs only.

Provides the ejs language, supports these file types: ejavascript.

Erb

Available on crate features all or erb only.

Provides the erb language, supports these file types: eruby.

Go

Available on crate features some or go only.

Provides the go language, supports these file types: go.

Hexdump

Available on crate features all or hexdump only.

Provides the hexdump language, supports these file types: hexdump.

Java

Available on crate features some or java only.

Provides the java language, supports these file types: java.

Javascript

Available on crate features some or javascript only.

Provides the javascript language, supports these file types: javascript, jsx.

Json

Available on crate features some or json only.

Provides the json language, supports these file types: json.

Lua

Available on (crate features some or lua) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the lua language, supports these file types: lua.

Markdown

Available on (crate features most or markdown) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the markdown language, supports these file types: markdown.

MarkdownInline

Available on (crate features most or markdown_inline) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the markdown_inline language, supports these file types: markdown.

Ocaml

Available on (crate features all or ocaml) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the ocaml language, supports these file types: ocaml.

OcamlInterface

Available on (crate features all or ocaml_interface) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the ocaml_interface language, supports these file types: ocamlinterface.

Python

Available on (crate features some or python) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the python language, supports these file types: python.

Regex

Available on crate features most or regex only.

Provides the regex language, supports no file types.

Ruby

Available on (crate features most or ruby) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the ruby language, supports these file types: ruby.

Rush

Available on crate features all or rush only.

Provides the rush language, supports these file types: rush.

Rust

Available on crate features some or rust only.

Provides the rust language, supports these file types: rust.

Scala

Available on (crate features most or scala) and not (WebAssembly and target_vendor="unknown" and target_os="unknown" and target_env="") only.

Provides the scala language, supports these file types: scala, sbt.

Toml

Available on crate features some or toml only.

Provides the toml language, supports these file types: toml.

Ursa

Available on crate features all or ursa only.

Provides the ursa language, supports these file types: ursa.

Implementations

impl Lang

pub fn get(&self) -> Language

Get an instance of the respective Language.

Trait Implementations

impl AsRef<str> for Lang

fn as_ref(&self) -> &str

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

impl Clone for Lang

fn clone(&self) -> Lang

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Lang

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

Formats the value using the given formatter.

impl Display for Lang

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

Formats the value using the given formatter.

impl<'_derivative_strum> From<&'_derivative_strum Lang> for &'static str

fn from(x: &'_derivative_strum Lang) -> &'static str

Converts to this type from the input type.

impl From<Lang> for &'static str

fn from(x: Lang) -> &'static str

Converts to this type from the input type.

impl FromStr for Lang

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl Hash for Lang

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<Lang> for Lang

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

fn name(&self) -> Cow<'_, str>

Get the name for this language.

fn for_name(name: impl AsRef<str>) -> Result<Self>

Get the language with the given name.

fn for_file_type(file_type: FileType) -> Option<Self>

Find a language based on the given [FileType].

fn for_injection(name: impl AsRef<str>) -> Option<Self>

Find a language for an injection.

impl TryFrom<&str> for Lang

type Error = ParseError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for Lang

impl Eq for Lang

impl StructuralEq for Lang

impl StructuralPartialEq for Lang