Enum Lang

#[non_exhaustive]
pub enum Lang {
    Asm,
    Bash,
    C,
    CSharp,
    Cmake,
    Cpp,
    Css,
    Diff,
    Ejs,
    Elixir,
    Erb,
    Fish,
    Gleam,
    Go,
    Haskell,
    Html,
    Java,
    Javascript,
    Jsdoc,
    Json,
    Julia,
    Kotlin,
    Lalrpop,
    Lua,
    Make,
    Markdown,
    MarkdownInline,
    Nix,
    Ocaml,
    OcamlInterface,
    Php,
    PhpOnly,
    Printf,
    Python,
    Ql,
    Regex,
    Ruby,
    Rush,
    Rust,
    Scala,
    Sql,
    Tsx,
    Typescript,
    Yaml,
    Zig,
}

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_gitdep::{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 as SupportedLanguage<'_, ()>>::name(&lang), &()).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.

Bash

Available on crate features some or bash only.

Provides the bash language, supports these file types: sh, bash, ksh.

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.

Cmake

Available on crate features most or cmake only.

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

Cpp

Available on crate features some or cpp 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.

Diff

Available on crate features most or diff only.

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

Ejs

Available on crate features all or ejs only.

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

Elixir

Available on crate features most or elixir only.

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

Erb

Available on crate features all or erb only.

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

Fish

Available on crate features all or fish only.

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

Gleam

Available on crate features all or gleam only.

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

Go

Available on crate features some or go only.

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

Haskell

Available on crate features most or haskell only.

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

Html

Available on crate features some or html only.

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

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.

Jsdoc

Available on crate features most or jsdoc only.

Provides the jsdoc language, supports no file types.

Json

Available on crate features some or json only.

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

Julia

Available on crate features all or julia only.

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

Kotlin

Available on crate features some or kotlin only.

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

Lalrpop

Available on crate features all or lalrpop only.

Provides the lalrpop language, supports no file types.

Lua

Available on crate features some or lua only.

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

Make

Available on crate features most or make only.

Provides the make language, supports these file types: make, automake.

Markdown

Available on crate features most or markdown only.

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

MarkdownInline

Available on crate features most or markdown_inline only.

Provides the markdown_inline language, supports no file types.

Nix

Available on crate features most or nix only.

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

Ocaml

Available on crate features all or ocaml only.

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

OcamlInterface

Available on crate features all or ocaml_interface only.

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

Php

Available on crate features most or php only.

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

PhpOnly

Available on crate features most or php_only only.

Provides the php_only language, supports no file types.

Printf

Available on crate features most or printf only.

Provides the printf language, supports no file types.

Python

Available on crate features some or python only.

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

Ql

Available on crate features all or ql only.

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

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 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 only.

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

Sql

Available on crate features most or sql only.

Provides the sql language, supports these file types: sql, mysql.

Tsx

Available on crate features some or tsx only.

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

Typescript

Available on crate features some or typescript only.

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

Yaml

Available on crate features some or yaml only.

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

Zig

Available on crate features most or zig only.

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

Implementations

impl Lang

pub fn get(&self) -> Language

Get an instance of the respective Language.

pub fn get_config(&self) -> Result<HighlightConfiguration>

Create an instance of the corresponding HighlightConfiguration.

pub fn highlights_query(&self) -> &'static str

Get the highlights query for this language.

pub fn injections_query(&self) -> &'static str

Get the injections query for this language.

pub fn locals_query(&self) -> &'static str

Get the locals query for this 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 for Lang

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

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

Get the name for this language.

fn for_name(name: impl AsRef<str>, _set: &S) -> Result<Self>

Get the language with the given name.

fn for_file_type(file_type: FileType, _set: &S) -> Option<Self>

Find a language based on the given [FileType].

fn for_injection(name: impl AsRef<str>, set: &'set S) -> 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 StructuralPartialEq for Lang