rdl 1.0.0.rc1

data/lib/rdl/types/singleton.rb

@@ -0,0 +1,62 @@
+require_relative 'type'
+
+module RDL::Type
+  class SingletonType < Type
+    attr_reader :val
+
+    @@cache = {}
+    @@cache.compare_by_identity
+    
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(val)
+      t = @@cache[val]
+      return t if t
+      t = self.__new__ val
+      return (@@cache[val] = t) # assignment evaluates to t
+    end
+
+    def initialize(val)
+      @val = val
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      return (other.instance_of? self.class) && (other.val.equal? @val)
+    end
+
+    def hash # :nodoc:
+      return @val.hash
+    end
+
+    def to_s
+      if @val.instance_of? Symbol
+        ":{@val}"
+      else
+        "Singleton(#{@val.to_s})"
+      end
+    end
+
+    def <=(other)
+      other.instance_of?(TopType) ||
+        (other.instance_of?(SingletonType) && other.val == @val) ||
+        (other.instance_of?(NominalType) && @val.class == other.klass) ||
+        (other.instance_of?(NominalType) && @val.is_a?(other.klass))
+    end
+
+    def member?(obj, *args)
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      obj.nil? || obj.equal?(@val)
+    end
+    
+    def instantiate(inst)
+      return self
+    end
+  end
+end

data/lib/rdl/types/structural.rb

@@ -0,0 +1,72 @@
+require_relative 'type'
+
+module RDL::Type
+  class StructuralType < Type
+    attr_reader :methods
+
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(methods)
+      t = @@cache[methods]
+      return t if t
+      t = StructuralType.__new__(methods)
+      return (@@cache[methods] = t) # assignment evaluates to t
+    end
+
+    # Create a new StructuralType.
+    #
+    # [+methods+] Map from method names as symbols to their types.
+    def initialize(methods)
+      raise "methods can't be empty" if methods.empty?
+      methods.each { |m, t|
+        raise RuntimeError, "Method names in StructuralType must be symbols" unless m.instance_of? Symbol
+        raise RuntimeError, "Got #{t.class} where MethodType expected" unless t.instance_of? MethodType
+        # Note intersection types not allowed as subtyping would be tricky
+      }
+      @methods = methods
+      super()
+    end
+
+    def to_s  # :nodoc:
+      "[ " + @methods.each_pair.map { |m, t| "#{m.to_s}: #{t.to_s}" }.sort.join(", ") + " ]"
+    end
+
+    def <=(other)
+      return true if other.instance_of? TopType
+      # in theory a StructuralType could contain all the methods of a NominalType or GenericType,
+      # but it seems unlikely in practice, so disallow this case.
+      return RuntimeError, "Structural subtype can't be subtype of #{other.class}" unless other.instance_of? StructuralType
+      # allow width subtyping
+      other.methods.each_pair { |m, t|
+        return false unless @methods.has_key?(m) && @methods[m] <= t
+      }
+      return true
+    end
+
+    def member?(obj, *args)
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      return NominalType.new(obj.class) <= self
+    end
+    
+    def instantiate(inst)
+      StructuralType.new(Hash[*@methods.each_pair.map { |m, t| [m, t.instantiate(inst)] }.flatten])
+    end
+    
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)  # :nodoc:
+      return (other.instance_of? StructuralType) && (other.methods == @methods)
+    end
+
+    def hash  # :nodoc:
+      @methods.hash
+    end
+  end
+end

data/lib/rdl/types/top.rb

@@ -0,0 +1,50 @@
+require_relative 'type'
+
+module RDL::Type
+  class TopType < Type
+    @@cache = nil
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new
+      @@cache = TopType.__new__ unless @@cache
+      return @@cache
+    end
+
+    def initialize
+      super
+    end
+
+    def to_s
+      "%any"
+    end
+
+    def eql?(other)
+      self == other
+    end
+      
+    def ==(other)
+      other.instance_of? TopType
+    end
+
+    def <=(other)
+      other.instance_of? TopType
+    end
+
+    def member?(obj, *args)
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      true
+    end
+    
+    def instantiate(inst)
+      return self
+    end
+    
+    def hash
+      17
+    end
+  end
+end

data/lib/rdl/types/tuple.rb

@@ -0,0 +1,61 @@
+require_relative 'type'
+
+module RDL::Type
+  # A specialized GenericType for tuples, i.e., fixed-sized arrays
+  class TupleType < Type
+    attr_reader :params
+
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(*params)
+      t = @@cache[params]
+      return t if t
+      raise RuntimeError, "Attempt to create generic type with non-type param" unless params.all? { |p| p.is_a? Type }
+      t = TupleType.__new__(params)
+      return (@@cache[params] = t) # assignment evaluates to t
+    end
+
+    def initialize(params)
+      @params = params
+      super()
+    end
+
+    def to_s
+      "[#{@params.map { |t| t.to_s }.join(', ')}]"
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other) # :nodoc:
+      return (other.instance_of? TupleType) && (other.params == @params)
+    end
+
+    def <=(other)
+      return true if other.instance_of? TopType
+      return self == other
+      # Subtyping with Array not allowed
+      # All positions of Tuple are invariant since tuples are mutable
+    end
+    
+    def member?(obj, *args)
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      return false unless obj.instance_of?(Array) && obj.size == @params.size
+      return @params.zip(obj).all? { |formal, actual| formal.member?(actual, *args) }
+    end
+
+    def instantiate(inst)
+      TupleType.new(*@params.map { |t| t.instantiate(inst) })
+    end
+    
+    def hash
+      h = 73 * @params.hash
+    end
+  end
+end

data/lib/rdl/types/type.rb

