typisch 0.1.5

data/lib/typisch/numeric.rb

@@ -0,0 +1,80 @@
+# TODO: have this work with whichever of these classes
+# end up getting required, without having to require them
+# upfront
+require 'rational'
+require 'bigdecimal'
+require 'complex'
+
+module Typisch
+  # This is aiming to be a nice numeric tower like those of Scheme etc:
+  #   Integral < Rational < Real < Complex
+  #
+  # In these kinds of numeric tower, type and degree of precision is treated as a separate
+  # orthogonal concern; for now I've not treated precision at all here, although
+  # support could be added, eg to allow a distinction between
+  #  - fixed precision binary floating point (Float)
+  #  - arbitrary precision decimal floating point (BigDecimal)
+  #  - fixed size integer (Fixnum)
+  #  - arbitrary size integer (Bignum)
+  #  - etc
+  # There are quite a few ways to classify numeric types, so I've stuck with just the
+  # most basic mathematical numeric tower classification for now.
+  class Type::Numeric < Type::Constructor
+
+    def initialize(type, *valid_implementation_classes)
+      @type = type
+      @valid_implementation_classes = valid_implementation_classes
+    end
+
+    attr_reader :valid_implementation_classes
+
+    # Note: these are based on how ruby 1.8.7 does it; 1.9 changes
+    # things slightly IIRC so may need tweaks to cope with this.
+    # Either way ruby's hierarchy of numeric types is slightly idiosyncratic:
+    complex  = new('Complex',  ::Numeric)
+    real     = new('Real',     ::Precision, ::BigDecimal, ::Rational)
+    rational = new('Rational', ::Rational, ::Integer)
+    integral = new('Integral', ::Integer)
+
+    Registry.register_global_type(:complex, complex)
+
+    Registry.register_global_type(:real, real)
+    Registry.register_global_type(:float, real) # aliasing this as :float too
+
+    Registry.register_global_type(:rational, rational)
+
+    Registry.register_global_type(:integral, integral)
+    Registry.register_global_type(:integer, integral)  # aliasing this as :integer too
+
+    TOWER = [complex, real, rational, integral]
+
+    class << self
+      private :new
+
+      def top_type(*)
+        TOWER.first
+      end
+
+      def check_subtype(x, y)
+        x.index_in_tower >= y.index_in_tower
+      end
+    end
+
+    def to_s(*)
+      @name.inspect
+    end
+
+    def tag
+      @type
+    end
+
+    def index_in_tower
+      TOWER.index {|t| t.equal?(self)}
+    end
+
+    def shallow_check_type(instance)
+      case instance when *@valid_implementation_classes then true else false end
+    end
+    alias :check_type :shallow_check_type
+  end
+end

data/lib/typisch/object.rb

