Enum tokei::LanguageType

#[non_exhaustive]pub enum LanguageType {
    Abap,
    ActionScript,
    Ada,
    Agda,
    Alex,
    Alloy,
    Arduino,
    Asn1,
    Asp,
    AspNet,
    Assembly,
    AssemblyGAS,
    AutoHotKey,
    Autoconf,
    Automake,
    Bash,
    Batch,
    BrightScript,
    C,
    CHeader,
    CMake,
    CSharp,
    CShell,
    Cabal,
    Cassius,
    Ceylon,
    Clojure,
    ClojureC,
    ClojureScript,
    Cobol,
    CoffeeScript,
    Cogent,
    ColdFusion,
    ColdFusionScript,
    Coq,
    Cpp,
    CppHeader,
    Crystal,
    Css,
    D,
    Dart,
    DeviceTree,
    Dhall,
    Dockerfile,
    DotNetResource,
    DreamMaker,
    Dust,
    Edn,
    Elisp,
    Elixir,
    Elm,
    Elvish,
    EmacsDevEnv,
    Emojicode,
    Erlang,
    FEN,
    FSharp,
    Fish,
    FlatBuffers,
    Forth,
    FortranLegacy,
    FortranModern,
    FreeMarker,
    Fstar,
    Futhark,
    GDB,
    GdScript,
    Gherkin,
    Glsl,
    Go,
    Gohtml,
    Graphql,
    Groovy,
    Hamlet,
    Handlebars,
    Happy,
    Haskell,
    Haxe,
    Hcl,
    Headache,
    Hex,
    Hlsl,
    HolyC,
    Html,
    Idris,
    Ini,
    IntelHex,
    Isabelle,
    Jai,
    Java,
    JavaScript,
    Json,
    Jsx,
    Julia,
    Julius,
    Jupyter,
    K,
    KakouneScript,
    Kotlin,
    LLVM,
    Lean,
    Less,
    LinkerScript,
    Liquid,
    Lisp,
    Logtalk,
    Lua,
    Lucius,
    Madlang,
    Makefile,
    Markdown,
    Meson,
    Mint,
    ModuleDef,
    MoonScript,
    MsBuild,
    Mustache,
    Nim,
    Nix,
    NotQuitePerl,
    OCaml,
    ObjectiveC,
    ObjectiveCpp,
    Odin,
    OpenType,
    Org,
    Oz,
    PSL,
    Pan,
    Pascal,
    Perl,
    Perl6,
    Pest,
    Php,
    Polly,
    Pony,
    PostCss,
    PowerShell,
    Processing,
    Prolog,
    Protobuf,
    PureScript,
    Python,
    Q,
    Qcl,
    Qml,
    R,
    RON,
    RPMSpecfile,
    Racket,
    Rakefile,
    Razor,
    ReStructuredText,
    Renpy,
    Ruby,
    RubyHtml,
    Rust,
    SRecode,
    Sass,
    Scala,
    Scheme,
    Scons,
    Sh,
    Sml,
    Solidity,
    SpecmanE,
    Spice,
    Sql,
    Stratego,
    Svelte,
    Svg,
    Swift,
    Swig,
    SystemVerilog,
    Tcl,
    Tex,
    Text,
    Thrift,
    Toml,
    Tsx,
    Twig,
    TypeScript,
    UnrealDeveloperMarkdown,
    UnrealPlugin,
    UnrealProject,
    UnrealScript,
    UnrealShader,
    UnrealShaderHeader,
    UrWeb,
    UrWebProject,
    VB6,
    VBScript,
    Vala,
    Velocity,
    Verilog,
    VerilogArgsFile,
    Vhdl,
    VimScript,
    VisualBasic,
    VisualStudioProject,
    VisualStudioSolution,
    Vue,
    WebAssembly,
    Wolfram,
    XSL,
    Xaml,
    XcodeConfig,
    Xml,
    Xtend,
    Yaml,
    Zig,
    Zsh,
}

Represents a individual programming language. Can be used to provide information about the language, such as multi line comments, single line comments, string literal syntax, whether a given language allows nesting comments.

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.

