rdl 1.0.0.rc1

data/lib/rdl/types/nil.rb

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

data/lib/rdl/types/nominal.rb

@@ -0,0 +1,80 @@
+require_relative 'type'
+
+module RDL::Type
+  class NominalType < Type
+    attr_reader :name # string
+    
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(name)
+      name = name.to_s
+      return NilType.new if name == "NilClass"
+      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 eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      return (other.instance_of? self.class) && (other.name == @name)
+    end
+
+    def hash # :nodoc:
+      return @name.hash
+    end
+
+    def to_s
+      return @name
+    end
+
+    def klass
+      @klass = RDL::Util.to_class(name) unless @klass
+      return @klass
+    end
+
+    def <=(other)
+      k = klass
+      return true if other.instance_of? TopType
+      return k.ancestors.member?(other.klass) if other.instance_of? NominalType
+#      return self <= other.base if other.instance_of? GenericType # raw subtyping not allowed
+      if other.instance_of? StructuralType
+        # similar logic in GenericType
+        other.methods.each_pair { |m, t|
+          return false unless k.method_defined? m
+          if RDL::Wrap.has_contracts?(k, m, :type)
+            types = RDL::Wrap.get_contracts(k, m, :type)
+            return false unless types.all? { |t_self| t_self <= t }
+          end
+        }
+        return true
+      end
+      if other.instance_of? UnionType
+        other.types.each {|ot| return true if self <= ot}
+      end
+      return false
+    end
+
+    def member?(obj, *args)
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      return true if obj.nil?
+      return obj.is_a? klass
+    end
+    
+    def instantiate(inst)
+      return self
+    end
+  end
+end

data/lib/rdl/types/optional.rb

@@ -0,0 +1,54 @@
+require_relative 'type'
+
+module RDL::Type
+  class OptionalType < Type
+    attr_reader :type
+
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(type)
+      t = @@cache[type]
+      return t if t
+      raise RuntimeError, "Attempt to create vararg type with non-type" unless type.is_a? Type
+      t = OptionalType.__new__ type
+      return (@@cache[type] = t) # assignment evaluates to t
+    end
+
+    def initialize(type)
+      raise "Can't have optional optional type" if type.class == OptionalType
+      raise "Can't have optional vararg type" if type.class == VarargType
+      @type = type
+      super()
+    end
+
+    def to_s
+      if @type.instance_of? UnionType
+        "?(#{@type.to_s})"
+      else
+        "?#{@type.to_s}"
+      end
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other) # :nodoc:
+      return (other.instance_of? OptionalType) && (other.type == @type)
+    end
+
+    # Note: no member?, because these can only appear in MethodType, where they're handled specially
+    
+    def instantiate(inst)
+      return OptionalType.new(@type.instantiate(inst))
+    end
+    
+    def hash # :nodoc:
+      return 57 + @type.hash
+    end
+  end
+end

data/lib/rdl/types/parser.racc

