euph 0.3.1

A functional stack-based programming language
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
129
130

use dashu_int::IBig;
use derive_more::{
    Debug,
    Display,
    IsVariant,
};
use ecow::EcoVec;
use hipstr::LocalHipStr;
use itertools::Itertools;
use num_traits::Signed;
use ordered_float::OrderedFloat;

use crate::{
    fns::bind,
    types::EuType,
};

#[derive(Debug, Display, Hash, Clone, IsVariant, PartialEq, Eq, PartialOrd, Ord)]
pub enum EuBind<'eu> {
    #[debug("{_0}")]
    Word(LocalHipStr<'eu>),
    #[debug("${_0}({})", _1.iter().map(|t| format!("{t:?}")).join(" "))]
    #[display("{}", _1.iter().join(" "))]
    Tag(LocalHipStr<'eu>, EcoVec<Self>),
    #[debug("({})", _0.iter().map(|t| format!("{t:?}")).join(" "))]
    #[display("{}", _0.iter().join(" "))]
    Union(EcoVec<Self>),
    #[debug("({_0:?}\\{_1:?})")]
    #[display("{_0}{_1}")]
    Bind(Box<Self>, Box<Self>),

    #[debug("{}", if *_0 { "True" } else { "False" })]
    Bool(bool),
    #[debug("{_0:?}i32")]
    I32(i32),
    #[debug("{_0:?}i64")]
    I64(i64),
    #[debug("{_0:?}")]
    IBig(IBig),
    #[debug("{}", if _0.is_infinite() { format!("{}Inf32", if _0.is_negative() {"-"} else {""}) } else { format!("{_0:?}") })]
    F64(OrderedFloat<f64>),
    #[debug("{_0:?}")]
    Char(char),

    #[debug("{_0:?}")]
    Str(LocalHipStr<'eu>),

    #[debug("\\[{}]", _0.iter().map(|t| format!("{t:?}")).join(" "))]
    #[display("{}", _0.iter().join(" "))]
    Vecz(EcoVec<Self>),

    #[debug("{{{}}}", _0.iter().map(|t| format!("{t:?}")).join(" "))]
    #[display("{}", _0.iter().join(" "))]
    Map(EcoVec<Self>),
}

impl<'eu> EuBind<'eu> {
    #[inline]
    pub fn word(s: impl Into<LocalHipStr<'eu>>) -> Self {
        Self::Word(s.into())
    }

    #[inline]
    pub fn tag(w: impl Into<LocalHipStr<'eu>>, bs: impl Into<EcoVec<Self>>) -> Self {
        Self::Tag(w.into(), bs.into())
    }

    #[inline]
    pub fn union(bs: impl Into<EcoVec<Self>>) -> Self {
        Self::Union(bs.into())
    }

    #[inline]
    pub fn bind(b0: impl Into<Self>, b1: impl Into<Self>) -> Self {
        Self::Bind(Box::new(b0.into()), Box::new(b1.into()))
    }

    #[inline]
    pub fn i32(n: impl Into<i32>) -> Self {
        Self::I32(n.into())
    }

    #[inline]
    pub fn i64(n: impl Into<i64>) -> Self {
        Self::I64(n.into())
    }

    #[inline]
    pub fn ibig(n: impl Into<IBig>) -> Self {
        Self::IBig(n.into())
    }

    #[inline]
    pub fn f64(n: impl Into<OrderedFloat<f64>>) -> Self {
        Self::F64(n.into())
    }

    #[inline]
    pub fn str(s: impl Into<LocalHipStr<'eu>>) -> Self {
        Self::Str(s.into())
    }

    #[inline]
    pub fn vecz(bs: impl Into<EcoVec<Self>>) -> Self {
        Self::Vecz(bs.into())
    }

    #[inline]
    pub fn map(bs: impl Into<EcoVec<Self>>) -> Self {
        Self::Map(bs.into())
    }

    #[must_use]
    pub fn to_free(self) -> Option<EuType<'eu>> {
        match self {
            EuBind::Bind(b0, b1) => b0.to_free().or_else(|| b1.to_free()),
            EuBind::Tag(w, bs) => (bind::BIND.get(&w)?.free)(bs),
            EuBind::Bool(b) => Some(EuType::Bool(b)),
            EuBind::I32(n) => Some(EuType::I32(n)),
            EuBind::I64(n) => Some(EuType::I64(n)),
            EuBind::IBig(n) => Some(EuType::IBig(n)),
            EuBind::F64(n) => Some(EuType::F64(n)),
            EuBind::Char(c) => Some(EuType::Char(c)),
            EuBind::Str(s) => Some(EuType::Str(s)),
            EuBind::Vecz(bs) => (bind::VECZ.free)(bs),
            EuBind::Map(bs) => (bind::MAP.free)(bs),
            _ => None,
        }
    }
}