rdl 2.0.0.rc4 → 2.0.0.rc5

data/lib/rdl/types/annotated_arg.rb

@@ -40,5 +40,13 @@ module RDL::Type
     def instantiate(inst)
       return AnnotatedArgType.new(@name, @type.instantiate(inst))
     end
+
+    def optional?
+      return type.optional?
+    end
+
+    def vararg?
+      return type.vararg?
+    end
   end
 end

data/lib/rdl/types/finite_hash.rb

@@ -1,22 +1,25 @@
 require_relative 'type'
 
 module RDL::Type
-  # A specialized GenericType for fixed-sized maps from values to
-  # types, for "named" arguments in Ruby. Values are compared with ==
-  # to see if they match.
+  # Type for finite maps from values to types; values are compared with ==.
+  # These are used for "named" arguments in Ruby, in which case the values are symbols.
+  # Finite hashes can also have a "rest" type (okay, they're not exactly finite in this case...)
+  # which is treated as a hash from Symbol to the type.
   class FiniteHashType < Type
     attr_reader :elts
+    attr_reader :rest
     attr_reader :the_hash # either nil or hash type if self has been promoted to hash
     attr_accessor :ubounds  # upper bounds this tuple has been compared with using <=
     attr_accessor :lbounds  # lower bounds...
 
-    # [+elts+] is a map from keys to types
-    def initialize(elts)
+    # [+ elts +] is a map from keys to types
+    def initialize(elts, rest)
       elts.each { |k, t|
         raise RuntimeError, "Got #{t.inspect} where Type expected" unless t.is_a? Type
         raise RuntimeError, "Type may not be annotated or vararg" if (t.instance_of? AnnotatedArgType) || (t.instance_of? VarargType)
       }
       @elts = elts
+      @rest = rest
       @the_hash = nil
       @cant_promote = false
       @ubounds = []
@@ -31,14 +34,14 @@ module RDL::Type
 
     def to_s
       return @the_hash.to_s if @the_hash
-      "{" + @elts.map { |k, t| k.to_s + ": " + t.to_s }.join(', ') + "}"
+      return "{ " + @elts.map { |k, t| k.to_s + ": " + t.to_s }.join(', ') + (if @rest then ", **" + @rest.to_s else "" end) + " }"
     end
 
     def ==(other) # :nodoc:
       return false if other.nil?
       return (@the_hash == other) if @the_hash
       other = other.canonical
-      return (other.instance_of? FiniteHashType) && (other.elts == @elts)
+      return (other.instance_of? FiniteHashType) && (other.elts == @elts) && (other.rest == @rest)
     end
 
     alias eql? ==
@@ -48,13 +51,22 @@ module RDL::Type
       other = other.canonical
       other = other.type if other.instance_of? AnnotatedArgType
       return true if other.instance_of? WildQuery
+      return false unless ((@rest.nil? && other.rest.nil?) ||
+                           (!@rest.nil? && !other.rest.nil? && @rest.match(other.rest)))
       return (@elts.length == other.elts.length &&
               @elts.all? { |k, v| (other.elts.has_key? k) && (v.match(other.elts[k]))})
     end
 
     def promote!
       return false if @cant_promote
-      @the_hash = GenericType.new($__rdl_hash_type, $__rdl_symbol_type, UnionType.new(*@elts.values))
+      # TODO look at key types
+      domain_type = UnionType.new(*(@elts.keys.map { |k| NominalType.new(k.class) }))
+      range_type = UnionType.new(*@elts.values)
+      if @rest
+        domain_type = UnionType.new(domain_type, $__rdl_symbol_type)
+        range_type = UnionType.new(range_type, @rest)
+      end
+      @the_hash = GenericType.new($__rdl_hash_type, domain_type, range_type)
       # same logic as Tuple
       return (@lbounds.all? { |lbound| lbound <= self }) && (@ubounds.all? { |ubound| self <= ubound })
     end
@@ -72,21 +84,24 @@ module RDL::Type
       return @the_hash.member(obj, *args) if @the_hash
       t = RDL::Util.rdl_type obj
       return t <= self if t
-      rest = @elts.clone # shallow copy
+      right_elts = @elts.clone # shallow copy
 
       return false unless obj.instance_of? Hash
 
       # Check that every mapping in obj exists in @map and matches the type
       obj.each_pair { |k, v|
-        return false unless @elts.has_key? k
-        t = @elts[k]
-        t = t.type if t.instance_of? OptionalType
-        return false unless t.member? v
-        rest.delete(k)
+        if @elts.has_key? k
+          t = @elts[k]
+          t = t.type if t.instance_of? OptionalType
+          return false unless t.member? v
+          right_elts.delete k
+        else
+          return false unless @rest && @rest.member?(v)
+        end
       }
 
       # Check that any remaining types are optional
-      rest.each_pair { |k, vt|
+      right_elts.each_pair { |k, vt|
         return false unless vt.instance_of? OptionalType
       }
 
@@ -95,12 +110,12 @@ module RDL::Type
 
     def instantiate(inst)
       return @the_hash.instantiate(inst) if @the_hash
-      return FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }])
+      return FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }], (if @rest then @rest.instantiate(inst) end))
     end
 
     def hash
       # note don't change hash value if @the_hash becomes non-nil
-      return 229 * @elts.hash
+      return 229 * @elts.hash * @rest.hash
     end
   end
 end

data/lib/rdl/types/lexer.rex

@@ -27,6 +27,7 @@ rule
   ,             { [:COMMA, text] }
   \?            { [:QUERY, text] }
   \!            { [:BANG, text] }
+  \*\*          { [:STARSTAR, text] } 
   \*            { [:STAR, text] }
   \#T           { [:HASH_TYPE, text] }
   \#Q           { [:HASH_QUERY, text] }

data/lib/rdl/types/lexer.rex.rb

@@ -106,6 +106,9 @@ class Parser < Racc::Parser
       when (text = @ss.scan(/\!/))
          action { [:BANG, text] }
 
