finitio 0.1.0

Finitio data 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

use std::cell::RefCell;
use std::rc::Rc;

use super::any::Any;
use super::builtin::Builtin;
use super::nil::Nil;
use super::r#ref::Ref;
use super::r#struct::Struct;
use super::relation::Relation;
use super::seq::Seq;
use super::set::Set;
use super::sub::Sub;
use super::tuple::Tuple;
use super::union::Union;
use super::{errors::ValidationError, typemap::TypeMap};

#[derive(Clone, Debug)]
pub enum TypeDef {
    AnyType(TypeDefStr<Any>),
    NilType(TypeDefStr<Nil>),
    BuiltinType(TypeDefStr<Builtin>),
    RefType(TypeDefStr<Ref>),
    SeqType(TypeDefStr<Seq>),
    SetType(TypeDefStr<Set>),
    UnionType(TypeDefStr<Union>),
    StructType(TypeDefStr<Struct>),
    SubType(TypeDefStr<Sub>),
    TupleType(TypeDefStr<Tuple>),
    RelationType(TypeDefStr<Relation>),
}

#[derive(Clone, Debug)]
pub struct TypeDefStr<T> {
    pub name: String,
    pub target: Rc<RefCell<T>>,
}

impl TypeDef {
    pub fn name(&self) -> String {
        match self {
            TypeDef::AnyType(t) => t.name.clone(),
            TypeDef::NilType(t) => t.name.clone(),
            TypeDef::BuiltinType(t) => t.name.clone(),
            TypeDef::RefType(t) => t.name.clone(),
            TypeDef::SeqType(t) => t.name.clone(),
            TypeDef::SetType(t) => t.name.clone(),
            TypeDef::UnionType(t) => t.name.clone(),
            TypeDef::StructType(t) => t.name.clone(),
            TypeDef::SubType(t) => t.name.clone(),
            TypeDef::TupleType(t) => t.name.clone(),
            TypeDef::RelationType(t) => t.name.clone(),
        }
    }

    pub(crate) fn resolve(&mut self, type_map: &TypeMap) -> Result<(), ValidationError> {
        match self {
            TypeDef::AnyType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::NilType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::BuiltinType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::RefType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::SeqType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::SetType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::UnionType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::StructType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::SubType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::TupleType(t) => t.target.borrow_mut().resolve(type_map),
            TypeDef::RelationType(t) => t.target.borrow_mut().resolve(type_map),
        }
    }
}