Abap

ActionScript

Ada

Agda

Alex

Alloy

Arduino

Asn1

Asp

AspNet

Assembly

AssemblyGAS

AutoHotKey

Autoconf

Automake

Bash

Batch

BrightScript

C

CHeader

CMake

CSharp

CShell

Cabal

Cassius

Ceylon

Clojure

ClojureC

ClojureScript

Cobol

CoffeeScript

Cogent

ColdFusion

ColdFusionScript

Coq

Cpp

CppHeader

Crystal

Css

D

Dart

DeviceTree

Dhall

Dockerfile

DotNetResource

DreamMaker

Dust

Edn

Elisp

Elixir

Elm

Elvish

EmacsDevEnv

Emojicode

Erlang

FEN

FSharp

Fish

FlatBuffers

Forth

FortranLegacy

FortranModern

FreeMarker

Fstar

Futhark

GDB

GdScript

Gherkin

Glsl

Go

Gohtml

Graphql

Groovy

Hamlet

Handlebars

Happy

Haskell

Haxe

Hcl

Headache

Hex

Hlsl

HolyC

Html

Idris

Ini

IntelHex

Isabelle

Jai

Java

JavaScript

Json

Jsx

Julia

Julius

Jupyter

K

KakouneScript

Kotlin

LLVM

Lean

Less

LinkerScript

Liquid

Lisp

Logtalk

Lua

Lucius

Madlang

Makefile

Markdown

Meson

Mint

ModuleDef

MoonScript

MsBuild

Mustache

Nim

Nix

NotQuitePerl

OCaml

ObjectiveC

ObjectiveCpp

Odin

OpenType

Org

Oz

PSL

Pan

Pascal

Perl

Perl6

Pest

Php

Polly

Pony

PostCss

PowerShell

Processing

Prolog

Protobuf

PureScript

Python

Q

Qcl

Qml

R

RON

RPMSpecfile

Racket

Rakefile

Razor

ReStructuredText

Renpy

Ruby

RubyHtml

Rust

SRecode

Sass

Scala

Scheme

Scons

Sh

Sml

Solidity

SpecmanE

Spice

Sql

Stratego

Svelte

Svg

Swift

Swig

SystemVerilog

Tcl

Tex

Text

Thrift

Toml

Tsx

Twig

TypeScript

UnrealDeveloperMarkdown

UnrealPlugin

UnrealProject

UnrealScript

UnrealShader

UnrealShaderHeader

UrWeb

UrWebProject

VB6

VBScript

Vala

Velocity

Verilog

VerilogArgsFile

Vhdl

VimScript

VisualBasic

VisualStudioProject

VisualStudioSolution

Vue

WebAssembly

Wolfram

XSL

Xaml

XcodeConfig

Xml

Xtend

Yaml

Zig

Zsh

Implementations

impl LanguageType

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

Returns the display name of a language.

let bash = LanguageType::Bash;

assert_eq!(bash.name(), "BASH");

pub fn is_literate(self) -> bool

Returns whether the language is "literate", meaning that it considered to primarily be documentation and is counted primarily as comments rather than procedural code.

pub fn list() -> &'static [Self]

Provides every variant in a Vec

pub fn line_comments(self) -> &'static [&'static str]

Returns the single line comments of a language.

use tokei::LanguageType;
let lang = LanguageType::Rust;
assert_eq!(lang.line_comments(), &["//"]);

pub fn multi_line_comments(self) -> &'static [(&'static str, &'static str)]

Returns the single line comments of a language.

use tokei::LanguageType;
let lang = LanguageType::Rust;
assert_eq!(lang.multi_line_comments(), &[("/*", "*/")]);

pub fn allows_nested(self) -> bool

Returns whether the language allows nested multi line comments.

use tokei::LanguageType;
let lang = LanguageType::Rust;
assert!(lang.allows_nested());

pub fn nested_comments(self) -> &'static [(&'static str, &'static str)]

Returns what nested comments the language has. (Currently only D has any of this type.)

