MathStuff/typeexpr.rb at master · jedediah/MathStuff · GitHub

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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

module TypeExpression
    module Operations
        def ~
            Negation.new(self)
        end

        def &(x)
            Intersection.new(self, x)
        end

        def |(x)
            Union.new(self, x)
        end
    end

    class Base
        include Operations
    end

    class Empty < Base
        def self.new
            @instance ||= super
        end

        def inspect
            '{}'
        end

        def ===(x)
            false
        end

        def potential_modules
            Set.empty
        end
    end

    class Negation < Base
        attr :type

        class << self
            def new(type)
                if type.is_a? Empty
                    Object
                elsif type == Object
                    Empty.new
                elsif type.is_a? Negation
                    type.type
                else
                    super
                end
            end
        end

        def initialize(type)
            @type = type
        end

        def potential_modules
            Object
        end
    end

    class Aggregate < Base
        attr :types

        def initialize(types)
            @types = types.freeze
        end
    end

    class Intersection < Aggregate
        class << self
            def new(*args)
                types = Set[]
                args.each do |arg|
                    if arg.is_a? Intersection
                        types |= arg.types
                    elsif arg.is_a? Empty
                        return Empty.new
                    elsif types.none?{|t| t < arg }
                        types.delete_if{|t| arg < t }
                        types << arg
                    end
                end

                case types.size
                    when 0
                        Object
                    when 1
                        types.first
                    else
                        super(types)
                end
            end
        end

        def inspect
            @types.map(&:inspect).join(' & ')
        end

        def ===(x)
            @types.all? do |t|
                t === x
            end
        end

        def potential_modules
            @types
        end
    end

    class Union < Aggregate
        class << self
            def new(*args)
                types = Set[]
                args.each do |arg|
                    if arg.is_a? Intersection
                        types |= arg.types
                    elsif arg == Object
                        return Object
                    elsif !arg.is_a?(Empty) && types.none?{|t| arg < t }
                        types.delete_if{|t| t < arg }
                        types << arg
                    end
                end

                case types.size
                    when 0
                        Empty.new
                    when 1
                        types.first
                    else
                        super(types)
                end
            end
        end

        def inspect
            @types.map(&:inspect).join(' | ')
        end

        def ===(x)
            @types.any? do |t|
                t === x
            end
        end

        def potential_modules
            @types
        end
    end
end

class Module
    includ TypeExpression::Operations

    def potential_modules
        Set[self]
    end
end