prune-lang 0.2.3

Prune is a constraint logic programming language with branching heuristic.
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

use super::intern::InternStr;
use std::fmt;
use std::sync::atomic;

// counter zero is reserved for dummy ident
static COUNTER: atomic::AtomicUsize = atomic::AtomicUsize::new(1);

#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct Ident {
    pub name: InternStr,
    pub index: usize,
}

impl Ident {
    pub fn fresh<S: AsRef<str>>(s: &S) -> Ident {
        let name = InternStr::new(s.as_ref());
        let index = COUNTER.fetch_add(1, atomic::Ordering::Relaxed);
        Ident { name, index }
    }

    pub fn dummy<S: AsRef<str>>(s: &S) -> Ident {
        let name = InternStr::new(s.as_ref());
        Ident { name, index: 0 }
    }

    pub fn is_dummy(&self) -> bool {
        self.index == 0
    }

    pub fn uniquify(&self) -> Ident {
        let name = self.name;
        let index = COUNTER.fetch_add(1, atomic::Ordering::Relaxed);
        Ident { name, index }
    }

    pub fn as_str(&self) -> &'static str {
        self.name.as_str()
    }

    pub fn tag_ctx(self, ctx: usize) -> IdentCtx {
        IdentCtx { ident: self, ctx }
    }
}

impl fmt::Debug for Ident {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        if self.is_dummy() {
            write!(f, "{:?}", self.name)
        } else {
            write!(f, "{:?}_{:?}", self.name, self.index)
        }
    }
}

impl fmt::Display for Ident {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}

impl AsRef<str> for Ident {
    fn as_ref(&self) -> &str {
        self.name.as_str()
    }
}

#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct IdentCtx {
    pub ident: Ident,
    pub ctx: usize,
}

impl fmt::Debug for IdentCtx {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:?}_{:?}", self.ident, self.ctx)
    }
}

impl fmt::Display for IdentCtx {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}_{}", self.ident, self.ctx)
    }
}

#[test]
fn ident_fresh_test() {
    let s1 = InternStr::new("foo");
    let x1 = Ident::fresh(&s1);
    let x2 = Ident::fresh(&s1);
    let x3 = Ident::fresh(&s1);
    assert_ne!(x1, x2);
    assert_ne!(x1, x3);
    assert_ne!(x2, x3);
    assert_eq!(x1.name, x2.name);
    assert_eq!(x1.name, x3.name);
    assert_eq!(x2.name, x3.name);
}

#[test]
fn ident_uniquify_test() {
    let s1 = InternStr::new("foo");
    let x1 = Ident::fresh(&s1);
    let x2 = x1.uniquify();
    assert_ne!(x1, x2);
    assert_eq!(x1.name, x2.name);
}