+      when (text = @ss.scan(/\*\*/))
+         action { [:STARSTAR, text] }
+
       when (text = @ss.scan(/\*/))
          action { [:STAR, text] }
 

data/lib/rdl/types/method.rb

@@ -41,7 +41,11 @@ module RDL::Type
       }
       @args = *args
 
-      raise "Block must be MethodType" unless (not block) or (block.instance_of? MethodType)
+      if block.instance_of? OptionalType
+        raise "Block must be MethodType" unless block.type.is_a? MethodType
+      else
+        raise "Block must be MethodType" unless (not block) or (block.instance_of? MethodType)
+      end
       @block = block
 
       raise "Attempt to create method type with non-type ret" unless ret.is_a? Type
@@ -61,8 +65,12 @@ module RDL::Type
 	        check_arg_preds(bind, preds) if preds.size > 0
           @args.each_with_index {|a,i| args[i] = block_wrap(slf, inst, a, bind, &args[i]) if a.is_a? MethodType }
           if @block then
-            next unless blk
-            blk = block_wrap(slf, inst, @block, bind, &blk)
+            if @block.is_a? OptionalType
+              blk = block_wrap(slf, inst, @block.type.instantiate(inst), bind, &blk) if blk
+            else
+              next unless blk
+              blk = block_wrap(slf, inst, @block, bind, &blk)
+            end
           elsif blk then
             next
           end
@@ -79,6 +87,16 @@ module RDL::Type
           t = t.type.instantiate(inst)
           if actual == args.size
             states << [formal+1, actual] # skip to allow extra formal optionals at end
+          elsif t.is_a? MethodType
+            if args[actual].is_a? Proc
+              args[actual] = block_wrap(slf, inst, t, bind, &args[actual])
+              states << [formal+1, actual+1]
+            elsif args[actual].nil?
+              states << [formal+1, actual+1] # match
+              states << [formal+1, actual] # skip
+            else
+              states << [formal+1, actual]
+            end
           elsif t.member?(args[actual], vars_wild: true)
             states << [formal+1, actual+1] # match
             states << [formal+1, actual] # skip
@@ -255,7 +273,9 @@ RUBY
     end
 
     def to_s  # :nodoc:
-      if @block
+      if @block && @block.is_a?(OptionalType)
+        return "(#{@args.map { |arg| arg.to_s }.join(', ')}) #{@block.to_s} -> #{@ret.to_s}"
+      elsif @block
         return "(#{@args.map { |arg| arg.to_s }.join(', ')}) {#{@block.to_s}} -> #{@ret.to_s}"
       elsif @args
         return "(#{@args.map { |arg| arg.to_s }.join(', ')}) -> #{@ret.to_s}"

data/lib/rdl/types/optional.rb

@@ -6,13 +6,16 @@ module RDL::Type
       raise RuntimeError, "Attempt to create optional type with non-type" unless type.is_a? Type
       raise "Can't have optional optional type" if type.is_a? OptionalType
       raise "Can't have optional vararg type" if type.is_a? VarargType
+      raise "Can't have optional annotated type" if type.is_a? AnnotatedArgType
       @type = type
       super()
     end
 
     def to_s
-      if @type.instance_of? UnionType
+      if @type.is_a? UnionType
         "?(#{@type.to_s})"
+      elsif @type.is_a? MethodType
+        "?{ #{@type.to_s} }"
       else
         "?#{@type.to_s}"
       end
@@ -42,5 +45,9 @@ module RDL::Type
     def hash # :nodoc:
       return 57 + @type.hash
     end
+
+    def optional?
+      return true
+    end
   end
 end

data/lib/rdl/types/parser.racc

@@ -10,7 +10,7 @@ class Parser
 token HASH_TYPE HASH_QUERY CONST_BEGIN RASSOC
 token OR FIXNUM FLOAT COLON RARROW DOT DOTS ID SYMBOL SPECIAL_ID STRING PREDICATE
 token LPAREN RPAREN LBRACE RBRACE LBRACKET RBRACKET
-token COMMA QUERY BANG STAR LESS GREATER
+token COMMA QUERY BANG STARSTAR STAR LESS GREATER
 token EOF
 
 rule
@@ -45,22 +45,23 @@ rule
       { result = [] }
     | nonempty_arg_list { result = val[0] }
     | named_arg_list {
-      result = [RDL::Type::FiniteHashType.new(Hash[*val[0]])]
+      result = [RDL::Type::FiniteHashType.new(Hash[*val[0][0]], val[0][1])]
       }
   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]])]
+      result = [val[0], RDL::Type::FiniteHashType.new(Hash[*val[2][0]], val[2][1])]
       }
   arg:
       base_arg { result = val[0] }
-    | base_arg ID PREDICATE {result = RDL::Type::DependentArgType.new(val[1], val[0], val[2])}
+    | base_arg ID PREDICATE { result = RDL::Type::DependentArgType.new(val[1], val[0], val[2]) }
     | base_arg ID { result = RDL::Type::AnnotatedArgType.new(val[1], val[0]) }
     | DOTS { result = RDL::Type::DotsQuery.new }
   named_arg_list:
-      named_arg { result = val[0] }
-    | named_arg COMMA named_arg_list { result = val[0] + val[2] }
+      named_arg { result = [val[0], nil] }
+    | STARSTAR type_expr { result = [[], val[1]] }
+    | named_arg COMMA named_arg_list { result = [val[0] + val[2][0], val[2][1]] }
   named_arg:
       ID COLON base_arg_query_only { result = [val[0].to_sym, val[2]] }
 
@@ -75,6 +76,7 @@ rule
   block:
       { result = nil }
     | LBRACE method_type RBRACE { result = val[1] }
+    | QUERY LBRACE method_type RBRACE { result = RDL::Type::OptionalType.new val[2] }
 
   type_expr:
     union_type { result = val[0] }