@@ -0,0 +1,72 @@
+class Typisch::Type
+  class Object < Constructor
+    class << self
+      def top_type(*)
+        new("Object")
+      end
+
+      def check_subtype(x, y, &recursively_check_subtype)
+        return false unless x.class_or_module <= y.class_or_module
+        y.property_names_to_types.all? do |y_propname, y_type|
+          x_type = x[y_propname] and recursively_check_subtype[x_type, y_type]
+        end
+      end
+    end
+
+    def initialize(tag, property_names_to_types={})
+      @tag = tag
+      raise ArgumentError, "expected String tag name for first argument" unless tag.is_a?(::String) && !tag.empty?
+      @property_names_to_types = property_names_to_types
+    end
+
+    attr_reader :tag, :property_names_to_types
+
+    def class_or_module
+      tag.split('::').inject(::Object) {|a,b| a.const_get(b)}
+    end
+
+    def property_names
+      @property_names_to_types.keys
+    end
+
+    def subexpression_types
+      @property_names_to_types.values
+    end
+
+    def [](property_name)
+      @property_names_to_types[property_name]
+    end
+
+    # For now, will only accept classes of object where the properties are available
+    # via attr_reader-style getter methods. TODO: maybe make allowances for objects
+    # which want to type-check via hash-style property access too.
+    def check_type(instance, &recursively_check_type)
+      instance.is_a?(class_or_module) &&
+      @property_names_to_types.all? do |prop_name, type|
+        instance.respond_to?(prop_name) &&
+        recursively_check_type[type, instance.send(prop_name)]
+      end
+    end
+
+    def shallow_check_type(instance)
+      instance.is_a?(class_or_module)
+    end
+
+    def to_string(depth, indent)
+      next_indent = "#{indent}  "
+      pairs = @property_names_to_types.map {|n,t| "#{n.inspect} => #{t.to_s(depth+1, "#{indent}  ")}"}
+      tag = @tag == "Object" ? '' : "#{@tag},"
+      "object(#{tag}\n#{next_indent}#{pairs.join(",\n#{next_indent}")}\n#{indent})"
+    end
+
+    def canonicalize!
+      @property_names_to_types.keys.each do |name|
+        @property_names_to_types[name] = @property_names_to_types[name].target
+      end
+    end
+
+    def property_annotations(property_name)
+      (annotations[:properties] ||= {})[property_name] ||= {}
+    end
+  end
+end

data/lib/typisch/poset_algorithms.rb

@@ -0,0 +1,18 @@
+module Typisch
+
+  class << self
+    # Finds a minimal set of upper bounds amongst the given set of items
+    # from a partially-ordered set, which together cover the whole set.
+    #
+    # In the worst case this will just return the whole set.
+    def find_minimal_set_of_upper_bounds(*items)
+      result = []
+      items.each do |item|
+        next if result.any? {|other| item <= other}
+        result.delete_if {|other| other <= item}
+        result << item
+      end
+      result
+    end
+  end
+end

data/lib/typisch/registry.rb

@@ -0,0 +1,146 @@
+module Typisch
+  # A registry is a glorified hash lookup of types by name
+  #
+  # - provide a concise way of referring to more complex types
+  # - help with the wiring up of recursive types
+  # -
+  #
+  class Registry
+    attr_reader :types_by_name, :types_by_class, :types_by_class_and_version
+
+    def initialize(&block)
+      @types_by_name = GLOBALS.dup
+      @pending_canonicalization = {}
+      @types_by_class = {}
+      @types_by_class_and_version = {}
+      register(&block) if block
+    end
+
+    def [](name, version=nil)
+      name = :"#{name}" if name.is_a?(::Module)
+      name = :"#{name}__#{version}" if version
+      @types_by_name[name] ||= Type::NamedPlaceholder.new(name, self)
+    end
+
+    def register_type(name, type, &callback_on_canonicalization)
+      case @types_by_name[name]
+      when Type::NamedPlaceholder
+        @types_by_name[name].send(:target=, type)
+      when NilClass
+      else
+        raise Error, "type already registered with name #{name.inspect}"
+      end
+      type.send(:name=, name) unless type.name
+      @types_by_name[name] = type
+      @pending_canonicalization[name] = [type, callback_on_canonicalization]
+    end
+    alias :[]= :register_type
+
+    # While loading, we'll register various types in this hash of types
+    # (boolean, string, ...) which we want to be included in all registries
+    GLOBALS = {}
+    def self.register_global_type(name, type)
+      type.send(:name=, name) unless type.name
+      GLOBALS[name] = type
+    end
+
+    # All registering of types in a registry needs to be done inside one of these
+    # blocks; it ensures that the any forward references or cyclic references are
+    # resolved (via canonicalize!-ing every type in the type graph) once you've
+    # finished registering types.
+    #
+    # This also ensures that any uses of recursion are valid / well-founded, and
+    # does any other necessary validation of the type graph you've declared which
+    # isn't possible to do upfront.
+    #
+    # You can nest register blocks without ill-effect; it will only try to
+    # resolve forward references etc once the outermost block has exited.
+    #
+    # Note, this is all very much non-threadsafe, wouldn't be hard to make it so
+    # (probably just slap a big mutex around it) but not sure why exactly you'd
+    # want multi-threaded type registration anyway to anyway so leaving as-is for now.
+    def register(&block)
+      if @registering_types
+        DSLContext.new(self).instance_eval(&block)
+      else
+        start_registering_types!
+        DSLContext.new(self).instance_eval(&block)
+        stop_registering_types!
+      end
+    end
+
+    def start_registering_types!
+      @registering_types = true
+    end
+
+    def stop_registering_types!
+      @registering_types = false
+
+      types = @pending_canonicalization.values.map {|t,c| t}
+      each_type_in_graph(*types) {|t| t.canonicalize!}
+      @pending_canonicalization.each {|name,(type,callback)| callback.call if callback}
+      @pending_canonicalization = {}
+    end
+
+    def each_type_in_graph(*types)
+      seen_so_far = {}
+      while (type = types.pop)
+        next if seen_so_far[type]
+        seen_so_far[type] = true
+        yield type
+        types.push(*type.subexpression_types)
+      end
+    end
+
+    # Allow you to dup and merge registries
+
+    def initialize_copy(other)
+      @types_by_name = @types_by_name.dup
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def merge!(other)
+      @types_by_name.merge!(other.types_by_name)
+    end
+
+    def to_s
+      pairs = @types_by_name.map do |n,t|
+        next if GLOBALS[n]
+        "r.register #{n.inspect}, #{t.to_s(0, '  ')}"
+      end.compact
+      "Typisch::Registry.new do |r|\n  #{pairs.join("\n  ")}\nend"
+    end
+
+    def register_type_for_class(klass, type)
+      @types_by_class[klass] = type
+    end
+
+    def register_version_type_for_class(klass, version, type)
+      @types_by_class_and_version[[klass, version]] = type
+    end
+  end
+
+  # We set up a global registry which you can use if you like, either
+  # via Typisch.global_registry or via the convenience aliases
+  # Typisch.[] and Typisch.register.
+  #
+  # Or, you can make your own registry if you don't want to share a
+  # global registry with other code using this library. (recommended
+  # if writing modular code / library code which uses this).
+
+  def self.global_registry
+    @global_registry ||= Registry.new
+  end
+
+  def self.register(&block)
+    global_registry.register(&block)
+  end
+
+  def self.[](name)
+    global_registry[name]
+  end
+
+end

data/lib/typisch/sequence.rb

@@ -0,0 +1,107 @@
+class Typisch::Type
+  # A Sequence is an ordered collection of items, all of a given type.
+  #
+  # For now if you want an unordered collection, you just have to treat it
+  # as an ordered collection with arbitrary order; if you want a map/hash you
+  # just treat it as a sequence of tuples. TODO: would be nice to
+  # have more of a hierarchy of collection types here, eg OrderedSequence < Set.
+  #
+  #
+  # (ordered) Sequences support 'slice types', which are a kind of structural
+  # supertype for sequences. Their use is primarily in specifying partial
+  # serializations or partial type-checking for large sequences.
+  #
+  # Eg sequence(:integer, :slice => 0...10)
+  #
+  # This is saying: "A sequence of ints, which may be of any known length, but
+  # where I only care (to validate, serialize, ...) at most the first 10 items".
+  #
+  # Eg sequence(:integer, :slice => 0...10, :total_length => false)
+  #
+  # This is saying: "A sequence of ints, which may be of any known or unknown length,
+  # but where I only care about (validating, serializing, ...) at most the first 10 items,
+  # and I don't care about (validating, serializing...) the total length of the collection
+  class Sequence < Constructor
+    class << self
+      def top_type(overall_top)
+        new(overall_top, :slice => (0...0), :total_length => false)
+      end
+
+      def check_subtype(x, y, &recursively_check_subtype)
+        recursively_check_subtype[x.type, y.type] && (
+          !x.slice ||
+          (y.slice && (
+            x.slice.begin <= y.slice.begin &&
+            x.slice.end >= y.slice.end &&
+            (x.total_length || !y.total_length)
+          ))
+        )
+      end
+    end
+
+    def initialize(type, options={})
+      @type = type
+      if options[:slice]
+        @slice = options[:slice]
+        @slice = (@slice.begin...@slice.end+1) unless @slice.exclude_end?
+        @total_length = options[:total_length] != false
+      end
+    end
+
+    attr_reader :slice, :total_length
+
+    def with_options(options)
+      self.class.new(@type, {:slice => @slice, :total_length => @total_length}.merge!(options))
+    end
+
+    def subexpression_types
+      [@type]
+    end
+
+    def check_type(instance, &recursively_check_type)
+      shallow_check_type(instance) && if @slice
+        (instance[@slice] || []).all? {|i| recursively_check_type[@type, i]} &&
+        (!@total_length || ::Integer === instance.length)
+      else
+        instance.all? {|i| recursively_check_type[@type, i]}
+      end
+    end
+
+    # I tried allowing any Enumerable, but this resulted in allowing String and a bunch
+    # of other things which sort of expose a vaguely-array-like interface but not really
+    # in a way that's helpful for typing purposes. E.g. String in 1.8.7 exposes Enumerable
+    # over its *lines*, but an array-like interface over its *characters*, sometimes as
+    # strings, sometimes as ascii char codes. So not consistent at all.
+    #
+    # Any other classes added here must expose Enumerable, but also .length and slices
+    # via [] (at least if you want them to work with slice types).
+    #
+    # For now allowing Hashes too so they can be typed as a sequence of tuples, although should
+    # really only be typed as a set of tuples as there's no ordering or support for slices.
+    VALID_IMPLEMENTATION_CLASSES = [::Array, ::Hash]
+
+    def shallow_check_type(instance)
+      case instance when *VALID_IMPLEMENTATION_CLASSES then true else false end
+    end
+
+    def tag
+      "Sequence"
+    end
+
+    attr_reader :type
+
+    def to_string(depth, indent)
+      result = "sequence(#{@type.to_s(depth+1, indent)}"
+      if @slice
+        result << ", :slice => #{@slice}"
+        result << ", :total_length => false" unless @total_length
+      end
+      result << ")"
+    end
+
+    def canonicalize!
+      @type = @type.target
+    end
+  end
+
+end

data/lib/typisch/serialization.rb

@@ -0,0 +1,80 @@
+require 'json'
+
+module Typisch
+  class JSONSerializer
+    def initialize(type, options={})
+      @type = type
+      @options = {}
+      @type_tag_key = (options[:type_tag_key] || '__class__').freeze
+      @class_to_type_tag = options[:class_to_type_tag]
+      @type_tag_to_class = options[:type_tag_to_class] || (@class_to_type_tag && @class_to_type_tag.invert)
+    end
+
+    def class_to_type_tag(klass)
+      @class_to_type_tag ? @class_to_type_tag[klass] : klass.to_s
+    end
+
+    def serialize(value)
+      serialize_to_jsonable(value).to_json
+    end
+
+    def serialize_already_encountered_pair(value, type, existing_serialization)
+      raise SerializationError, "cyclic object / type graph when serializing"
+    end
+
+    # http://work.tinou.com/2009/06/the-expression-problem-and-other-mysteries-of-life.html
+    def serialize_to_jsonable(value, type=@type, existing_serializations={})
+      existing = existing_serializations[[type, value]]
+      return serialize_already_encountered_pair(value, type, existing) if existing
+
+      result = case type
+      when Type::Date
+        value.to_s
+
+      when Type::Time
+        value.iso8601
+
+      when Type::Sequence
+        if type.slice
+          slice = value[type.slice]
+          existing_serializations[[type, value]] = result = {
+            @type_tag_key => class_to_type_tag(value.class),
+            'range_start' => type.slice.begin
+          }
+          result['items'] = slice.map {|v| serialize_to_jsonable(v, type.type, existing_serializations)} if slice
+          result['total_items'] = value.length if type.total_length
+          result
+        else
+          result = existing_serializations[[type, value]] = []
+          value.each {|v| result << serialize_to_jsonable(v, type.type, existing_serializations)}
+          result
+        end
+
+      when Type::Tuple
+        result = existing_serializations[[type, value]] = []
+        type.types.zip(value).each {|t,v| result << serialize_to_jsonable(v,t,existing_serializations)}
+        result
+
+      when Type::Object
+        result = existing_serializations[[type, value]] = {@type_tag_key => class_to_type_tag(value.class)}
+        type.property_names_to_types.each do |prop_name, type|
+          result[prop_name.to_s] = serialize_to_jsonable(value.send(prop_name), type, existing_serializations)
+        end
+        result
+
+      when Type::Union
+        type = type.alternative_types.find {|t| t.shallow_check_type(value)}
+        raise SerializationError, "No types in union #{type} matched #{value.inspect}, could not serialize" unless type
+        serialize_to_jsonable(value, type, existing_serializations)
+
+      when Type::Constructor # Numeric, Null, String, Boolean etc
+        value
+
+      else
+        raise SerializationError, "Type #{type} not supported for serialization of #{value.inspect}"
+      end
+
+      result
+    end
+  end
+end

data/lib/typisch/string.rb

@@ -0,0 +1,69 @@
+module Typisch
+  # String types support refinement types, specifying a set of allowed values,
+  # or a maximum length.
+  #
+  # About ruby Symbols: these are a pain in the arse.
+  # For now I'm allowing them to type-check interchangably with Strings.
+  # Since Typisch isn't specifically designed for Ruby's quirks but for more general
+  # data interchange, I don't think Symbol should have a special priviledged type
+  # of its own.
+  #
+  # Nevertheless if we ever allow custom type tags on String types (as we do for
+  # Object types at the moment) we could perhaps allow Symbol as a specially-tagged psuedo
+  # string like type. Although it's not a subclass of String, so hmm.
+  class Type::String < Type::Constructor
+    class << self
+      def tag
+        "String"
+      end
+
+      def top_type(*)
+        @top_type ||= new
+      end
+
+      def check_subtype(x, y)
+        x.equal?(y) || (
+          (x.max_length || Infinity) <= (y.max_length || Infinity) &&
+          (!y.values || (x.values && x.values.subset?(y.values)))
+        )
+      end
+    end
+
+    def initialize(refinements={})
+      @refinements = refinements
+      if @refinements[:values] && !@refinements[:values].is_a?(::Set)
+        @refinements[:values] = ::Set.new(refinements[:values])
+      end
+    end
+
+    Infinity = 1.0/0
+
+    def max_length
+      @refinements[:max_length]
+    end
+
+    def values
+      @refinements[:values]
+    end
+
+    def tag
+      self.class.tag
+    end
+
+    def to_s(*)
+      @name ? @name.inspect : "string(#{@refinements.inspect})"
+    end
+
+    def self.tag
+      "String"
+    end
+
+    def shallow_check_type(instance)
+      (::String === instance || ::Symbol === instance) &&
+      (!values     || values.include?(instance.to_s)) &&
+      (!max_length || instance.to_s.length <= max_length)
+    end
+
+    Registry.register_global_type(:string, top_type)
+  end
+end

data/lib/typisch/subtyping.rb

@@ -0,0 +1,64 @@
+class Typisch::Type
+  class << self
+    # The core of the subtyping algorithm, which copes with equi-recursive types.
+    #
+    # Actually quite simple on the face of it -- or at least, short.
+    #
+    # The crucial thing is that we allow a goal to be assumed without proof during
+    # the proving of its subgoals. Since (because of the potentially recursive nature
+    # of types) those subgoals may refer to types from the parent goal, we could otherwise
+    # run into infinite loops.
+    #
+    # How's that justified from a logic perspective? well, what we're doing is,
+    # we're just checking that the given subtyping judgement *isn't* provably
+    # *false* under the inference rules at hand. This allows a maximal consistent
+    # set of subtyping judgements to be made.
+    #
+    # Its dual, requiring that the judgement *is* provably *true* under the inference
+    # rules, would only allow a minimal set to be proven, and could get stuck
+    # searching forever for a proof of those judgements which are neither provably false
+    # nor provably true (namely, the awkward recursive ones).
+    #
+    # See Pierce on equi-recursive types and subtyping for the theory:
+    # http://www.cis.upenn.edu/~bcpierce/tapl/, it's an application of
+    # http://en.wikipedia.org/wiki/Knaster–Tarski_theorem to show that this
+    # is a least fixed point with respect to the adding of extra inferences
+    # to a set of subtyping judgements, if you note that those inference rules
+    # are monotonic. 'Corecursion' / 'coinduction' are also terms for what's
+    # going on here.
+    #
+    # TODO: for best performance, should we be going depth-first or breadth-first here?
+    #
+    # Also TODO: when subtype? succeeds (returns true), we can safely save the resulting
+    # set of judgements that were shown to be consistent, for use during future calls to
+    # subtype?. Memoization essentially.
+    def subtype?(x, y, may_assume_proven = {}, depth=0)
+      return true if may_assume_proven[[x,y]]
+      may_assume_proven[[x,y]] = true
+
+      result = check_subtype(x, y) do |u,v|
+        subtype?(u, v, may_assume_proven, depth+1)
+      end
+
+      result
+    end
+
+  private
+    def check_subtype(x, y, &recursively_check_subtype)
+      # Types are either union types, or constructor types. We deal with the unions first.
+      if Union === x
+        x.alternative_types.all? {|t| recursively_check_subtype[t, y]}
+      elsif Union === y
+        y.alternative_types.any? {|t| recursively_check_subtype[x, t]}
+      elsif x.type_lattice == y.type_lattice
+        # Hand over to that specific type_lattice in which both these Type::Constructor types
+        # live, in order to check subtyping goals which are specific to this lattice.
+        x.type_lattice.check_subtype(x, y, &recursively_check_subtype)
+      else
+        # Different Type::Constructor lattices are non-overlapping so we stop unless they're
+        # the same:
+        false
+      end
+    end
+  end
+end