Enum Language 

pub enum Language {
    Go,
    Java,
    Kotlin,
    Python,
    Ruby,
    Rust,
}

A programming language supported by pelicode.

Variants

Go

Go (.go).

Java

Java (.java).

Kotlin

Kotlin (.kt, .kts).

Python

Python (.py).

Ruby

Ruby (.rb).

Rust

Rust (.rs).

Implementations

impl Language

pub const ALL: [Language; 6]

Every supported language.

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

Lower-case name of the language, as used in databases and reports.

Examples

use pelicode_core::Language;

assert_eq!(Language::Kotlin.name(), "kotlin");
assert_eq!("kotlin".parse::<Language>(), Ok(Language::Kotlin));

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

File extensions of the language, without the leading dot.

Examples

use pelicode_core::Language;

assert_eq!(Language::Kotlin.extensions(), ["kt", "kts"]);

pub fn from_extension(ext: &str) -> Option<Language>

The language of a file extension (without the dot); None when unsupported.

Examples

use pelicode_core::Language;

assert_eq!(Language::from_extension("rs"), Some(Language::Rust));
assert_eq!(Language::from_extension("c"), None);

pub fn from_path(path: &Path) -> Option<Language>

The language of a file, from its extension; None when unsupported.

Examples

use std::path::Path;
use pelicode_core::Language;

assert_eq!(Language::from_path(Path::new("src/Main.java")), Some(Language::Java));
assert_eq!(Language::from_path(Path::new("README.md")), None);

pub fn ts_language(self) -> Language

The Tree-sitter grammar of the language.

Examples

use pelicode_core::Language;

let mut parser = tree_sitter::Parser::new();
parser.set_language(&Language::Go.ts_language()).unwrap();
let tree = parser.parse("package main", None).unwrap();
assert_eq!(tree.root_node().kind(), "source_file");

Trait Implementations

impl Clone for Language

fn clone(&self) -> Self

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<'de> Deserialize<'de> for Language

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Language

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

Formats the value using the given formatter.

impl Eq for Language

impl FromStr for Language

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &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 Ord for Language

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for Language

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Language

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for Language

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Language