@@ -94,8 +96,9 @@ rule
   | 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] }
+      hash_expr { result = [val[0], nil] }
+    | STARSTAR type_expr { result = [[], val[1]] }
+    | hash_expr COMMA hash_expr_comma_list { result = [val[0] + val[2][0], val[2][1]] }
 
   union_type:
     single_type { result = val[0] }
@@ -140,7 +143,7 @@ rule
       result = RDL::Type::TupleType.new
     }
     | LBRACE hash_expr_comma_list RBRACE {
-      result = RDL::Type::FiniteHashType.new(Hash[*val[1]])
+      result = RDL::Type::FiniteHashType.new(Hash[*val[1][0]], val[1][1])
     }
     | FIXNUM { result = RDL::Type::SingletonType.new(val[0].to_i) }
     | FLOAT { result = RDL::Type::SingletonType.new(val[0].to_f) }

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

@@ -11,7 +11,7 @@ module RDL::Type
 
 class Parser < Racc::Parser
 
-module_eval(<<'...end parser.racc/module_eval...', 'parser.racc', 159)
+module_eval(<<'...end parser.racc/module_eval...', 'parser.racc', 162)
 
 def initialize()
   @yydebug = true
@@ -21,198 +21,213 @@ end
 ##### State transition tables begin ###
 
 racc_action_table = [
-    21,    77,    19,    20,    79,    22,    29,    31,    14,    16,
-    82,    40,    11,    88,    17,    59,    18,    73,    32,    13,
-    33,    21,    91,    19,    20,     7,    22,    29,    31,    14,
-    16,    96,    39,    11,    39,    17,     7,    18,    99,    32,
-    13,    33,    21,   100,    19,    20,   102,    22,   104,    15,
-    14,    16,   106,     5,     6,    73,    17,    21,    18,    19,
-    20,    13,    22,   107,    15,    14,    16,     7,     8,     7,
-    35,    17,    21,    18,    19,    20,    13,    22,    37,    15,
-    14,    16,    39,    54,    55,    56,    17,    21,    18,    19,
-    20,    13,    22,    57,    15,    14,    16,    58,    62,    11,
-    64,    17,    21,    18,    19,    20,    13,    22,    59,    15,
-    14,    16,    66,    67,    68,    69,    17,    21,    18,    19,
-    20,    13,    22,    70,    15,    14,    16,    71,    72,    11,
-    74,    17,    21,    18,    19,    20,    13,    22,    75,    15,
-    14,    16,    76,   nil,    11,   nil,    17,   nil,    18,   nil,
-    85,    13,    21,   nil,    19,    20,   nil,    22,   nil,    15,
-    14,    16,   nil,   nil,    11,   nil,    17,    21,    18,    19,
-    20,    13,    22,   nil,    15,    14,    16,   nil,   nil,   nil,
-   nil,    17,    21,    18,    19,    20,    13,    22,   nil,    15,
-    14,    16,   nil,   nil,    11,   nil,    17,    21,    18,    19,
-    20,    13,    22,   nil,    15,    14,    16,   nil,   nil,    11,
-   nil,    17,    21,    18,    19,    20,    13,    22,   nil,    15,
-    14,    16,   nil,   nil,    11,   nil,    17,    21,    18,    19,
-    20,    13,    22,   nil,    15,    14,    16,   nil,   nil,   nil,
-   nil,    17,    21,    18,    19,    20,    13,    22,   nil,    15,
-    14,    16,   nil,   nil,    11,   nil,    17,    21,    18,    19,
-    20,    13,    22,   nil,    15,    14,    16,   nil,   nil,    11,
-   nil,    17,    21,    18,    19,    20,    13,    22,   nil,    49,
-    14,    16,   nil,   nil,    11,   nil,    17,   nil,    18,    53,
-    21,    13,    19,    20,   nil,    22,   nil,    15,    14,    16,
-    44,   nil,    42,    43,    17,   nil,    18,    40,   nil,   nil,
-    45,    44,     7,    42,    43,   nil,   nil,   nil,    40,   nil,
-   nil,    45 ]
+    21,    71,    19,    20,    72,    22,    29,    32,    14,    16,
+    41,    73,    11,    69,    17,    62,    18,    77,    33,    13,
+    31,    34,    21,    31,    19,    20,    75,    22,    29,    32,
+    14,    16,    76,    40,    11,    40,    17,    62,    18,    78,
+    33,    13,    31,    34,    45,    79,    43,    44,     5,     6,
+    45,    41,    43,    44,    46,    83,     7,    41,    80,    84,
+    46,    81,     7,    67,    48,    87,    21,    65,    19,    20,
+    48,    22,    60,    15,    14,    16,    59,    93,    11,    58,
+    17,    21,    18,    19,    20,    13,    22,    57,    15,    14,
+    16,    96,    56,    11,    40,    17,    21,    18,    19,    20,
+    13,    22,     7,    15,    14,    16,    38,   101,    11,     7,
+    17,    21,    18,    19,    20,    13,    22,   103,    51,    14,
+    16,    36,   105,    11,   106,    17,     7,    18,    55,    21,
+    13,    19,    20,   108,    22,     7,    15,    14,    16,     8,
+   111,   113,   114,    17,    21,    18,    19,    20,    13,    22,
+    77,    15,    14,    16,    70,   115,   nil,   nil,    17,    21,
+    18,    19,    20,    13,    22,   nil,    15,    14,    16,   nil,
+   nil,   nil,   nil,    17,    21,    18,    19,    20,    13,    22,
+   nil,    15,    14,    16,   nil,   nil,   nil,   nil,    17,    21,
+    18,    19,    20,    13,    22,   nil,    15,    14,    16,   nil,
+   nil,    11,   nil,    17,   nil,    18,   nil,    90,    13,    21,
+   nil,    19,    20,   nil,    22,   nil,    15,    14,    16,   nil,
+   nil,    11,   nil,    17,    21,    18,    19,    20,    13,    22,
+   nil,    15,    14,    16,   nil,   nil,    11,   nil,    17,    21,
+    18,    19,    20,    13,    22,   nil,    15,    14,    16,   nil,
+   nil,   nil,   nil,    17,    21,    18,    19,    20,    13,    22,
+   nil,    15,    14,    16,   nil,   nil,    11,   nil,    17,    21,
+    18,    19,    20,    13,    22,   nil,    15,    14,    16,   nil,
+   nil,    11,   nil,    17,    21,    18,    19,    20,    13,    22,
+   nil,    15,    14,    16,   nil,   nil,    11,   nil,    17,    21,
+    18,    19,    20,    13,    22,   nil,    15,    14,    16,   nil,
+   nil,    11,   nil,    17,    21,    18,    19,    20,    13,    22,
+   nil,    15,    14,    16,   nil,   nil,   nil,   nil,    17,    21,
+    18,    19,    20,    13,    22,   nil,    15,    14,    16,   nil,
+   nil,    11,   nil,    17,    21,    18,    19,    20,    13,    22,
+   nil,    15,    14,    16,   nil,   nil,   nil,   nil,    17,   nil,
+    18 ]
 
 racc_action_check = [
-    56,    54,    56,    56,    55,    56,    56,    56,    56,    56,
-    57,    58,    56,    65,    56,    31,    56,    49,    56,    56,
-    56,     7,    68,     7,     7,    73,     7,     7,     7,     7,
-     7,    78,    31,     7,    49,     7,    79,     7,    91,     7,
-     7,     7,    64,    94,    64,    64,    97,    64,   100,    64,
-    64,    64,   101,     0,     0,   104,    64,    66,    64,    66,
-    66,    64,    66,   106,    66,    66,    66,     0,     1,     6,
-     8,    66,    67,    66,    67,    67,    66,    67,    12,    67,
-    67,    67,    15,    21,    24,    27,    67,    32,    67,    32,
-    32,    67,    32,    28,    32,    32,    32,    30,    36,    32,
-    38,    32,    69,    32,    69,    69,    32,    69,    40,    69,
-    69,    69,    42,    43,    44,    45,    69,     5,    69,     5,
-     5,    69,     5,    46,     5,     5,     5,    47,    48,     5,
-    50,     5,    59,     5,    59,    59,     5,    59,    51,    59,
-    59,    59,    52,   nil,    59,   nil,    59,   nil,    59,   nil,
-    59,    59,    85,   nil,    85,    85,   nil,    85,   nil,    85,
-    85,    85,   nil,   nil,    85,   nil,    85,    37,    85,    37,
-    37,    85,    37,   nil,    37,    37,    37,   nil,   nil,   nil,
-   nil,    37,    11,    37,    11,    11,    37,    11,   nil,    11,
-    11,    11,   nil,   nil,    11,   nil,    11,    96,    11,    96,
-    96,    11,    96,   nil,    96,    96,    96,   nil,   nil,    96,
-   nil,    96,    39,    96,    39,    39,    96,    39,   nil,    39,
-    39,    39,   nil,   nil,    39,   nil,    39,    99,    39,    99,
-    99,    39,    99,   nil,    99,    99,    99,   nil,   nil,   nil,
-   nil,    99,    33,    99,    33,    33,    99,    33,   nil,    33,
-    33,    33,   nil,   nil,    33,   nil,    33,    74,    33,    74,
-    74,    33,    74,   nil,    74,    74,    74,   nil,   nil,    74,
-   nil,    74,    18,    74,    18,    18,    74,    18,   nil,    18,
-    18,    18,   nil,   nil,    18,   nil,    18,   nil,    18,    18,
-    13,    18,    13,    13,   nil,    13,   nil,    13,    13,    13,
-    17,   nil,    17,    17,    13,   nil,    13,    17,   nil,   nil,
-    17,    70,    17,    70,    70,   nil,   nil,   nil,    70,   nil,
-   nil,    70 ]
+     7,    45,     7,     7,    46,     7,     7,     7,     7,     7,
+    60,    47,     7,    43,     7,    32,     7,    51,     7,     7,
+     7,     7,    58,    60,    58,    58,    49,    58,    58,    58,
+    58,    58,    50,    32,    58,    51,    58,    41,    58,    52,
+    58,    58,    58,    58,    17,    53,    17,    17,     0,     0,
+    73,    17,    73,    73,    17,    57,    17,    73,    54,    57,
+    73,    56,     0,    39,    17,    59,    90,    37,    90,    90,
+    73,    90,    30,    90,    90,    90,    28,    68,    90,    27,
+    90,    11,    90,    11,    11,    90,    11,    24,    11,    11,
+    11,    71,    21,    11,    15,    11,    78,    11,    78,    78,
+    11,    78,    77,    78,    78,    78,    12,    82,    78,    83,
+    78,    18,    78,    18,    18,    78,    18,    84,    18,    18,
+    18,     8,    96,    18,    99,    18,     6,    18,    18,    72,
+    18,    72,    72,   102,    72,   103,    72,    72,    72,     1,
+   106,   107,   109,    72,    70,    72,    70,    70,    72,    70,
+   111,    70,    70,    70,    44,   113,   nil,   nil,    70,    69,
+    70,    69,    69,    70,    69,   nil,    69,    69,    69,   nil,
+   nil,   nil,   nil,    69,    67,    69,    67,    67,    69,    67,
+   nil,    67,    67,    67,   nil,   nil,   nil,   nil,    67,    62,
+    67,    62,    62,    67,    62,   nil,    62,    62,    62,   nil,
+   nil,    62,   nil,    62,   nil,    62,   nil,    62,    62,    31,
+   nil,    31,    31,   nil,    31,   nil,    31,    31,    31,   nil,
+   nil,    31,   nil,    31,    48,    31,    48,    48,    31,    48,
+   nil,    48,    48,    48,   nil,   nil,    48,   nil,    48,   105,
+    48,   105,   105,    48,   105,   nil,   105,   105,   105,   nil,
+   nil,   nil,   nil,   105,     5,   105,     5,     5,   105,     5,
+   nil,     5,     5,     5,   nil,   nil,     5,   nil,     5,   101,
+     5,   101,   101,     5,   101,   nil,   101,   101,   101,   nil,
+   nil,   101,   nil,   101,    33,   101,    33,    33,   101,    33,
+   nil,    33,    33,    33,   nil,   nil,    33,   nil,    33,    34,
+    33,    34,    34,    33,    34,   nil,    34,    34,    34,   nil,
+   nil,    34,   nil,    34,    38,    34,    38,    38,    34,    38,
+   nil,    38,    38,    38,   nil,   nil,   nil,   nil,    38,    40,
+    38,    40,    40,    38,    40,   nil,    40,    40,    40,   nil,
+   nil,    40,   nil,    40,    13,    40,    13,    13,    40,    13,
+   nil,    13,    13,    13,   nil,   nil,   nil,   nil,    13,   nil,
+    13 ]
 
 racc_action_pointer = [
-    48,    68,   nil,   nil,   nil,   110,    50,    14,    70,   nil,
-   nil,   175,    74,   283,   nil,    54,   nil,   293,   265,   nil,
-   nil,    69,   nil,   nil,    64,   nil,   nil,    83,    79,   nil,
-    95,     4,    80,   235,   nil,   nil,    78,   160,    96,   205,
-    97,   nil,   104,   105,   100,   107,   121,   105,   106,     6,
-   128,   114,   118,   nil,   -21,   -17,    -7,    -8,    -3,   125,
-   nil,   nil,   nil,   nil,    35,   -16,    50,    65,     0,    95,
-   304,   nil,   nil,     6,   250,   nil,   nil,   nil,    28,    17,
-   nil,   nil,   nil,   nil,   nil,   145,   nil,   nil,   nil,   nil,
-   nil,    30,   nil,   nil,    41,   nil,   190,    24,   nil,   220,
-    34,    38,   nil,   nil,    44,   nil,    45,   nil ]
+    43,   139,   nil,   nil,   nil,   247,   107,    -7,   121,   nil,
+   nil,    74,   102,   337,   nil,    65,   nil,    37,   104,   nil,
+   nil,    78,   nil,   nil,    67,   nil,   nil,    77,    62,   nil,
+    70,   202,     4,   277,   292,   nil,   nil,    47,   307,    59,
+   322,    26,   nil,     5,   146,   -13,    -4,     9,   217,     4,
+    10,     6,    37,    21,    34,   nil,    39,    34,    15,    47,
+    -4,   nil,   182,   nil,   nil,   nil,   nil,   167,    47,   152,
+   137,    69,   122,    43,   nil,   nil,   nil,    83,    89,   nil,
+   nil,   nil,   104,    90,    96,   nil,   nil,   nil,   nil,   nil,
+    59,   nil,   nil,   nil,   nil,   nil,   114,   nil,   nil,   122,
+   nil,   262,   111,   116,   nil,   232,   126,   127,   nil,   120,
+   nil,   139,   nil,   137,   nil,   nil ]
 
 racc_action_default = [
-   -60,   -60,    -1,    -2,    -3,   -60,   -60,   -11,   -60,    -4,
-   -31,   -60,   -43,   -60,   -47,   -48,   -49,   -35,   -60,   -56,
-   -57,   -60,   -59,    -5,   -60,   -12,   -13,   -14,   -17,   -20,
-   -21,   -48,   -60,   -60,   -26,   108,   -60,   -60,   -45,   -60,
-   -60,   -36,   -60,   -60,   -60,   -60,   -41,   -60,   -60,   -48,
-   -33,   -60,   -60,   -54,   -60,   -29,   -60,   -19,   -60,   -60,
-   -24,   -25,   -32,   -44,   -60,   -60,   -60,   -60,   -60,   -60,
-   -35,   -51,   -55,   -60,   -60,   -52,   -53,   -58,   -60,   -60,
-   -15,   -16,   -18,   -22,   -23,   -60,   -28,   -46,   -50,   -37,
-   -38,   -60,   -40,   -42,    -9,   -34,   -60,   -60,   -27,   -60,
-   -60,    -6,   -30,   -39,   -60,   -10,    -7,    -8 ]
+   -63,   -63,    -1,    -2,    -3,   -63,   -63,   -11,   -63,    -4,
+   -33,   -63,   -46,   -63,   -50,   -51,   -52,   -37,   -63,   -59,
+   -60,   -63,   -62,    -5,   -63,   -12,   -13,   -14,   -17,   -20,
+   -21,   -63,   -51,   -63,   -63,   -27,   116,   -63,   -63,   -48,
+   -63,   -63,   -38,   -63,   -63,   -63,   -63,   -43,   -63,   -63,
+   -63,   -51,   -35,   -63,   -63,   -57,   -63,   -30,   -63,   -19,
+   -63,   -22,   -63,   -25,   -26,   -34,   -47,   -63,   -63,   -63,
+   -63,   -63,   -63,   -37,   -44,   -54,   -58,   -63,   -63,   -55,
+   -56,   -61,   -63,   -63,   -63,   -15,   -16,   -18,   -23,   -24,
+   -63,   -29,   -49,   -53,   -39,   -40,   -63,   -42,   -45,    -9,
+   -36,   -63,   -63,   -63,   -28,   -63,   -63,    -6,   -31,   -63,
+   -41,   -63,   -10,    -7,   -32,    -8 ]
 
 racc_goto_table = [
-     9,    52,    34,     2,    63,    51,    36,    41,    26,    23,
-    48,    38,     3,    25,     4,    24,    78,    84,     1,   nil,
-    47,   nil,   nil,   nil,   nil,   nil,    65,    60,    61,   nil,
-   nil,    87,   nil,    89,    90,   nil,    92,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    34,   nil,   nil,    86,   nil,   nil,    81,   nil,    83,
-    41,    95,    80,    93,   nil,   nil,   103,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,    94,   nil,   nil,   nil,
-    98,   nil,    97,   105,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   101 ]
+     2,     9,    54,    35,    66,    50,    23,    37,    42,    53,
+    39,    25,    26,     3,     4,    24,    82,    49,    89,     1,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    61,   nil,    63,
+    64,    68,   nil,    92,   nil,    94,    95,   nil,    97,   nil,
+   nil,   nil,   nil,   nil,    74,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    35,   nil,   nil,   nil,    91,   nil,
+   nil,    98,    85,    86,    42,    88,   nil,   nil,   nil,   100,
+   nil,   110,   nil,   nil,   nil,   nil,   nil,    99,   nil,   nil,
+   nil,   nil,   nil,   102,   nil,   nil,   104,   nil,   nil,   nil,
+   112,   nil,   nil,   nil,   nil,   nil,   nil,   107,   nil,   nil,
+   nil,   nil,   nil,   109 ]
 
 racc_goto_check = [
-     5,     8,     5,     2,    15,    16,     5,    13,    10,     2,
-    18,    19,     3,     9,     4,     6,     7,    14,     1,   nil,
-     2,   nil,   nil,   nil,   nil,   nil,    16,     5,     5,   nil,
-   nil,    15,   nil,    15,    15,   nil,    15,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,     5,   nil,   nil,     5,   nil,   nil,    10,   nil,    10,
-    13,    16,     9,    18,   nil,   nil,    15,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,     2,   nil,   nil,   nil,
-     5,   nil,     2,     8,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,     5 ]
+     2,     5,     8,     5,    15,    18,     2,     5,    13,    16,
+    19,     9,    10,     3,     4,     6,     7,     2,    14,     1,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,     5,   nil,     5,
+     5,    16,   nil,    15,   nil,    15,    15,   nil,    15,   nil,
+   nil,   nil,   nil,   nil,     5,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,     5,   nil,   nil,   nil,     5,   nil,
+   nil,    18,     9,    10,    13,    10,   nil,   nil,   nil,    16,
+   nil,    15,   nil,   nil,   nil,   nil,   nil,     2,   nil,   nil,
+   nil,   nil,   nil,     2,   nil,   nil,     5,   nil,   nil,   nil,
+     8,   nil,   nil,   nil,   nil,   nil,   nil,     5,   nil,   nil,
+   nil,   nil,   nil,     2 ]
 
 racc_goto_pointer = [
-   nil,    18,     3,    12,    14,    -5,     8,   -39,   -17,     6,
-     1,   nil,   nil,   -10,   -42,   -33,   -13,   nil,    -7,    -2 ]
+   nil,    19,     0,    13,    14,    -4,     8,   -41,   -16,     4,
+     5,   nil,   nil,    -9,   -44,   -34,    -9,   nil,   -12,    -3 ]
 
 racc_goto_default = [
-   nil,   nil,   nil,   nil,   nil,    50,   nil,   nil,   nil,   nil,
-   nil,    27,    28,    30,   nil,    10,   nil,    46,   nil,    12 ]
+   nil,   nil,   nil,   nil,   nil,    52,   nil,   nil,   nil,   nil,
+   nil,    27,    28,    30,   nil,    10,   nil,    47,   nil,    12 ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
-  1, 32, :_reduce_1,
-  1, 32, :_reduce_2,
-  1, 32, :_reduce_3,
-  2, 34, :_reduce_4,
-  2, 35, :_reduce_5,
-  6, 33, :_reduce_6,
-  7, 33, :_reduce_7,
-  8, 33, :_reduce_8,
-  3, 39, :_reduce_9,
-  5, 39, :_reduce_10,
-  0, 37, :_reduce_11,
-  1, 37, :_reduce_12,
-  1, 37, :_reduce_13,
-  1, 40, :_reduce_14,
-  3, 40, :_reduce_15,
-  3, 40, :_reduce_16,
-  1, 42, :_reduce_17,
-  3, 42, :_reduce_18,
-  2, 42, :_reduce_19,
-  1, 42, :_reduce_20,
-  1, 41, :_reduce_21,
-  3, 41, :_reduce_22,
-  3, 44, :_reduce_23,
-  2, 43, :_reduce_24,
-  2, 43, :_reduce_25,
-  1, 43, :_reduce_26,
-  2, 45, :_reduce_27,
-  1, 45, :_reduce_28,
-  0, 38, :_reduce_29,
-  3, 38, :_reduce_30,
-  1, 36, :_reduce_31,
-  3, 36, :_reduce_32,
-  1, 47, :_reduce_33,
-  3, 47, :_reduce_34,
-  0, 48, :_reduce_none,
-  1, 48, :_reduce_36,
-  3, 48, :_reduce_37,
-  3, 48, :_reduce_38,
-  5, 48, :_reduce_39,
-  3, 48, :_reduce_40,
-  1, 49, :_reduce_41,
+  1, 33, :_reduce_1,
+  1, 33, :_reduce_2,
+  1, 33, :_reduce_3,
+  2, 35, :_reduce_4,
+  2, 36, :_reduce_5,
+  6, 34, :_reduce_6,
+  7, 34, :_reduce_7,
+  8, 34, :_reduce_8,
+  3, 40, :_reduce_9,
+  5, 40, :_reduce_10,
+  0, 38, :_reduce_11,
+  1, 38, :_reduce_12,
+  1, 38, :_reduce_13,
+  1, 41, :_reduce_14,
+  3, 41, :_reduce_15,
+  3, 41, :_reduce_16,
+  1, 43, :_reduce_17,
+  3, 43, :_reduce_18,
+  2, 43, :_reduce_19,
+  1, 43, :_reduce_20,
+  1, 42, :_reduce_21,
+  2, 42, :_reduce_22,
+  3, 42, :_reduce_23,
+  3, 45, :_reduce_24,
+  2, 44, :_reduce_25,
+  2, 44, :_reduce_26,
+  1, 44, :_reduce_27,
+  2, 46, :_reduce_28,
+  1, 46, :_reduce_29,
+  0, 39, :_reduce_30,
+  3, 39, :_reduce_31,
+  4, 39, :_reduce_32,
+  1, 37, :_reduce_33,
+  3, 37, :_reduce_34,
+  1, 48, :_reduce_35,
+  3, 48, :_reduce_36,
+  0, 49, :_reduce_none,
+  1, 49, :_reduce_38,
+  3, 49, :_reduce_39,
+  3, 49, :_reduce_40,
+  5, 49, :_reduce_41,
   3, 49, :_reduce_42,
