erg_compiler 0.6.53

Centimetre: the Erg compiler
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

from abc import ABC, abstractmethod

from _erg_float import Float

class Eq(ABC):
    @abstractmethod
    def __eq__(self, other): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Eq:
            if any("__eq__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Ord(ABC):
    @abstractmethod
    def __lt__(self, other): pass
    def __gt__(self, other): pass
    def __le__(self, other): pass
    def __ge__(self, other): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Ord:
            # TODO: adhoc
            if C == float or C == Float:
                return False
            if any("__lt__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Hash(ABC):
    @abstractmethod
    def __hash__(self): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Hash:
            if any("__hash__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Sized(ABC):
    @abstractmethod
    def __len__(self): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sized:
            if any("__len__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Add(ABC):
    Output: type

    @abstractmethod
    def __add__(self, other): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Add:
            if any("__add__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Sub(ABC):
    Output: type

    @abstractmethod
    def __sub__(self, other): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Sub:
            if any("__sub__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Mul(ABC):
    Output: type

    @abstractmethod
    def __mul__(self, other): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Mul:
            if any("__mul__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Div(ABC):
    Output: type

    @abstractmethod
    def __truediv__(self, other): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Div:
            if any("__truediv__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Pos(ABC):
    Output: type

    @abstractmethod
    def __pos__(self): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Pos:
            if any("__pos__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Neg(ABC):
    Output: type

    @abstractmethod
    def __neg__(self): pass

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Neg:
            if any("__neg__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented