vortex-array 0.84.0

Vortex in memory columnar data format
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

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use crate::dtype::DType;

/// The context an [`Expression`](crate::expr::Expression) is bound against.
///
/// Today a scope is just the dtype that [`root`](crate::expr::root) resolves to. It is an opaque
/// struct rather than a bare [`DType`] so that lexical bindings can be added later without changing
/// [`Expression::bind_scope`](crate::expr::Expression::bind_scope)'s signature.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Scope {
    root: DType,
}

impl Scope {
    /// Create a scope in which `root` resolves to the given dtype.
    pub fn new(root: DType) -> Self {
        Self { root }
    }

    /// The dtype that `root` resolves to.
    pub fn root(&self) -> &DType {
        &self.root
    }
}

impl From<DType> for Scope {
    fn from(root: DType) -> Self {
        Self::new(root)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::dtype::Nullability;

    #[test]
    fn root_round_trips() {
        let dtype = DType::Bool(Nullability::Nullable);
        assert_eq!(Scope::new(dtype.clone()).root(), &dtype);
        assert_eq!(Scope::from(dtype.clone()).root(), &dtype);
    }
}