-  1, 46, :_reduce_43,
-  3, 46, :_reduce_44,
-  2, 46, :_reduce_45,
-  4, 46, :_reduce_46,
-  1, 50, :_reduce_47,
-  1, 50, :_reduce_48,
-  1, 50, :_reduce_49,
-  4, 50, :_reduce_50,
-  3, 50, :_reduce_51,
-  3, 50, :_reduce_52,
-  3, 50, :_reduce_53,
-  2, 50, :_reduce_54,
-  3, 50, :_reduce_55,
-  1, 50, :_reduce_56,
-  1, 50, :_reduce_57,
-  3, 50, :_reduce_58,
-  1, 50, :_reduce_59 ]
-
-racc_reduce_n = 60
-
-racc_shift_n = 108
+  1, 50, :_reduce_43,
+  2, 50, :_reduce_44,
+  3, 50, :_reduce_45,
+  1, 47, :_reduce_46,
+  3, 47, :_reduce_47,
+  2, 47, :_reduce_48,
+  4, 47, :_reduce_49,
+  1, 51, :_reduce_50,
+  1, 51, :_reduce_51,
+  1, 51, :_reduce_52,
+  4, 51, :_reduce_53,
+  3, 51, :_reduce_54,
+  3, 51, :_reduce_55,
+  3, 51, :_reduce_56,
+  2, 51, :_reduce_57,
+  3, 51, :_reduce_58,
+  1, 51, :_reduce_59,
+  1, 51, :_reduce_60,
+  3, 51, :_reduce_61,
+  1, 51, :_reduce_62 ]
+
+racc_reduce_n = 63
+
+racc_shift_n = 116
 
 racc_token_table = {
   false => 0,
@@ -242,12 +257,13 @@ racc_token_table = {
   :RBRACKET => 24,
   :QUERY => 25,
   :BANG => 26,
-  :STAR => 27,
-  :LESS => 28,
-  :GREATER => 29,
-  :EOF => 30 }
+  :STARSTAR => 27,
+  :STAR => 28,
+  :LESS => 29,
+  :GREATER => 30,
+  :EOF => 31 }
 
-racc_nt_base = 31
+racc_nt_base = 32
 
 racc_use_result_var = true
 
@@ -295,6 +311,7 @@ Racc_token_to_s_table = [
   "RBRACKET",
   "QUERY",
   "BANG",
+  "STARSTAR",
   "STAR",
   "LESS",
   "GREATER",
@@ -415,7 +432,7 @@ module_eval(<<'.,.,', 'parser.racc', 45)
 
 module_eval(<<'.,.,', 'parser.racc', 47)
   def _reduce_13(val, _values, result)
-          result = [RDL::Type::FiniteHashType.new(Hash[*val[0]])]
+          result = [RDL::Type::FiniteHashType.new(Hash[*val[0][0]], val[0][1])]
       
     result
   end
@@ -438,7 +455,7 @@ module_eval(<<'.,.,', 'parser.racc', 51)
 module_eval(<<'.,.,', 'parser.racc', 52)
   def _reduce_16(val, _values, result)
      # named arg list must come last
-      result = [val[0], RDL::Type::FiniteHashType.new(Hash[*val[2]])]
+      result = [val[0], RDL::Type::FiniteHashType.new(Hash[*val[2][0]], val[2][1])]
       
     result
   end
@@ -453,7 +470,7 @@ module_eval(<<'.,.,', 'parser.racc', 56)
 
 module_eval(<<'.,.,', 'parser.racc', 57)
   def _reduce_18(val, _values, result)
-    result = RDL::Type::DependentArgType.new(val[1], val[0], val[2])
+     result = RDL::Type::DependentArgType.new(val[1], val[0], val[2]) 
     result
   end
 .,.,
@@ -474,191 +491,212 @@ module_eval(<<'.,.,', 'parser.racc', 59)
 
 module_eval(<<'.,.,', 'parser.racc', 61)
   def _reduce_21(val, _values, result)
-     result = val[0] 
+     result = [val[0], nil] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 62)
   def _reduce_22(val, _values, result)