use tokei::LanguageType;
let lang = LanguageType::D;
assert_eq!(lang.nested_comments(), &[("/+", "+/")]);

pub fn quotes(self) -> &'static [(&'static str, &'static str)]

Returns the quotes of a language.

use tokei::LanguageType;
let lang = LanguageType::C;
assert_eq!(lang.quotes(), &[("\"", "\"")]);

pub fn verbatim_quotes(self) -> &'static [(&'static str, &'static str)]

Returns the verbatim quotes of a language.

use tokei::LanguageType;
let lang = LanguageType::CSharp;
assert_eq!(lang.verbatim_quotes(), &[("@\"", "\"")]);

pub fn doc_quotes(self) -> &'static [(&'static str, &'static str)]

Returns the doc quotes of a language.

use tokei::LanguageType;
let lang = LanguageType::Python;
assert_eq!(lang.doc_quotes(), &[("\"\"\"", "\"\"\""), ("'''", "'''")]);

pub fn shebangs(self) -> &'static [&'static str]

Returns the shebang of a language.

use tokei::LanguageType;
let lang = LanguageType::Bash;
assert_eq!(lang.shebangs(), &["#!/bin/bash"]);

pub fn important_syntax(self) -> &'static [&'static str]

Returns the parts of syntax that determines whether tokei can skip large parts of analysis.

pub fn from_path<P: AsRef<Path>>(entry: P, _config: &Config) -> Option<Self>

Get language from a file path. May open and read the file.

use tokei::{Config, LanguageType};

let rust = LanguageType::from_path("./main.rs", &Config::default());

assert_eq!(rust, Some(LanguageType::Rust));

pub fn from_file_extension(extension: &str) -> Option<Self>

Get language from a file extension.

use tokei::LanguageType;

let rust = LanguageType::from_file_extension("rs");

assert_eq!(rust, Some(LanguageType::Rust));

pub fn from_mime(mime: &str) -> Option<Self>

Get language from its MIME type if available.

use tokei::LanguageType;

let lang = LanguageType::from_mime("application/javascript");

assert_eq!(lang, Some(LanguageType::JavaScript));

pub fn from_shebang<P: AsRef<Path>>(entry: P) -> Option<Self>

Get language from a shebang. May open and read the file.

use tokei::LanguageType;

let rust = LanguageType::from_shebang("./main.rs");

assert_eq!(rust, Some(LanguageType::Rust));

impl LanguageType

pub fn parse(
    self,
    path: PathBuf,
    config: &Config
) -> Result<Report, (Error, PathBuf)>

Parses a given Path using the LanguageType. Returning Report on success and giving back ownership of PathBuf on error.

pub fn parse_from_str<A: AsRef<str>>(
    self,
    text: A,
    config: &Config
) -> CodeStats

Parses the text provided as the given LanguageType.

pub fn parse_from_slice<A: AsRef<[u8]>>(
    self,
    text: A,
    config: &Config
) -> CodeStats

Parses the bytes provided as the given LanguageType.

Trait Implementations

impl Clone for LanguageType

fn clone(&self) -> LanguageType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for LanguageType

impl Debug for LanguageType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LanguageType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for LanguageType

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

Formats the value using the given formatter.

impl Eq for LanguageType

impl<'a> From<&'a LanguageType> for Cow<'a, LanguageType>

fn from(from: &'a LanguageType) -> Self

Performs the conversion.

impl<'a> From<LanguageType> for Cow<'a, LanguageType>

fn from(from: LanguageType) -> Self

Performs the conversion.

impl FromStr for LanguageType

type Err = &'static str

The associated error which can be returned from parsing.

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

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

impl Hash for LanguageType

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, 

Feeds a slice of this type into the given [Hasher].

impl Ord for LanguageType

fn cmp(&self, other: &LanguageType) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<LanguageType> for LanguageType

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<LanguageType> for LanguageType

fn partial_cmp(&self, other: &LanguageType) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for LanguageType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for LanguageType

impl StructuralPartialEq for LanguageType