MathStuff/typeset.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
require 'set'
require_relative 'ext'

class TypeSet
    include Enumerable

    attr :types

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

            case types.size
                when 0
                    @empty ||= super(types)
                when 1
                    types.first
                else
                    super(types)
            end
        end

        forward :[], :new
    end

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

    def each(&block)
        types.each(&block)
    end
    enum_method :each

    def inspect
        if types.empty?
            '{}'
        else
            types.map(&:inspect).join(' | ')
        end
    end
    forward :to_s, :inspect

    def ==(m)
        (m.is_a?(Module) || m.is_a?(TypeSet)) && types == m.types
    end
    forward :eql?, :==

    def ===(x)
        types.any?{|t| t === x }
    end

    def <(m)
        types.any?{|t| m.types.any?{|u| t < u }}
    end

    def <=(m)
        types.any?{|t| m.types.any?{|u| t <= u }}
    end

    def >(m)
        types.any?{|t| m.types.any?{|u| t > u }}
    end

    def >=(m)
        types.any?{|t| m.types.any?{|u| t >= u }}
    end

    def |(s)
        self.class.new(self, s)
    end

    module ModuleExt
        def types
            Set[self].freeze
        end

        def |(m)
            TypeSet[self, m]
        end

        def <(m)
            if m.is_a? TypeSet
                m > self
            else
                super
            end
        end

        def <=(m)
            if m.is_a? TypeSet
                m >= self
            else
                super
            end
        end

        def >(m)
            if m.is_a? TypeSet
                m < self
            else
                super
            end
        end

        def >=(m)
            if m.is_a? TypeSet
                m <= self
            else
                super
            end
        end
    end

    Module.prepend(ModuleExt)
end