-     result = val[0] + val[2] 
+     result = [[], val[1]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 64)
+module_eval(<<'.,.,', 'parser.racc', 63)
   def _reduce_23(val, _values, result)
-     result = [val[0].to_sym, val[2]] 
+     result = [val[0] + val[2][0], val[2][1]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 67)
+module_eval(<<'.,.,', 'parser.racc', 65)
   def _reduce_24(val, _values, result)
-     result = RDL::Type::OptionalType.new val[1] 
+     result = [val[0].to_sym, val[2]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 68)
   def _reduce_25(val, _values, result)
-     result = RDL::Type::VarargType.new val[1] 
+     result = RDL::Type::OptionalType.new val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 69)
   def _reduce_26(val, _values, result)
-     result = val[0] 
+     result = RDL::Type::VarargType.new val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 71)
+module_eval(<<'.,.,', 'parser.racc', 70)
   def _reduce_27(val, _values, result)
-     result = RDL::Type::OptionalType.new val[1] 
+     result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 72)
   def _reduce_28(val, _values, result)
-     result = val[0] 
+     result = RDL::Type::OptionalType.new val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 75)
+module_eval(<<'.,.,', 'parser.racc', 73)
   def _reduce_29(val, _values, result)
-     result = nil 
+     result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 76)
   def _reduce_30(val, _values, result)