@@ -0,0 +1,150 @@
+class Parser
+  prechigh
+    left COMMA
+    right RARROW
+    left OR
+  preclow
+
+  start entry
+
+token DOUBLE_HASH CONST_BEGIN RASSOC
+token OR FIXNUM FLOAT COLON RARROW ID SYMBOL SPECIAL_ID STRING
+token LPAREN RPAREN LBRACE RBRACE LBRACKET RBRACKET
+token COMMA QUERY STAR LESS GREATER
+token EOF
+
+rule
+
+  entry:
+      method_type { result = val[0] }
+    | bare_type { result = val[0] }
+
+  bare_type:
+      DOUBLE_HASH type_expr {
+        result = val[1]
+      }
+
+  method_type:
+      LPAREN arg_list RPAREN block RARROW type_expr {
+        result = RDL::Type::MethodType.new val[1], val[3], val[5]
+      }
+   | LPAREN arg_list RPAREN block RARROW type_expr ID {
+        result = RDL::Type::MethodType.new val[1], val[3], RDL::Type::AnnotatedArgType.new(val[6], val[5])
+      }
+
+  method_sig_list:
+     ID COLON method_type { result = [val[0].to_sym, val[2]] }
+   | ID COLON method_type COMMA method_sig_list { result = [val[0].to_sym, val[2]] + val[4] }
+
+  arg_list:
+      { result = [] }
+    | nonempty_arg_list { result = val[0] }
+    | named_arg_list {
+      result = [RDL::Type::FiniteHashType.new(Hash[*val[0]])]
+      }
+  nonempty_arg_list:
+      arg { result = [val[0]] }
+    | arg COMMA nonempty_arg_list { result = val[2].unshift val[0] }
+    | arg COMMA named_arg_list { # named arg list must come last
+      result = [val[0], RDL::Type::FiniteHashType.new(Hash[*val[2]])]
+      }
+  arg:
+      base_arg { result = val[0] }
+    | base_arg ID { result = RDL::Type::AnnotatedArgType.new(val[1], val[0]) }
+  named_arg_list:
+      named_arg { result = val[0] }
+    | named_arg COMMA named_arg_list { result = val[0] + val[2] }
+  named_arg:
+      ID COLON base_arg_query_only { result = [val[0].to_sym, val[2]] }
+
+  base_arg:
+      QUERY type_expr { result = RDL::Type::OptionalType.new val[1] }
+    | STAR type_expr { result = RDL::Type::VarargType.new val[1] }
+    | type_expr { result = val[0] }
+  base_arg_query_only:
+      QUERY type_expr { result = RDL::Type::OptionalType.new val[1] }
+    | type_expr { result = val[0] }
+
+  block:
+      { result = nil }
+    | LBRACE method_type RBRACE { result = val[1] }
+
+  type_expr:
+    union_type { result = val[0] }
+  | LPAREN type_expr RPAREN { result = val[1] }
+
+  type_expr_comma_list:
+      type_expr { result = [val[0]] }
+    | type_expr COMMA type_expr_comma_list { result = [val[0]] + val[2] }
+
+  hash_expr:
+  | named_arg { result = val[0] }
+  | FIXNUM RASSOC union_type { result = [val[0].to_i, val[2]] }
+  | FLOAT RASSOC union_type { result = [val[0].to_f, val[2]] }
+  | CONST_BEGIN ID RBRACE RASSOC union_type {
+    result = [Kernel.const_get(val[0]), val[2]]
+  }
+  | STRING RASSOC union_type { result = [val[0], val[2]] } # strings are allowed as finite hash keys
+
+  hash_expr_comma_list:
+      hash_expr { result = val[0] }
+    | hash_expr COMMA hash_expr_comma_list { result = val[0] + val[2] }
+
+  union_type:
+    single_type { result = val[0] }
+  | single_type OR union_type { result = RDL::Type::UnionType.new val[0], val[2] }
+
+  single_type:
+      SYMBOL { result = RDL::Type::SingletonType.new(val[0].to_sym) }
+    | ID {
+      if val[0] == 'nil' then
+        result = RDL::Type::NilType.new
+      elsif val[0] =~ /^[a-z_]+\w*\'?/ then
+        result = RDL::Type::VarType.new(val[0].to_sym)
+      else
+        result = RDL::Type::NominalType.new val[0]
+      end
+    }
+    | SPECIAL_ID {
+      if $__rdl_special_types.has_key? val[0] then
+        result = $__rdl_special_types[val[0]]
+      else
+        fail "Unexpected special type identifier #{val[0]}"
+      end
+    }
+    | ID LESS type_expr_comma_list GREATER { 
+      n = RDL::Type::NominalType.new(val[0])
+      result = RDL::Type::GenericType.new(n, *val[2])
+    }
+    | LBRACKET type_expr_comma_list RBRACKET {
+      result = RDL::Type::TupleType.new(*val[1])
+    }
+    | LBRACKET method_sig_list RBRACKET {
+      result = RDL::Type::StructuralType.new(Hash[*val[1]])
+    }
+    | LBRACE hash_expr_comma_list RBRACE {
+      result = RDL::Type::FiniteHashType.new(Hash[*val[1]])
+    }
+    | FIXNUM { result = RDL::Type::SingletonType.new(val[0].to_i) }
+    | FLOAT { result = RDL::Type::SingletonType.new(val[0].to_f) }
+    | CONST_BEGIN ID RBRACE {
+      result =  RDL::Type::SingletonType.new(Kernel.const_get(val[1]))
+    }
+# The following can't be used in SingletonTypes because those compare using .equal?
+#    | STRING { result = RDL::Type::SingletonType.new(val[0]) }
+
+---- header ----
+
+require_relative 'lexer.rex'
+
+module RDL::Type
+
+---- inner ----
+
+def initialize()
+  @yydebug = true
+end
+
+---- footer ----
+
+end

