oak-fsharp 0.0.11

High-performance incremental F# (F Sharp) parser for the oak ecosystem with flexible configuration, supporting functional programming and .NET ecosystem integration.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

#![doc = include_str!("readme.md")]
use oak_core::{Language, LanguageCategory};

/// F# language implementation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct FSharpLanguage {
    /// Whether to enable F# 4.0 features.
    pub fsharp_4_0: bool,
    /// Whether to enable F# 4.1 features.
    pub fsharp_4_1: bool,
    /// Whether to enable F# 4.5 features.
    pub fsharp_4_5: bool,
    /// Whether to enable F# 5.0 features.
    pub fsharp_5_0: bool,
    /// Whether to enable F# 6.0 features.
    pub fsharp_6_0: bool,
    /// Whether to enable F# 7.0 features.
    pub fsharp_7_0: bool,
    /// Whether to enable computation expressions.
    pub computation_expressions: bool,
    /// Whether to enable type providers.
    pub type_providers: bool,
    /// Whether to enable async workflows.
    pub async_workflows: bool,
    /// Whether to enable query expressions.
    pub query_expressions: bool,
}

impl Default for FSharpLanguage {
    fn default() -> Self {
        Self { fsharp_4_0: true, fsharp_4_1: true, fsharp_4_5: true, fsharp_5_0: true, fsharp_6_0: true, fsharp_7_0: true, computation_expressions: true, type_providers: true, async_workflows: true, query_expressions: true }
    }
}

impl FSharpLanguage {
    /// Creates a new F# language configuration.
    pub fn new() -> Self {
        Self::default()
    }

    /// Enables all F# features.
    pub fn with_all_features(mut self) -> Self {
        self.fsharp_4_0 = true;
        self.fsharp_4_1 = true;
        self.fsharp_4_5 = true;
        self.fsharp_5_0 = true;
        self.fsharp_6_0 = true;
        self.fsharp_7_0 = true;
        self.computation_expressions = true;
        self.type_providers = true;
        self.async_workflows = true;
        self.query_expressions = true;
        self
    }

    /// Sets the F# version.
    pub fn with_version(mut self, major: u8, minor: u8) -> Self {
        match (major, minor) {
            (4, 0) => self.fsharp_4_0 = true,
            (4, 1) => {
                self.fsharp_4_0 = true;
                self.fsharp_4_1 = true
            }
            (4, 5) => {
                self.fsharp_4_0 = true;
                self.fsharp_4_1 = true;
                self.fsharp_4_5 = true
            }
            (5, 0) => {
                self.fsharp_4_0 = true;
                self.fsharp_4_1 = true;
                self.fsharp_4_5 = true;
                self.fsharp_5_0 = true
            }
            (6, 0) => {
                self.fsharp_4_0 = true;
                self.fsharp_4_1 = true;
                self.fsharp_4_5 = true;
                self.fsharp_5_0 = true;
                self.fsharp_6_0 = true
            }
            (7, 0) => {
                self.fsharp_4_0 = true;
                self.fsharp_4_1 = true;
                self.fsharp_4_5 = true;
                self.fsharp_5_0 = true;
                self.fsharp_6_0 = true;
                self.fsharp_7_0 = true
            }
            _ => {}
        }
        self
    }

    /// Enables or disables computation expressions.
    pub fn with_computation_expressions(mut self, enabled: bool) -> Self {
        self.computation_expressions = enabled;
        self
    }

    /// Enables or disables type providers.
    pub fn with_type_providers(mut self, enabled: bool) -> Self {
        self.type_providers = enabled;
        self
    }

    /// Enables or disables async workflows.
    pub fn with_async_workflows(mut self, enabled: bool) -> Self {
        self.async_workflows = enabled;
        self
    }

    /// Enables or disables query expressions.
    pub fn with_query_expressions(mut self, enabled: bool) -> Self {
        self.query_expressions = enabled;
        self
    }
}

impl Language for FSharpLanguage {
    const NAME: &'static str = "fsharp";
    const CATEGORY: LanguageCategory = LanguageCategory::Programming;

    type TokenType = crate::lexer::token_type::FSharpTokenType;
    type ElementType = crate::parser::element_type::FSharpElementType;
    type TypedRoot = crate::ast::FSharpRoot;
}