-     result = val[1] 
+     result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 79)
+module_eval(<<'.,.,', 'parser.racc', 77)
   def _reduce_31(val, _values, result)
-     result = val[0] 
+     result = val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 80)
+module_eval(<<'.,.,', 'parser.racc', 78)
   def _reduce_32(val, _values, result)
-     result = val[1] 
+     result = RDL::Type::OptionalType.new val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 83)
+module_eval(<<'.,.,', 'parser.racc', 81)
   def _reduce_33(val, _values, result)
-     result = [val[0]] 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 84)
+module_eval(<<'.,.,', 'parser.racc', 82)
   def _reduce_34(val, _values, result)
-     result = [val[0]] + val[2] 
+     result = val[1] 
     result
   end
 .,.,
 
-# reduce 35 omitted
+module_eval(<<'.,.,', 'parser.racc', 85)
+  def _reduce_35(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.racc', 87)
+module_eval(<<'.,.,', 'parser.racc', 86)
   def _reduce_36(val, _values, result)
+     result = [val[0]] + val[2] 
+    result
+  end
+.,.,
+
+# reduce 37 omitted
+
+module_eval(<<'.,.,', 'parser.racc', 89)
+  def _reduce_38(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 88)
-  def _reduce_37(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 90)
+  def _reduce_39(val, _values, result)
      result = [val[0].to_i, val[2]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 89)
-  def _reduce_38(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 91)
+  def _reduce_40(val, _values, result)
      result = [val[0].to_f, val[2]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 91)
-  def _reduce_39(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 93)
+  def _reduce_41(val, _values, result)
         result = [Kernel.const_get(val[0]), val[2]]
   
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 93)
-  def _reduce_40(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 95)
+  def _reduce_42(val, _values, result)
      result = [val[0], val[2]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 96)