@@ -0,0 +1,24 @@
+module RDL::Type
+  # Abstract base class for all types. This class
+  # should never be instantiated directly.
+
+  class TypeError < StandardError; end
+
+  class Type
+
+    @@contract_cache = {}
+
+    def to_contract
+      c = @@contract_cache[self]
+      return c if c
+
+      slf = self # Bind self to slf since contracts are executed in scope of associated method
+      c = RDL::Contract::FlatContract.new(to_s) { |obj|
+        raise TypeError, "Expecting #{to_s}, got object of class #{RDL::Util.rdl_type_or_class(obj)}" unless slf.member?(obj)
+        true
+      }
+      return (@@contract_cache[self] = c)  # assignment evaluates to c
+    end
+
+  end
+end

data/lib/rdl/types/type_inferencer.rb

@@ -0,0 +1,73 @@
+module RDL
+  class TypeInferencer
+    def self.infer_type(it)
+      current_types = Set.new
+      it_types = it.map {|t| t.rdl_type}
+      it_types = it_types.to_set
+
+      it_types.each {|t|
+        subtype = current_types.any? {|ct| t.le(ct)}
+        current_types.add(t) if not subtype
+      }
+
+      if current_types.size == 1
+        current_types.to_a[0]
+      elsif current_types.size == 0
+        RDL::Type::NilType.new
+      else
+        RDL::Type::UnionType.new(*self.unify_param_types(current_types))
+      end
+    end
+
+    private
+    
+    def self.extract_types(param_type)
+      param_type.instance_of?(RDL::Type::UnionType) ? param_type.types.to_a : [param_type]
+    end
+    
+    # Unifies i.e. #<Set: {Array<String>, Array<Array<String>>}> into
+    # Array<(Array<String> or String)>
+    # If this step is not called, then infer_type for 
+    # [["a", "b"], [["c"]]].rdl_type would return
+    # (Array<Array<String>> or Array<String>) instead of
+    # (Array<(Array<String> or String)>)
+    def self.unify_param_types(type_set)
+      non_param_classes = []
+      parameterized_classes = {}
+
+      type_set.each {|member_type|
+        if member_type.instance_of? RDL::Type::GenericType
+          nominal_type = member_type.base
+
+          tparam_set = parameterized_classes.fetch(nominal_type) {|n_type|
+            cls = eval(n_type.name.to_s)
+            type_parameters = cls.instance_variable_get :@__cls_params
+            [].fill([], 0, type_parameters.size)
+          }
+
+          cls = eval(nominal_type.name.to_s)
+          type_parameters = cls.instance_variable_get :@__cls_params
+          ((0..(type_parameters.size - 1)).map {|tparam_index|
+             extract_types(member_type.params[tparam_index])
+           }).each_with_index {|type_parameter,index|            
+            tparam_set[index]+=type_parameter
+          }
+
+          parameterized_classes[nominal_type] = tparam_set
+        else
+          non_param_classes << member_type
+        end
+      }
+
+      parameterized_classes.each {|nominal, type_set|
+        t = type_set.map {|unioned_type_parameter|
+          RDL::Type::UnionType.new(*unify_param_types(unioned_type_parameter))
+        }
+
+        non_param_classes << RDL::Type::GenericType.new(nominal, *t)
+      }
+
+      non_param_classes
+    end
+  end
+end

data/lib/rdl/types/union.rb

@@ -0,0 +1,74 @@
+require_relative 'type'
+
+module RDL::Type
+  class UnionType < Type
+    attr_reader :types
+    
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(*types)
+      ts = []
+      types.each { |t|
+        if t.instance_of? NilType
+          next
+        elsif t.instance_of? TopType
+          ts = [t]
+          break
+        elsif t.instance_of? UnionType
+          ts.concat t.types
+        else
+          raise RuntimeError, "Attempt to create union type with non-type" unless t.is_a? Type
+          ts << t
+        end
+      }
+
+      ts.sort! { |a,b| a.object_id <=> b.object_id }      
+      ts.uniq!
+
+      return NilType.new if ts.size == 0
+      return ts[0] if ts.size == 1
+
+      t = @@cache[ts]
+      return t if t
+      t = UnionType.__new__(ts)
+      return (@@cache[ts] = t) # assignment evaluates to t
+    end
+
+    def initialize(types)
+      @types = types
+      super()
+    end
+
+    def to_s  # :nodoc:
+      "#{@types.map { |t| t.to_s }.join(' or ')}"
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)  # :nodoc:
+      return (other.instance_of? UnionType) && (other.types == @types)
+    end
+
+    def <=(other)
+      @types.all? { |t| t <= other }
+    end
+
+    def member?(obj, *args)
+      @types.any? { |t| t.member?(obj, *args) }
+    end
+    
+    def instantiate(inst)
+      return UnionType.new(*(@types.map { |t| t.instantiate(inst) }))
+    end
+    
+    def hash  # :nodoc:
+      41 + @types.hash
+    end
+  end
+end

data/lib/rdl/types/var.rb

@@ -0,0 +1,51 @@
+require_relative 'type'
+
+module RDL::Type
+  class VarType < Type
+    attr_reader :name
+
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(name)
+      name = name.to_s.to_sym
+      t = @@cache[name]
+      return t if t
+      t = self.__new__ name
+      return (@@cache[name] = t) # assignment evaluates to t
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s # :nodoc:
+      return @name.to_s
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      return (other.instance_of? self.class) && (other.name.to_s == @name.to_s)
+    end
+
+    def hash # :nodoc:
+      return @name.to_s.hash
+    end
+
+    def member?(obj, vars_wild: false)
+      return true if vars_wild
+      raise TypeError, "Unbound type variable #{@name}"
+    end
+
+    def instantiate(inst)
+      return inst[@name] if inst[@name]
+      return self
+    end
+  end
+end