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

use crate::{value::Value, Error};
use core::fmt::{self, Display, Formatter};

pub const FALSE: Cons = Cons::dummy(0);
pub const TRUE: Cons = Cons::dummy(1);
pub const NULL: Cons = Cons::dummy(2);
pub const MOVED: Cons = Cons::dummy(3);

const TAG_MASK: u64 = 0b1111;
const TAG_SIZE: usize = TAG_MASK.count_ones() as usize;

#[derive(Clone, Copy, Debug)]
pub struct Cons(u64);

impl Cons {
    pub const fn new(index: u64) -> Self {
        Self(index << (TAG_SIZE + 1))
    }

    pub(crate) const fn dummy(index: u64) -> Self {
        Self::new(u64::MAX - index)
    }

    pub const fn index(self) -> usize {
        (self.0 >> (TAG_SIZE + 1)) as usize
    }

    pub const fn tag(self) -> u8 {
        ((self.0 >> 1) & TAG_MASK) as u8
    }

    pub const fn set_tag(self, tag: u8) -> Self {
        Self(((self.0 >> 1) & !TAG_MASK | (tag as u64 & TAG_MASK)) << 1)
    }

    pub(crate) const fn from_raw(raw: u64) -> Self {
        Self(raw)
    }

    pub(crate) const fn to_raw(self) -> u64 {
        self.0
    }

    pub(crate) const fn is_singleton(self) -> bool {
        self.index() > MOVED.index()
    }
}

impl PartialEq for Cons {
    fn eq(&self, other: &Self) -> bool {
        self.index() == other.index()
    }
}

impl Eq for Cons {}

impl TryFrom<Value> for Cons {
    type Error = Error;

    fn try_from(value: Value) -> Result<Self, Self::Error> {
        value.to_cons().ok_or(Error::ConsExpected)
    }
}

impl Display for Cons {
    fn fmt(&self, formatter: &mut Formatter) -> fmt::Result {
        if self == &FALSE {
            write!(formatter, "#f")?;
        } else if self == &TRUE {
            write!(formatter, "#t")?;
        } else if self == &NULL {
            write!(formatter, "()")?;
        } else if self == &MOVED {
            write!(formatter, "moved")?;
        } else {
            write!(formatter, "c{:x}", self.index())?;
        }

        write!(formatter, ":{}", self.tag())
    }
}

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

    #[test]
    fn tag() {
        let cons = Cons::new(42);

        assert_eq!(cons.index(), 42);
        assert_eq!(cons.tag(), 0);

        let cons = cons.set_tag(1);

        assert_eq!(cons.index(), 42);
        assert_eq!(cons.tag(), 1);

        let cons = cons.set_tag(3);

        assert_eq!(cons.index(), 42);
        assert_eq!(cons.tag(), 3);
    }

    #[test]
    fn reset_tag() {
        assert_eq!(Cons::new(42).set_tag(2).set_tag(1).tag(), 1);
    }

    #[test]
    fn set_too_large_tag() {
        let cons = Cons::new(0).set_tag(u8::MAX);

        assert_eq!(cons.index(), 0);
        assert_eq!(cons.tag(), TAG_MASK as u8);
    }

    #[test]
    fn is_singleton() {
        assert!(!Cons::new(0).is_singleton());
        assert!(!Cons::new(42).is_singleton());
        assert!(FALSE.is_singleton());
        assert!(TRUE.is_singleton());
        assert!(NULL.is_singleton());
        assert!(!MOVED.is_singleton());
    }
}