-  def _reduce_41(val, _values, result)
-     result = val[0] 
+module_eval(<<'.,.,', 'parser.racc', 98)
+  def _reduce_43(val, _values, result)
+     result = [val[0], nil] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 97)
-  def _reduce_42(val, _values, result)
-     result = val[0] + val[2] 
+module_eval(<<'.,.,', 'parser.racc', 99)
+  def _reduce_44(val, _values, result)
+     result = [[], val[1]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 100)
-  def _reduce_43(val, _values, result)
+  def _reduce_45(val, _values, result)
+     result = [val[0] + val[2][0], val[2][1]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 103)
+  def _reduce_46(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 101)
-  def _reduce_44(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 104)
+  def _reduce_47(val, _values, result)
      result = RDL::Type::UnionType.new val[0], val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 102)
-  def _reduce_45(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 105)
+  def _reduce_48(val, _values, result)
      result = RDL::Type::NonNullType.new val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 103)
-  def _reduce_46(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 106)
+  def _reduce_49(val, _values, result)
      result = RDL::Type::UnionType.new(RDL::Type::NonNullType.new(val[1]), val[3]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 106)
-  def _reduce_47(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 109)
+  def _reduce_50(val, _values, result)
      result = RDL::Type::SingletonType.new(val[0].to_sym) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 108)
-  def _reduce_48(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 111)
+  def _reduce_51(val, _values, result)
           if val[0] == 'nil' then
         result = $__rdl_nil_type
       elsif val[0] == 'true' then
@@ -675,8 +713,8 @@ module_eval(<<'.,.,', 'parser.racc', 108)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 121)
-  def _reduce_49(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 124)
+  def _reduce_52(val, _values, result)
           if $__rdl_special_types.has_key? val[0] then
         result = $__rdl_special_types[val[0]]
       else
@@ -687,8 +725,8 @@ module_eval(<<'.,.,', 'parser.racc', 121)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 128)
-  def _reduce_50(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 131)
+  def _reduce_53(val, _values, result)
           n = RDL::Type::NominalType.new(val[0])
       result = RDL::Type::GenericType.new(n, *val[2])
     
@@ -696,69 +734,69 @@ module_eval(<<'.,.,', 'parser.racc', 128)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 131)
-  def _reduce_51(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 134)
+  def _reduce_54(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 133)
-  def _reduce_52(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 136)
+  def _reduce_55(val, _values, result)
           result = RDL::Type::TupleType.new(*val[1])
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 136)
-  def _reduce_53(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 139)
+  def _reduce_56(val, _values, result)
           result = RDL::Type::StructuralType.new(Hash[*val[1]])
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 139)
-  def _reduce_54(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 142)
+  def _reduce_57(val, _values, result)
           result = RDL::Type::TupleType.new
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 142)
-  def _reduce_55(val, _values, result)
-          result = RDL::Type::FiniteHashType.new(Hash[*val[1]])
+module_eval(<<'.,.,', 'parser.racc', 145)
+  def _reduce_58(val, _values, result)
+          result = RDL::Type::FiniteHashType.new(Hash[*val[1][0]], val[1][1])
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 144)
-  def _reduce_56(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 147)
+  def _reduce_59(val, _values, result)
      result = RDL::Type::SingletonType.new(val[0].to_i) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 145)
-  def _reduce_57(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 148)
+  def _reduce_60(val, _values, result)
      result = RDL::Type::SingletonType.new(val[0].to_f) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 147)
-  def _reduce_58(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 150)
+  def _reduce_61(val, _values, result)
           result =  RDL::Type::SingletonType.new(Kernel.const_get(val[1]))
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 151)
-  def _reduce_59(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 154)
+  def _reduce_62(val, _values, result)
      result = RDL::Type::WildQuery.new 
     result
   end