data/lib/rdl/types/parser.tab.rb

@@ -0,0 +1,654 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.12
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+
+require_relative 'lexer.rex'
+
+module RDL::Type
+
+class Parser < Racc::Parser
+
+module_eval(<<'...end parser.racc/module_eval...', 'parser.racc', 143)
+
+def initialize()
+  @yydebug = true
+end
+
+...end parser.racc/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    18,    56,    16,    17,    62,    25,    11,    13,    50,     9,
+    58,    15,    59,    14,    32,    26,    27,    18,    50,    16,
+    17,    32,    25,    11,    13,     4,     9,    60,    15,    61,
+    14,    57,    26,    27,    18,     5,    16,    17,    63,    12,
+    11,    13,    64,     9,    65,    15,    66,    14,    18,    73,
+    16,    17,    68,    12,    11,    13,    53,    37,    49,    15,
+    18,    14,    16,    17,    75,    12,    11,    13,     5,     9,
+    48,    15,    18,    14,    16,    17,    47,    12,    11,    13,
+    46,     9,    80,    15,    18,    14,    16,    17,    45,    12,
+    11,    13,    32,     9,    83,    15,    18,    14,    16,    17,
+     5,    12,    11,    13,    31,     9,    86,    15,    18,    14,
+    16,    17,    87,    33,    11,    13,    29,     9,    89,    15,
+    18,    14,    16,    17,    90,    12,    11,    13,     6,    93,
+    56,    15,    18,    14,    16,    17,   nil,    12,    11,    13,
+   nil,     9,   nil,    15,    18,    14,    16,    17,   nil,    12,
+    11,    13,   nil,   nil,   nil,    15,    18,    14,    16,    17,
+   nil,    12,    11,    13,   nil,     9,   nil,    15,    18,    14,
+    16,    17,   nil,    12,    11,    13,   nil,   nil,   nil,    15,
+    18,    14,    16,    17,   nil,    12,    11,    13,   nil,     9,
+   nil,    15,    18,    14,    16,    17,   nil,    12,    11,    13,
+   nil,     9,   nil,    15,    18,    14,    16,    17,   nil,    12,
+    11,    13,   nil,   nil,   nil,    15,    41,    14,    39,    40,
+    41,    37,    39,    40,    42,    37,   nil,   nil,    42 ]
+
+racc_action_check = [
+     5,    33,     5,     5,    41,     5,     5,     5,    25,     5,
+    35,     5,    36,     5,    33,     5,     5,    47,    37,    47,
+    47,    25,    47,    47,    47,     0,    47,    39,    47,    40,
+    47,    34,    47,    47,    50,     0,    50,    50,    42,    50,
+    50,    50,    43,    50,    44,    50,    45,    50,    31,    50,
+    31,    31,    46,    31,    31,    31,    30,    49,    24,    31,
+    83,    31,    83,    83,    55,    83,    83,    83,    56,    83,
+    23,    83,     9,    83,     9,     9,    22,     9,     9,     9,
+    19,     9,    62,     9,    73,     9,    73,    73,    18,    73,
+    73,    73,    12,    73,    67,    73,    32,    73,    32,    32,
+    68,    32,    32,    32,    10,    32,    76,    32,    14,    32,
+    14,    14,    80,    14,    14,    14,     6,    14,    84,    14,
+    63,    14,    63,    63,    86,    63,    63,    63,     1,    88,
+    90,    63,     4,    63,     4,     4,   nil,     4,     4,     4,
+   nil,     4,   nil,     4,    60,     4,    60,    60,   nil,    60,
+    60,    60,   nil,   nil,   nil,    60,    57,    60,    57,    57,
+   nil,    57,    57,    57,   nil,    57,   nil,    57,    87,    57,
+    87,    87,   nil,    87,    87,    87,   nil,   nil,   nil,    87,
+    26,    87,    26,    26,   nil,    26,    26,    26,   nil,    26,
+   nil,    26,    27,    26,    27,    27,   nil,    27,    27,    27,
+   nil,    27,   nil,    27,    61,    27,    61,    61,   nil,    61,
+    61,    61,   nil,   nil,   nil,    61,    64,    61,    64,    64,
+    15,    64,    15,    15,    64,    15,   nil,   nil,    15 ]
+
+racc_action_pointer = [
+    20,   128,   nil,   nil,   126,    -6,   116,   nil,   nil,    66,
+   100,   nil,    69,   nil,   102,   214,   nil,   nil,    77,    64,
+   nil,   nil,    74,    59,    56,    -2,   174,   186,   nil,   nil,
+    40,    42,    90,    -9,    29,   -10,    -8,     8,   nil,    20,
+    22,    -7,    31,    40,    26,    28,    35,    11,   nil,    46,
+    28,   nil,   nil,   nil,   nil,    40,    53,   150,   nil,   nil,
+   138,   198,    64,   114,   210,   nil,   nil,    91,    85,   nil,
+   nil,   nil,   nil,    78,   nil,   nil,   104,   nil,   nil,   nil,
+   105,   nil,   nil,    54,   100,   nil,   113,   162,   118,   nil,
+   120,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -50,   -50,    -1,    -2,   -50,    -8,   -50,    -3,   -26,   -50,
+   -38,   -40,   -41,   -42,   -50,   -30,   -47,   -48,   -50,   -50,
+    -9,   -10,   -11,   -14,   -16,   -41,   -50,   -50,   -21,    94,
+   -50,   -50,   -50,   -41,   -28,   -50,   -50,   -50,   -31,   -50,
+   -50,   -50,   -50,   -36,   -50,   -50,   -24,   -50,   -15,   -50,
+   -50,   -19,   -20,   -27,   -39,   -50,   -50,   -50,   -44,   -45,
+   -50,   -50,   -50,   -50,   -30,   -46,   -49,   -50,   -50,   -12,
+   -13,   -17,   -18,   -50,   -23,   -43,    -6,   -29,   -32,   -33,
+   -50,   -35,   -37,   -50,   -50,   -22,   -50,   -50,    -4,   -25,
+   -50,    -7,   -34,    -5 ]
+
+racc_goto_table = [
+     7,    28,    36,     2,    54,    30,    44,    38,    21,    20,
+    35,    67,    72,    19,     3,     1,   nil,   nil,   nil,   nil,
+   nil,   nil,    51,    52,   nil,   nil,   nil,   nil,    55,   nil,
+   nil,   nil,   nil,    78,    79,   nil,    81,   nil,   nil,   nil,
+   nil,   nil,   nil,    28,   nil,   nil,    74,   nil,   nil,   nil,
+    70,    69,    71,    77,   nil,    82,    38,   nil,   nil,    76,
+    92,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    85,
+   nil,    84,   nil,   nil,    91,   nil,   nil,   nil,   nil,    88 ]
+
+racc_goto_check = [
+     4,     4,     7,     2,    14,     4,    17,    12,     9,     8,
+    15,     6,    13,     5,     3,     1,   nil,   nil,   nil,   nil,
+   nil,   nil,     4,     4,   nil,   nil,   nil,   nil,    15,   nil,
+   nil,   nil,   nil,    14,    14,   nil,    14,   nil,   nil,   nil,
+   nil,   nil,   nil,     4,   nil,   nil,     4,   nil,   nil,   nil,
+     9,     8,     9,    15,   nil,    17,    12,   nil,   nil,     2,
+    14,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     4,
+   nil,     2,   nil,   nil,     7,   nil,   nil,   nil,   nil,     4 ]
+
+racc_goto_pointer = [
+   nil,    15,     3,    14,    -4,     8,   -35,   -12,     4,     3,
+   nil,   nil,    -8,   -38,   -27,    -4,   nil,    -9,   nil ]
+
+racc_goto_default = [
+   nil,   nil,   nil,   nil,    34,   nil,   nil,   nil,   nil,   nil,
+    22,    23,    24,   nil,     8,   nil,    43,   nil,    10 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 27, :_reduce_1,
+  1, 27, :_reduce_2,
+  2, 29, :_reduce_3,
+  6, 28, :_reduce_4,
+  7, 28, :_reduce_5,
+  3, 33, :_reduce_6,
+  5, 33, :_reduce_7,
+  0, 31, :_reduce_8,
+  1, 31, :_reduce_9,
+  1, 31, :_reduce_10,
+  1, 34, :_reduce_11,
+  3, 34, :_reduce_12,
+  3, 34, :_reduce_13,
+  1, 36, :_reduce_14,
+  2, 36, :_reduce_15,
+  1, 35, :_reduce_16,
+  3, 35, :_reduce_17,
+  3, 38, :_reduce_18,
+  2, 37, :_reduce_19,
+  2, 37, :_reduce_20,
+  1, 37, :_reduce_21,
+  2, 39, :_reduce_22,
+  1, 39, :_reduce_23,
+  0, 32, :_reduce_24,
+  3, 32, :_reduce_25,
+  1, 30, :_reduce_26,
+  3, 30, :_reduce_27,
+  1, 41, :_reduce_28,
+  3, 41, :_reduce_29,
+  0, 42, :_reduce_none,
+  1, 42, :_reduce_31,
+  3, 42, :_reduce_32,
+  3, 42, :_reduce_33,
+  5, 42, :_reduce_34,
+  3, 42, :_reduce_35,
+  1, 43, :_reduce_36,
+  3, 43, :_reduce_37,
+  1, 40, :_reduce_38,
+  3, 40, :_reduce_39,
+  1, 44, :_reduce_40,
+  1, 44, :_reduce_41,
+  1, 44, :_reduce_42,
+  4, 44, :_reduce_43,
+  3, 44, :_reduce_44,
+  3, 44, :_reduce_45,
+  3, 44, :_reduce_46,
+  1, 44, :_reduce_47,
+  1, 44, :_reduce_48,
+  3, 44, :_reduce_49 ]
+
+racc_reduce_n = 50
+
+racc_shift_n = 94
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :COMMA => 2,
+  :RARROW => 3,
+  :OR => 4,
+  :DOUBLE_HASH => 5,
+  :CONST_BEGIN => 6,
+  :RASSOC => 7,
+  :FIXNUM => 8,
+  :FLOAT => 9,
+  :COLON => 10,
+  :ID => 11,
+  :SYMBOL => 12,
+  :SPECIAL_ID => 13,
+  :STRING => 14,
+  :LPAREN => 15,
+  :RPAREN => 16,
+  :LBRACE => 17,
+  :RBRACE => 18,
+  :LBRACKET => 19,
+  :RBRACKET => 20,
+  :QUERY => 21,
+  :STAR => 22,
+  :LESS => 23,
+  :GREATER => 24,
+  :EOF => 25 }
+
+racc_nt_base = 26
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "COMMA",
+  "RARROW",
+  "OR",
+  "DOUBLE_HASH",
+  "CONST_BEGIN",
+  "RASSOC",
+  "FIXNUM",
+  "FLOAT",
+  "COLON",
+  "ID",
+  "SYMBOL",
+  "SPECIAL_ID",
+  "STRING",
+  "LPAREN",
+  "RPAREN",
+  "LBRACE",
+  "RBRACE",
+  "LBRACKET",
+  "RBRACKET",
+  "QUERY",
+  "STAR",
+  "LESS",
+  "GREATER",
+  "EOF",
+  "$start",
+  "entry",
+  "method_type",
+  "bare_type",
+  "type_expr",
+  "arg_list",
+  "block",
+  "method_sig_list",
+  "nonempty_arg_list",
+  "named_arg_list",
+  "arg",
+  "base_arg",
+  "named_arg",
+  "base_arg_query_only",
+  "union_type",
+  "type_expr_comma_list",
+  "hash_expr",
+  "hash_expr_comma_list",
+  "single_type" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'parser.racc', 18)
+  def _reduce_1(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 19)
+  def _reduce_2(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 23)
+  def _reduce_3(val, _values, result)
+            result = val[1]
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 28)
+  def _reduce_4(val, _values, result)
+            result = RDL::Type::MethodType.new val[1], val[3], val[5]
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 31)
+  def _reduce_5(val, _values, result)
+            result = RDL::Type::MethodType.new val[1], val[3], RDL::Type::AnnotatedArgType.new(val[6], val[5])
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 35)
+  def _reduce_6(val, _values, result)
+     result = [val[0].to_sym, val[2]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 36)
+  def _reduce_7(val, _values, result)
+     result = [val[0].to_sym, val[2]] + val[4] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 39)
+  def _reduce_8(val, _values, result)
+     result = [] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 40)
+  def _reduce_9(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 42)
+  def _reduce_10(val, _values, result)
+          result = [RDL::Type::FiniteHashType.new(Hash[*val[0]])]
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 45)
+  def _reduce_11(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 46)
+  def _reduce_12(val, _values, result)
+     result = val[2].unshift val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 47)
+  def _reduce_13(val, _values, result)
+     # named arg list must come last
+      result = [val[0], RDL::Type::FiniteHashType.new(Hash[*val[2]])]
+      
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 51)
+  def _reduce_14(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 52)
+  def _reduce_15(val, _values, result)
+     result = RDL::Type::AnnotatedArgType.new(val[1], val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 54)
+  def _reduce_16(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 55)
+  def _reduce_17(val, _values, result)
+     result = val[0] + val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 57)
+  def _reduce_18(val, _values, result)
+     result = [val[0].to_sym, val[2]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 60)
+  def _reduce_19(val, _values, result)
+     result = RDL::Type::OptionalType.new val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 61)
+  def _reduce_20(val, _values, result)
+     result = RDL::Type::VarargType.new val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 62)
+  def _reduce_21(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 64)
+  def _reduce_22(val, _values, result)
+     result = RDL::Type::OptionalType.new val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 65)
+  def _reduce_23(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 68)
+  def _reduce_24(val, _values, result)
+     result = nil 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 69)
+  def _reduce_25(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 72)
+  def _reduce_26(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 73)
+  def _reduce_27(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 76)
+  def _reduce_28(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 77)
+  def _reduce_29(val, _values, result)
+     result = [val[0]] + val[2] 
+    result
+  end
+.,.,
+
+# reduce 30 omitted
+
+module_eval(<<'.,.,', 'parser.racc', 80)
+  def _reduce_31(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 81)
+  def _reduce_32(val, _values, result)
+     result = [val[0].to_i, val[2]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 82)
+  def _reduce_33(val, _values, result)
+     result = [val[0].to_f, val[2]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 84)
+  def _reduce_34(val, _values, result)
+        result = [Kernel.const_get(val[0]), val[2]]
+  
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 86)
+  def _reduce_35(val, _values, result)
+     result = [val[0], val[2]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 89)
+  def _reduce_36(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 90)
+  def _reduce_37(val, _values, result)
+     result = val[0] + val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 93)
+  def _reduce_38(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 94)
+  def _reduce_39(val, _values, result)
+     result = RDL::Type::UnionType.new val[0], val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 97)
+  def _reduce_40(val, _values, result)
+     result = RDL::Type::SingletonType.new(val[0].to_sym) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 99)
+  def _reduce_41(val, _values, result)
+          if val[0] == 'nil' then
+        result = RDL::Type::NilType.new
+      elsif val[0] =~ /^[a-z_]+\w*\'?/ then
+        result = RDL::Type::VarType.new(val[0].to_sym)
+      else
+        result = RDL::Type::NominalType.new val[0]
+      end
+    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 108)
+  def _reduce_42(val, _values, result)
+          if $__rdl_special_types.has_key? val[0] then
+        result = $__rdl_special_types[val[0]]
+      else
+        fail "Unexpected special type identifier #{val[0]}"
+      end
+    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 115)
+  def _reduce_43(val, _values, result)
+          n = RDL::Type::NominalType.new(val[0])
+      result = RDL::Type::GenericType.new(n, *val[2])
+    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 119)
+  def _reduce_44(val, _values, result)
+          result = RDL::Type::TupleType.new(*val[1])
+    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 122)
+  def _reduce_45(val, _values, result)
+          result = RDL::Type::StructuralType.new(Hash[*val[1]])
+    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 125)
+  def _reduce_46(val, _values, result)
+          result = RDL::Type::FiniteHashType.new(Hash[*val[1]])
+    
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 127)
+  def _reduce_47(val, _values, result)
+     result = RDL::Type::SingletonType.new(val[0].to_i) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 128)
+  def _reduce_48(val, _values, result)
+     result = RDL::Type::SingletonType.new(val[0].to_f) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 130)
+  def _reduce_49(val, _values, result)
+          result =  RDL::Type::SingletonType.new(Kernel.const_get(val[1]))
+    
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+end   # class Parser
+
+
+end