hamelin_lib 0.21.7

Core library for Hamelin query language
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

use std::sync::Arc;

use crate::tree::ast::expression::{Expression, Lambda, LambdaParameter};
use crate::tree::ast::node::Span;
use crate::types::Type;

use super::{ExpressionBuilder, IntoExpressionBuilder};

/// Builder for lambda expressions (before body is set)
#[derive(Debug)]
pub struct LambdaBuilder {
    parameters: Vec<LambdaParameter>,
}

impl LambdaBuilder {
    pub fn new() -> Self {
        Self {
            parameters: Vec::new(),
        }
    }

    /// Add a parameter without a type hint
    pub fn param(mut self, name: impl Into<String>) -> Self {
        self.parameters.push(LambdaParameter::new(name));
        self
    }

    /// Add a parameter with a type hint
    pub fn param_with_type(mut self, name: impl Into<String>, typ: Arc<Type>) -> Self {
        self.parameters.push(LambdaParameter::with_type(name, typ));
        self
    }

    /// Set the lambda body (transitions to WithBody state)
    pub fn body(self, body: impl IntoExpressionBuilder) -> LambdaBuilderWithBody {
        LambdaBuilderWithBody {
            parameters: self.parameters,
            body: body.into_expression_builder(),
        }
    }
}

impl Default for LambdaBuilder {
    fn default() -> Self {
        Self::new()
    }
}

/// Builder for lambda expressions (after body is set)
#[derive(Debug)]
pub struct LambdaBuilderWithBody {
    parameters: Vec<LambdaParameter>,
    body: Box<dyn ExpressionBuilder>,
}

impl LambdaBuilderWithBody {
    /// Add a parameter without a type hint
    pub fn param(mut self, name: impl Into<String>) -> Self {
        self.parameters.push(LambdaParameter::new(name));
        self
    }

    /// Add a parameter with a type hint
    pub fn param_with_type(mut self, name: impl Into<String>, typ: Arc<Type>) -> Self {
        self.parameters.push(LambdaParameter::with_type(name, typ));
        self
    }

    /// Replace the lambda body
    pub fn body(mut self, body: impl IntoExpressionBuilder) -> Self {
        self.body = body.into_expression_builder();
        self
    }
}

impl ExpressionBuilder for LambdaBuilderWithBody {
    fn build(&self) -> Expression {
        let body = Arc::new(self.body.build());

        Expression {
            span: Span::NONE,
            kind: Lambda {
                parameters: self.parameters.clone(),
                body,
            }
            .into(),
        }
    }
}

impl IntoExpressionBuilder for LambdaBuilderWithBody {
    fn into_expression_builder(self) -> Box<dyn ExpressionBuilder> {
        Box::new(self)
    }
}

/// Create a lambda builder
pub fn lambda() -> LambdaBuilder {
    LambdaBuilder::new()
}

/// Create a single-parameter lambda (convenience)
pub fn lambda1(param: impl Into<String>) -> LambdaBuilder {
    LambdaBuilder::new().param(param)
}

/// Create a two-parameter lambda (convenience)
pub fn lambda2(param1: impl Into<String>, param2: impl Into<String>) -> LambdaBuilder {
    LambdaBuilder::new().param(param1).param(param2)
}