rdl 1.1.0 → 1.1.1.rc1

data/lib/rdl/types/lexer.rex

@@ -7,6 +7,8 @@ macro
   SPECIAL_ID %\w+
   FIXNUM -?(\d)+
   FLOAT -?\d\.\d+
+  PREDICATE \{\{(?:(?!}}).)+\}\}
+
 
 rule
   \s            # skip
@@ -15,6 +17,7 @@ rule
   =>            { [:RASSOC, text] }
   \(            { [:LPAREN, text] }
   \)            { [:RPAREN, text] }
+  {PREDICATE}   { [:PREDICATE, text] } 
   \{            { [:LBRACE, text] }
   \}            { [:RBRACE, text] }
   \[            { [:LBRACKET, text] }
@@ -24,8 +27,8 @@ rule
   ,             { [:COMMA, text] }
   \?            { [:QUERY, text] }
   \*            { [:STAR, text] }
-  \#T      	    { [:HASH_TYPE, text] }
-  \#Q      	    { [:HASH_QUERY, text] }
+  \#T           { [:HASH_TYPE, text] }
+  \#Q           { [:HASH_QUERY, text] }
   \$\{          { [:CONST_BEGIN, text] }
   \.\.\.        { [:DOTS, text] }
   \.            { [:DOT, text] }

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

@@ -76,6 +76,9 @@ class Parser < Racc::Parser
       when (text = @ss.scan(/\)/))
          action { [:RPAREN, text] }
 
+      when (text = @ss.scan(/\{\{(?:(?!}}).)+\}\}/))
+         action { [:PREDICATE, text] }
+
       when (text = @ss.scan(/\{/))
          action { [:LBRACE, text] }
 

data/lib/rdl/types/method.rb

@@ -57,14 +57,23 @@ module RDL::Type
     end
 
     # TODO: Check blk
-    def pre_cond?(inst, *args, &blk)
+    def pre_cond?(blk, slf, inst, bind, *args)
       states = [[0, 0]] # [position in @arg, position in args]
+      preds = []
       until states.empty?
         formal, actual = states.pop
-        return true if formal == @args.size && actual == args.size # Matched all actuals, no formals left over
+        if formal == @args.size && actual == args.size then # Matched all actuals, no formals left over
+	  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?(RDL::Type::MethodType) }
+          blk = block_wrap(slf,inst,@block,bind,&blk) if @block
+          return [true, args, blk, bind]
+        end
         next if formal >= @args.size # Too many actuals to match
         t = @args[formal]
-        t = t.type if t.instance_of? AnnotatedArgType
+        if t.instance_of? AnnotatedArgType then
+	  bind.local_variable_set(t.name.to_sym,args[actual])
+	  t = t.type
+        end
         case t
         when OptionalType
           t = t.type.instantiate(inst)
@@ -87,7 +96,22 @@ module RDL::Type
           else
             states << [formal+1, actual] # skip
           end
+        when DependentArgType
+	  bind.local_variable_set(t.name.to_sym,args[actual])
+          preds.push(t)
+          t = t.type.instantiate(inst)
+          the_actual = nil
+          if actual == args.size
+            next unless t.instance_of? FiniteHashType
+            if t.member?({}, vars_wild: true) # try matching against the empty hash
+              states << [formal+1, actual]
+            end
+          elsif t.member?(args[actual], vars_wild: true)
+            states << [formal+1, actual+1] # match
+            # no else case; if there is no match, this is a dead end
+          end
         else
+          t = RDL::Type::NominalType.new 'Proc' if t.instance_of? MethodType
           t = t.instantiate(inst)
           the_actual = nil
           if actual == args.size
@@ -101,43 +125,104 @@ module RDL::Type
           end
         end
       end
-      return false
+      return [false, args, blk, bind]
     end
 
-    def post_cond?(inst, ret, *args)
+    def check_arg_preds(bind, preds)
+      preds.each_with_index { |p,i|
+        if !eval(p.predicate, bind) then
+          raise TypeError, <<RUBY
+Argument does not match type predicate.
+Expected arg type:
+#{p}
+Actual argument value:
+#{bind.local_variable_get(p.name)}
+RUBY
+        end
+      }
+      return true
+    end
+
+    def check_ret_pred(bind, pred)
+      if !eval(pred.predicate, bind) then
+        raise TypeError, <<RUBY
+Return value does not match type predicate.
+Expected return type:
+#{pred}
+Actual return value:
+#{bind.local_variable_get(pred.name)}
+RUBY
+      end
+      return true
+    end
+
+    def post_cond?(slf, inst, ret, bind, *args)
+      new_ret = ret
+      if @ret.is_a?(RDL::Type::MethodType) then
+        if !ret.is_a?(Proc) then
+          return [false,ret]
+        else
+	  new_ret = block_wrap(slf,inst,@ret,bind,&ret)
+	  return [true, new_ret]
+	end
+      end
       method_name = method_name ? method_name + ": " : ""
-      return @ret.instantiate(inst).member?(ret, vars_wild: true)
+      if @ret.is_a?(DependentArgType) then
+        bind.local_variable_set(@ret.name.to_sym, ret)
+        check_ret_pred(bind,@ret)
+      end
+      return [@ret.instantiate(inst).member?(ret, vars_wild: true), new_ret]
     end
 
     def to_contract(inst: nil)
       c = @@contract_cache[self]
       return c if c
-
       # slf.ret, slf.args are the formals
       # ret, args are the actuals
       slf = self # Bind self so it's captured in a closure, since contracts are executed
                  # with self bound to the receiver method's self
+      bind = binding
       prec = RDL::Contract::FlatContract.new { |*args, &blk|
-        raise TypeError, "Arguments #{args} do not match argument types #{slf}" unless slf.pre_cond?(inst, *args, &blk)
+        raise TypeError, "Arguments #{args} do not match argument types #{slf}" unless slf.pre_cond?(blk, slf, inst, bind, *args)[0]
         true
       }
       postc = RDL::Contract::FlatContract.new { |ret, *args|
-        raise TypeError, "Return #{ret} does not match return type #{slf}" unless slf.post_cond?(inst, ret, *args)
+        raise TypeError, "Return #{ret} does not match return type #{slf}" unless slf.post_cond?(slf, inst, ret, bind, *args)[0]
         true
       }
       c = RDL::Contract::ProcContract.new(pre_cond: prec, post_cond: postc)
       return (@@contract_cache[self] = c) # assignment evaluates to c
     end
 
+    def to_higher_contract(sf, &blk)
+      #method for testing higher order contracts
+      #to_contract method only works for flat contracts
+      slf = self
+      inst = nil
+      bind = binding
+      Proc.new {|*args, &other_blk|
+        res,args,other_blk,bind = slf.pre_cond?(other_blk, slf, inst, bind, *args)
+        raise TypeError, "Arguments #{args} do not match argument types #{slf}" unless res
+        tmp = other_blk ? sf.instance_exec(*args, other_blk, &blk) : sf.instance_exec(*args, &blk)
+        res_post, ret = slf.post_cond?(slf, inst, tmp, bind, *args)
+        raise TypeError, "Return #{ret} does not match return type #{slf}" unless res_post
+        ret
+      }
+    end
+
+
     # [+types+] is an array of method types. Checks that [+args+] and
     # [+blk+] match at least one arm of the intersection type;
     # otherwise raises exception. Returns array of method types that
     # matched [+args+] and [+blk+]
-    def self.check_arg_types(method_name, types, inst, *args, &blk)
+    def self.check_arg_types(method_name, slf, bind, types, inst, *args, &blk)
       $__rdl_contract_switch.off {
         matches = [] # types that matched args
-        types.each_with_index { |t, i| matches << i if t.pre_cond?(inst, *args, &blk) }
-        return matches if matches.size > 0
+        types.each_with_index { |t, i|
+          res,args,blk,bind =t.pre_cond?(blk,slf,inst,bind,*args)
+          matches << i if res
+	}
+	return [matches, args, blk, bind] if matches.size > 0
         method_name = method_name ? method_name + ": " : ""
         raise TypeError, <<RUBY
 #{method_name}Argument type error.
@@ -151,9 +236,11 @@ RUBY
       }
     end
 
-    def self.check_ret_types(method_name, types, inst, matches, ret, *args, &blk)
+    def self.check_ret_types(slf, method_name, types, inst, matches, ret, bind, *args, &blk)
       $__rdl_contract_switch.off {
-        matches.each { |i| return true if types[i].post_cond?(inst, ret, *args) }
+        matches.each { |i| res,new_ret = types[i].post_cond?(slf, inst, ret, bind, *args)
+          return new_ret if res
+	}
         method_name = method_name ? method_name + ": " : ""
         raise TypeError, <<RUBY
 #{method_name}Return type error. *'s indicate argument lists that matched.
@@ -252,5 +339,47 @@ RUBY
       h = h * 31 + @block.hash if @block
       return h
     end
-end
+
+    def self.check_block_arg_types(slf, types, inst, bind, *args)
+      $__rdl_contract_switch.off {
+	res,args,blk,bind = types.pre_cond?(nil, slf, inst, bind, *args)
+	return [true, args,blk,bind] if res
+        raise TypeError, <<RUBY
+Proc argument type error.
+Proc type:
+#{ [types].map { |t| "        " + t.to_s }.join("\n") }
+Actual argument type#{args.size > 1 ? "s" : ""}:
+        (#{args.map { |arg| RDL::Util.rdl_type_or_class(arg) }.join(', ')})
+Actual argument values (one per line):
+#{ args.map { |arg| "        " + arg.inspect }.join("\n") }
+RUBY
+      }
+    end
+
+    def self.check_block_ret_types(slf, types, inst, ret, bind, *args)
+      $__rdl_contract_switch.off {
+	res,new_ret = types.post_cond?(slf, inst, ret, bind, *args)
+	return new_ret if res
+        raise TypeError, <<RUBY
+Proc return type error.
+Proc type:
+#{[types].each_with_index.map { |t,i| "       " + t.to_s }.join("\n") }
+Actual Proc return type:
+        #{ RDL::Util.rdl_type_or_class(ret)}
+Actual Proc return value:
+        #{ ret.inspect }
+RUBY
+      }
+    end
+
+    def block_wrap(slf, inst, types, bind, &blk)
+      Proc.new {|*v, &other_blk|
+        _, v, other_blk, bind = RDL::Type::MethodType.check_block_arg_types(slf, types, inst, bind, *v)
+        tmp = other_blk ? slf.instance_exec(*v, other_blk, &blk) : slf.instance_exec(*v, &blk)
+	      tmp = RDL::Type::MethodType.check_block_ret_types(slf, types, inst, tmp, bind, *v)
+        tmp
+      }
+    end
+
+  end
 end

data/lib/rdl/types/nominal.rb

@@ -46,7 +46,7 @@ module RDL::Type
     end
 
     def klass
-      @klass = RDL::Util.to_class(name) unless @klass
+      @klass = RDL::Util.to_class(name) unless defined? @klass
       return @klass
     end
 

data/lib/rdl/types/parser.racc

@@ -8,7 +8,7 @@ class Parser
   start entry
 
 token HASH_TYPE HASH_QUERY CONST_BEGIN RASSOC
-token OR FIXNUM FLOAT COLON RARROW DOT DOTS ID SYMBOL SPECIAL_ID STRING
+token OR FIXNUM FLOAT COLON RARROW DOT DOTS ID SYMBOL SPECIAL_ID STRING PREDICATE
 token LPAREN RPAREN LBRACE RBRACE LBRACKET RBRACKET
 token COMMA QUERY STAR LESS GREATER
 token EOF
@@ -33,6 +33,9 @@ rule
    | 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])
       }
+   | LPAREN arg_list RPAREN block RARROW type_expr ID PREDICATE {
+        result = RDL::Type::MethodType.new val[1], val[3], RDL::Type::DependentArgType.new(val[6], val[5], val[7])
+      }
 
   method_sig_list:
      ID COLON method_type { result = [val[0].to_sym, val[2]] }
@@ -52,6 +55,7 @@ rule
       }
   arg:
       base_arg { result = val[0] }
+    | 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:
@@ -119,6 +123,7 @@ rule
       n = RDL::Type::NominalType.new(val[0])
       result = RDL::Type::GenericType.new(n, *val[2])
     }
+    | LBRACE method_type RBRACE { result = val[1] }
     | LBRACKET type_expr_comma_list RBRACKET {
       result = RDL::Type::TupleType.new(*val[1])
     }

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

@@ -1,6 +1,6 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.14
+# This file is automatically generated by Racc 1.4.9
 # from Racc grammer file "".
 #
 
@@ -13,7 +13,7 @@ module RDL::Type
 
 class Parser < Racc::Parser
 
-module_eval(<<'...end parser.racc/module_eval...', 'parser.racc', 147)
+module_eval(<<'...end parser.racc/module_eval...', 'parser.racc', 152)
 
 def initialize()
   @yydebug = true
@@ -23,176 +23,179 @@ end
 ##### State transition tables begin ###
 
 racc_action_table = [
-    20,    55,    18,    19,    71,    21,    28,    30,    13,    15,
-    73,    11,    42,    17,    61,    16,    37,    31,    32,    20,
-    80,    18,    19,     7,    21,    28,    30,    13,    15,    37,
-    11,    85,    17,    88,    16,     7,    31,    32,    20,    91,
-    18,    19,    92,    21,    94,    14,    13,    15,    95,    11,
-    98,    17,    61,    16,    20,    78,    18,    19,     8,    21,
-     7,    14,    13,    15,    34,    11,    36,    17,    20,    16,
-    18,    19,    37,    21,    50,    14,    13,    15,    51,     5,
-     6,    17,    20,    16,    18,    19,    52,    21,    53,    14,
-    13,    15,     7,    54,    58,    17,    20,    16,    18,    19,
-    62,    21,    63,    14,    13,    15,    64,    55,    65,    17,
-    20,    16,    18,    19,    66,    21,    67,    14,    13,    15,
-    68,    11,    69,    17,    20,    16,    18,    19,    70,    21,
-   nil,    14,    13,    15,   nil,    11,   nil,    17,    20,    16,
-    18,    19,   nil,    21,   nil,    38,    13,    15,   nil,    11,
-   nil,    17,    20,    16,    18,    19,   nil,    21,   nil,    14,
-    13,    15,   nil,    11,   nil,    17,    20,    16,    18,    19,
-   nil,    21,   nil,    14,    13,    15,   nil,   nil,   nil,    17,
-    20,    16,    18,    19,   nil,    21,   nil,    14,    13,    15,
-   nil,    11,   nil,    17,    20,    16,    18,    19,   nil,    21,
-   nil,    14,    13,    15,   nil,    11,   nil,    17,    20,    16,
-    18,    19,   nil,    21,   nil,    14,    13,    15,   nil,    11,
-   nil,    17,    20,    16,    18,    19,   nil,    21,   nil,    14,
-    13,    15,   nil,   nil,   nil,    17,    20,    16,    18,    19,
-   nil,    21,   nil,    14,    13,    15,   nil,    11,   nil,    17,
-    46,    16,    44,    45,   nil,   nil,    46,    42,    44,    45,
-    47,   nil,   nil,    42,   nil,   nil,    47 ]
+    20,    69,    18,    19,    56,    21,    28,    30,    13,    15,
+     5,     6,    11,    62,    16,    56,    17,    37,    31,    32,
+    20,    63,    18,    19,     7,    21,    28,    30,    13,    15,
+    64,    37,    11,    65,    16,    66,    17,    67,    31,    32,
+    20,    68,    18,    19,    59,    21,    70,    14,    13,    15,
+    71,    72,    11,    73,    16,    75,    17,    20,    81,    18,
+    19,    55,    21,    78,    14,    13,    15,    20,    38,    18,
+    19,    16,    21,    17,    14,    13,    15,    54,    83,    11,
+    53,    16,    20,    17,    18,    19,    52,    21,    86,    14,
+    13,    15,    51,    37,    11,     7,    16,    20,    17,    18,
+    19,    36,    21,    91,    14,    13,    15,     7,    34,    11,
+    94,    16,    20,    17,    18,    19,    95,    21,     7,    14,
+    13,    15,    97,     8,    11,    99,    16,    20,    17,    18,
+    19,   101,    21,    69,    14,    13,    15,   102,   nil,    11,
+   nil,    16,    20,    17,    18,    19,   nil,    21,   nil,    14,
+    13,    15,   nil,   nil,    11,   nil,    16,    20,    17,    18,
+    19,   nil,    21,   nil,    14,    13,    15,    20,   nil,    18,
+    19,    16,    21,    17,    14,    13,    15,    20,   nil,    18,
+    19,    16,    21,    17,    14,    13,    15,    20,   nil,    18,
+    19,    16,    21,    17,    14,    13,    15,   nil,   nil,    11,
+   nil,    16,    20,    17,    18,    19,   nil,    21,   nil,    14,
+    13,    15,    20,   nil,    18,    19,    16,    21,    17,    14,
+    13,    15,   nil,   nil,    11,   nil,    16,    20,    17,    18,
+    19,   nil,    21,   nil,    47,    13,    15,   nil,   nil,    11,
+   nil,    16,    42,    17,    40,    41,   nil,   nil,    42,    38,
+    40,    41,    43,   nil,     7,    38,   nil,   nil,    43 ]
 
 racc_action_check = [
-     7,    30,     7,     7,    50,     7,     7,     7,     7,     7,
-    51,     7,    54,     7,    38,     7,    30,     7,     7,    52,
-    60,    52,    52,    61,    52,    52,    52,    52,    52,    38,
-    52,    67,    52,    72,    52,    73,    52,    52,    55,    81,
-    55,    55,    85,    55,    89,    55,    55,    55,    91,    55,
-    93,    55,    95,    55,    62,    55,    62,    62,     1,    62,
-     6,    62,    62,    62,     8,    62,    12,    62,    65,    62,
-    65,    65,    14,    65,    20,    65,    65,    65,    23,     0,
-     0,    65,    66,    65,    66,    66,    26,    66,    27,    66,
-    66,    66,     0,    29,    35,    66,    68,    66,    68,    68,
-    39,    68,    40,    68,    68,    68,    41,    42,    44,    68,
-    31,    68,    31,    31,    45,    31,    46,    31,    31,    31,
-    47,    31,    48,    31,     5,    31,     5,     5,    49,     5,
-   nil,     5,     5,     5,   nil,     5,   nil,     5,    16,     5,
-    16,    16,   nil,    16,   nil,    16,    16,    16,   nil,    16,
-   nil,    16,    37,    16,    37,    37,   nil,    37,   nil,    37,
-    37,    37,   nil,    37,   nil,    37,    92,    37,    92,    92,
-   nil,    92,   nil,    92,    92,    92,   nil,   nil,   nil,    92,
-    32,    92,    32,    32,   nil,    32,   nil,    32,    32,    32,
-   nil,    32,   nil,    32,    78,    32,    78,    78,   nil,    78,
-   nil,    78,    78,    78,   nil,    78,   nil,    78,    11,    78,
-    11,    11,   nil,    11,   nil,    11,    11,    11,   nil,    11,
-   nil,    11,    36,    11,    36,    36,   nil,    36,   nil,    36,
-    36,    36,   nil,   nil,   nil,    36,    88,    36,    88,    88,
-   nil,    88,   nil,    88,    88,    88,   nil,    88,   nil,    88,
-    69,    88,    69,    69,   nil,   nil,    17,    69,    17,    17,
-    69,   nil,   nil,    17,   nil,   nil,    17 ]
+     7,    47,     7,     7,    38,     7,     7,     7,     7,     7,
+     0,     0,     7,    40,     7,    30,     7,    47,     7,     7,
+    53,    41,    53,    53,     0,    53,    53,    53,    53,    53,
+    42,    30,    53,    43,    53,    44,    53,    45,    53,    53,
+    56,    46,    56,    56,    35,    56,    48,    56,    56,    56,
+    49,    50,    56,    51,    56,    52,    56,    36,    56,    36,
+    36,    29,    36,    54,    36,    36,    36,    81,    55,    81,
+    81,    36,    81,    36,    81,    81,    81,    27,    61,    81,
+    26,    81,    11,    81,    11,    11,    23,    11,    64,    11,
+    11,    11,    20,    14,    11,    69,    11,    70,    11,    70,
+    70,    12,    70,    74,    70,    70,    70,    75,     8,    70,
+    86,    70,    37,    70,    37,    37,    89,    37,     6,    37,
+    37,    37,    92,     1,    37,    95,    37,    91,    37,    91,
+    91,    96,    91,    99,    91,    91,    91,   101,   nil,    91,
+   nil,    91,    32,    91,    32,    32,   nil,    32,   nil,    32,
+    32,    32,   nil,   nil,    32,   nil,    32,    65,    32,    65,
+    65,   nil,    65,   nil,    65,    65,    65,    63,   nil,    63,
+    63,    65,    63,    65,    63,    63,    63,    62,   nil,    62,
+    62,    63,    62,    63,    62,    62,    62,     5,   nil,     5,
+     5,    62,     5,    62,     5,     5,     5,   nil,   nil,     5,
+   nil,     5,    94,     5,    94,    94,   nil,    94,   nil,    94,
+    94,    94,    31,   nil,    31,    31,    94,    31,    94,    31,
+    31,    31,   nil,   nil,    31,   nil,    31,    17,    31,    17,
+    17,   nil,    17,   nil,    17,    17,    17,   nil,   nil,    17,
+   nil,    17,    16,    17,    16,    16,   nil,   nil,    66,    16,
+    66,    66,    16,   nil,    16,    66,   nil,   nil,    66 ]
 
 racc_action_pointer = [
-    74,    58,   nil,   nil,   nil,   117,    42,    -7,    64,   nil,
-   nil,   201,    62,   nil,    46,   nil,   131,   249,   nil,   nil,
-    60,   nil,   nil,    59,   nil,   nil,    84,    74,   nil,    91,
-   -10,   103,   173,   nil,   nil,    75,   215,   145,     3,    98,
-    79,    83,    96,   nil,   100,   106,   102,   112,   120,   107,
-   -17,   -10,    12,   nil,    -2,    31,   nil,   nil,   nil,   nil,
-    -7,     5,    47,   nil,   nil,    61,    75,    10,    89,   243,
-   nil,   nil,    30,    17,   nil,   nil,   nil,   nil,   187,   nil,
-   nil,    37,   nil,   nil,   nil,    34,   nil,   nil,   229,    23,
-   nil,    34,   159,    36,   nil,    41,   nil,   nil,   nil ]
+     5,   123,   nil,   nil,   nil,   180,    99,    -7,   108,   nil,
+   nil,    75,    97,   nil,    66,   nil,   235,   220,   nil,   nil,
+    78,   nil,   nil,    66,   nil,   nil,    78,    63,   nil,    59,
+     4,   205,   135,   nil,   nil,    24,    50,   105,    -7,   nil,
+     5,    13,    16,    25,    33,    15,    19,   -10,    44,    26,
+    27,    31,    34,    13,    45,    54,    33,   nil,   nil,   nil,
+   nil,    50,   170,   160,    66,   150,   241,   nil,   nil,    76,
+    90,   nil,   nil,   nil,   100,    88,   nil,   nil,   nil,   nil,
+   nil,    60,   nil,   nil,   nil,   nil,   102,   nil,   nil,   114,
+   nil,   120,   100,   nil,   195,   111,   117,   nil,   nil,   122,
+   nil,   119,   nil ]
 
 racc_action_default = [
-   -54,   -54,    -1,    -2,    -3,   -54,   -54,   -10,   -54,    -4,
-   -29,   -54,   -41,   -43,   -44,   -45,   -54,   -33,   -50,   -51,
-   -54,   -53,    -5,   -54,   -11,   -12,   -13,   -16,   -18,   -19,
-   -44,   -54,   -54,   -24,    99,   -54,   -54,   -54,   -44,   -31,
-   -54,   -54,   -54,   -34,   -54,   -54,   -54,   -54,   -39,   -54,
-   -54,   -27,   -54,   -17,   -54,   -54,   -22,   -23,   -30,   -42,
-   -54,   -54,   -54,   -47,   -48,   -54,   -54,   -54,   -54,   -33,
-   -49,   -52,   -54,   -54,   -14,   -15,   -20,   -21,   -54,   -26,
-   -46,    -8,   -32,   -35,   -36,   -54,   -38,   -40,   -54,   -54,
-   -25,   -54,   -54,    -6,   -28,   -54,    -9,   -37,    -7 ]
+   -57,   -57,    -1,    -2,    -3,   -57,   -57,   -11,   -57,    -4,
+   -31,   -57,   -43,   -45,   -46,   -47,   -35,   -57,   -53,   -54,
+   -57,   -56,    -5,   -57,   -12,   -13,   -14,   -17,   -20,   -21,
+   -46,   -57,   -57,   -26,   103,   -57,   -57,   -57,   -57,   -36,
+   -57,   -57,   -57,   -57,   -41,   -57,   -57,   -46,   -33,   -57,
+   -57,   -57,   -29,   -57,   -19,   -57,   -57,   -24,   -25,   -32,
+   -44,   -57,   -57,   -57,   -57,   -57,   -35,   -49,   -52,   -57,
+   -57,   -50,   -51,   -55,   -57,   -57,   -15,   -16,   -18,   -22,
+   -23,   -57,   -28,   -48,   -37,   -38,   -57,   -40,   -42,    -9,
+   -34,   -57,   -57,   -27,   -57,   -57,    -6,   -30,   -39,   -57,
+   -10,    -7,    -8 ]
 
 racc_goto_table = [
-     9,    41,    33,    59,     2,    49,    35,    25,    43,    40,
-    22,    24,    77,     3,    72,    23,     4,     1,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,    56,    57,   nil,   nil,
-    60,   nil,    83,    84,   nil,    86,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,    33,   nil,   nil,
-    79,   nil,    75,   nil,    76,    82,    74,    87,   nil,    97,
-    43,   nil,   nil,   nil,   nil,    81,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,    90,   nil,   nil,    96,    89,   nil,   nil,
-   nil,   nil,   nil,    93 ]
+     9,    50,    33,     2,    60,    49,    35,    39,    25,    22,
+    46,    80,    23,    24,    74,     4,     3,     1,   nil,    45,
+   nil,   nil,   nil,   nil,   nil,    61,    57,    58,   nil,   nil,
+    84,    85,   nil,    87,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    33,   nil,
+   nil,    82,   nil,   nil,    77,   nil,    79,    39,    90,    76,
+    88,   nil,    98,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    89,   nil,   nil,   nil,    93,   nil,    92,   100,
+   nil,   nil,   nil,   nil,   nil,   nil,    96 ]
 
 racc_goto_check = [
-     5,     8,     5,    15,     2,    18,     5,    10,    13,    16,
-     2,     9,    14,     3,     7,     6,     4,     1,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,     5,     5,   nil,   nil,
-    16,   nil,    15,    15,   nil,    15,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,     5,   nil,   nil,
-     5,   nil,    10,   nil,    10,    16,     9,    18,   nil,    15,
-    13,   nil,   nil,   nil,   nil,     2,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,     5,   nil,   nil,     8,     2,   nil,   nil,
-   nil,   nil,   nil,     5 ]
+     5,     8,     5,     2,    15,    16,     5,    13,    10,     2,
+    18,    14,     6,     9,     7,     4,     3,     1,   nil,     2,
+   nil,   nil,   nil,   nil,   nil,    16,     5,     5,   nil,   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,    15,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,     2,   nil,   nil,   nil,     5,   nil,     2,     8,
+   nil,   nil,   nil,   nil,   nil,   nil,     5 ]
 
 racc_goto_pointer = [
-   nil,    17,     4,    13,    16,    -5,     8,   -37,   -15,     4,
-     0,   nil,   nil,    -9,   -43,   -33,    -7,   nil,   -12,   nil ]
+   nil,    17,     3,    16,    15,    -5,     5,   -38,   -16,     6,
+     1,   nil,   nil,    -9,   -45,   -32,   -12,   nil,    -6,   nil ]
 
 racc_goto_default = [
-   nil,   nil,   nil,   nil,   nil,    39,   nil,   nil,   nil,   nil,
-   nil,    26,    27,    29,   nil,    10,   nil,    48,   nil,    12 ]
+   nil,   nil,   nil,   nil,   nil,    48,   nil,   nil,   nil,   nil,
+   nil,    26,    27,    29,   nil,    10,   nil,    44,   nil,    12 ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
-  1, 30, :_reduce_1,
-  1, 30, :_reduce_2,
-  1, 30, :_reduce_3,
-  2, 32, :_reduce_4,
-  2, 33, :_reduce_5,
-  6, 31, :_reduce_6,
-  7, 31, :_reduce_7,
-  3, 37, :_reduce_8,
-  5, 37, :_reduce_9,
-  0, 35, :_reduce_10,
-  1, 35, :_reduce_11,
-  1, 35, :_reduce_12,
-  1, 38, :_reduce_13,
-  3, 38, :_reduce_14,
-  3, 38, :_reduce_15,
-  1, 40, :_reduce_16,
-  2, 40, :_reduce_17,
-  1, 40, :_reduce_18,
-  1, 39, :_reduce_19,
-  3, 39, :_reduce_20,
-  3, 42, :_reduce_21,
-  2, 41, :_reduce_22,
-  2, 41, :_reduce_23,
-  1, 41, :_reduce_24,
-  2, 43, :_reduce_25,
-  1, 43, :_reduce_26,
-  0, 36, :_reduce_27,
-  3, 36, :_reduce_28,
-  1, 34, :_reduce_29,
-  3, 34, :_reduce_30,
-  1, 45, :_reduce_31,
-  3, 45, :_reduce_32,
-  0, 46, :_reduce_none,
-  1, 46, :_reduce_34,
-  3, 46, :_reduce_35,
-  3, 46, :_reduce_36,
-  5, 46, :_reduce_37,
-  3, 46, :_reduce_38,
-  1, 47, :_reduce_39,
+  1, 31, :_reduce_1,
+  1, 31, :_reduce_2,
+  1, 31, :_reduce_3,
+  2, 33, :_reduce_4,
+  2, 34, :_reduce_5,
+  6, 32, :_reduce_6,
+  7, 32, :_reduce_7,
+  8, 32, :_reduce_8,
+  3, 38, :_reduce_9,
+  5, 38, :_reduce_10,
+  0, 36, :_reduce_11,
+  1, 36, :_reduce_12,
+  1, 36, :_reduce_13,
+  1, 39, :_reduce_14,
+  3, 39, :_reduce_15,
+  3, 39, :_reduce_16,
+  1, 41, :_reduce_17,
+  3, 41, :_reduce_18,
+  2, 41, :_reduce_19,
+  1, 41, :_reduce_20,
+  1, 40, :_reduce_21,
+  3, 40, :_reduce_22,
+  3, 43, :_reduce_23,
+  2, 42, :_reduce_24,
+  2, 42, :_reduce_25,
+  1, 42, :_reduce_26,
+  2, 44, :_reduce_27,
+  1, 44, :_reduce_28,
+  0, 37, :_reduce_29,
+  3, 37, :_reduce_30,
+  1, 35, :_reduce_31,
+  3, 35, :_reduce_32,
+  1, 46, :_reduce_33,
+  3, 46, :_reduce_34,
+  0, 47, :_reduce_none,
+  1, 47, :_reduce_36,
+  3, 47, :_reduce_37,
+  3, 47, :_reduce_38,
+  5, 47, :_reduce_39,
   3, 47, :_reduce_40,
-  1, 44, :_reduce_41,
-  3, 44, :_reduce_42,
-  1, 48, :_reduce_43,
-  1, 48, :_reduce_44,
-  1, 48, :_reduce_45,
-  4, 48, :_reduce_46,
-  3, 48, :_reduce_47,
-  3, 48, :_reduce_48,
-  3, 48, :_reduce_49,
-  1, 48, :_reduce_50,
-  1, 48, :_reduce_51,
-  3, 48, :_reduce_52,
-  1, 48, :_reduce_53 ]
-
-racc_reduce_n = 54
-
-racc_shift_n = 99
+  1, 48, :_reduce_41,
+  3, 48, :_reduce_42,
+  1, 45, :_reduce_43,
+  3, 45, :_reduce_44,
+  1, 49, :_reduce_45,
+  1, 49, :_reduce_46,
+  1, 49, :_reduce_47,
+  4, 49, :_reduce_48,
+  3, 49, :_reduce_49,
+  3, 49, :_reduce_50,
+  3, 49, :_reduce_51,
+  3, 49, :_reduce_52,
+  1, 49, :_reduce_53,
+  1, 49, :_reduce_54,
+  3, 49, :_reduce_55,
+  1, 49, :_reduce_56 ]
+
+racc_reduce_n = 57
+
+racc_shift_n = 103
 
 racc_token_table = {
   false => 0,
@@ -213,19 +216,20 @@ racc_token_table = {
   :SYMBOL => 15,
   :SPECIAL_ID => 16,
   :STRING => 17,
-  :LPAREN => 18,
-  :RPAREN => 19,
-  :LBRACE => 20,
-  :RBRACE => 21,
-  :LBRACKET => 22,
-  :RBRACKET => 23,
-  :QUERY => 24,
-  :STAR => 25,
-  :LESS => 26,
-  :GREATER => 27,
-  :EOF => 28 }
-
-racc_nt_base = 29
+  :PREDICATE => 18,
+  :LPAREN => 19,
+  :RPAREN => 20,
+  :LBRACE => 21,
+  :RBRACE => 22,
+  :LBRACKET => 23,
+  :RBRACKET => 24,
+  :QUERY => 25,
+  :STAR => 26,
+  :LESS => 27,
+  :GREATER => 28,
+  :EOF => 29 }
+
+racc_nt_base = 30
 
 racc_use_result_var = true
 
@@ -264,6 +268,7 @@ Racc_token_to_s_table = [
   "SYMBOL",
   "SPECIAL_ID",
   "STRING",
+  "PREDICATE",
   "LPAREN",
   "RPAREN",
   "LBRACE",
@@ -353,136 +358,137 @@ module_eval(<<'.,.,', 'parser.racc', 33)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 37)
+module_eval(<<'.,.,', 'parser.racc', 36)
   def _reduce_8(val, _values, result)
-     result = [val[0].to_sym, val[2]] 
+            result = RDL::Type::MethodType.new val[1], val[3], RDL::Type::DependentArgType.new(val[6], val[5], val[7])
+      
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 38)
+module_eval(<<'.,.,', 'parser.racc', 40)
   def _reduce_9(val, _values, result)
-     result = [val[0].to_sym, val[2]] + val[4] 
+     result = [val[0].to_sym, val[2]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 41)
   def _reduce_10(val, _values, result)
-     result = [] 
+     result = [val[0].to_sym, val[2]] + val[4] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 42)
+module_eval(<<'.,.,', 'parser.racc', 44)
   def _reduce_11(val, _values, result)
-     result = val[0] 
+     result = [] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 44)
+module_eval(<<'.,.,', 'parser.racc', 45)
   def _reduce_12(val, _values, result)
-          result = [RDL::Type::FiniteHashType.new(Hash[*val[0]])]
-      
+     result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 47)
   def _reduce_13(val, _values, result)
-     result = [val[0]] 
+          result = [RDL::Type::FiniteHashType.new(Hash[*val[0]])]
+      
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 48)
+module_eval(<<'.,.,', 'parser.racc', 50)
   def _reduce_14(val, _values, result)
-     result = val[2].unshift val[0] 
+     result = [val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 49)
+module_eval(<<'.,.,', 'parser.racc', 51)
   def _reduce_15(val, _values, result)
-     # named arg list must come last
-      result = [val[0], RDL::Type::FiniteHashType.new(Hash[*val[2]])]
-      
+     result = val[2].unshift val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 53)
+module_eval(<<'.,.,', 'parser.racc', 52)
   def _reduce_16(val, _values, result)
-     result = val[0] 
+     # named arg list must come last
+      result = [val[0], RDL::Type::FiniteHashType.new(Hash[*val[2]])]
+      
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 54)
+module_eval(<<'.,.,', 'parser.racc', 56)
   def _reduce_17(val, _values, result)
-     result = RDL::Type::AnnotatedArgType.new(val[1], val[0]) 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 55)
+module_eval(<<'.,.,', 'parser.racc', 57)
   def _reduce_18(val, _values, result)
-     result = RDL::Type::DotsQuery.new 
+    result = RDL::Type::DependentArgType.new(val[1], val[0], val[2])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 57)
+module_eval(<<'.,.,', 'parser.racc', 58)
   def _reduce_19(val, _values, result)
-     result = val[0] 
+     result = RDL::Type::AnnotatedArgType.new(val[1], val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 58)
+module_eval(<<'.,.,', 'parser.racc', 59)
   def _reduce_20(val, _values, result)
-     result = val[0] + val[2] 
+     result = RDL::Type::DotsQuery.new 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 60)
+module_eval(<<'.,.,', 'parser.racc', 61)
   def _reduce_21(val, _values, result)
-     result = [val[0].to_sym, val[2]] 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 63)
+module_eval(<<'.,.,', 'parser.racc', 62)
   def _reduce_22(val, _values, result)
-     result = RDL::Type::OptionalType.new val[1] 
+     result = val[0] + val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 64)
   def _reduce_23(val, _values, result)
-     result = RDL::Type::VarargType.new val[1] 
+     result = [val[0].to_sym, val[2]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 65)
+module_eval(<<'.,.,', 'parser.racc', 67)
   def _reduce_24(val, _values, result)
-     result = val[0] 
+     result = RDL::Type::OptionalType.new val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 67)
+module_eval(<<'.,.,', 'parser.racc', 68)
   def _reduce_25(val, _values, result)
-     result = RDL::Type::OptionalType.new val[1] 
+     result = RDL::Type::VarargType.new val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 68)
+module_eval(<<'.,.,', 'parser.racc', 69)
   def _reduce_26(val, _values, result)
      result = val[0] 
     result
@@ -491,21 +497,21 @@ module_eval(<<'.,.,', 'parser.racc', 68)
 
 module_eval(<<'.,.,', 'parser.racc', 71)
   def _reduce_27(val, _values, result)
-     result = nil 
+     result = RDL::Type::OptionalType.new val[1] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 72)
   def _reduce_28(val, _values, result)
-     result = val[1] 
+     result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 75)
   def _reduce_29(val, _values, result)
-     result = val[0] 
+     result = nil 
     result
   end
 .,.,
@@ -519,66 +525,66 @@ module_eval(<<'.,.,', 'parser.racc', 76)
 
 module_eval(<<'.,.,', 'parser.racc', 79)
   def _reduce_31(val, _values, result)
-     result = [val[0]] 
+     result = val[0] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 80)
   def _reduce_32(val, _values, result)
-     result = [val[0]] + val[2] 
+     result = val[1] 
     result
   end
 .,.,
 
-# reduce 33 omitted
-
 module_eval(<<'.,.,', 'parser.racc', 83)
-  def _reduce_34(val, _values, result)
-     result = val[0] 
+  def _reduce_33(val, _values, result)
+     result = [val[0]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 84)
-  def _reduce_35(val, _values, result)
-     result = [val[0].to_i, val[2]] 
+  def _reduce_34(val, _values, result)
+     result = [val[0]] + val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 85)
+# reduce 35 omitted
+
+module_eval(<<'.,.,', 'parser.racc', 87)
   def _reduce_36(val, _values, result)
-     result = [val[0].to_f, val[2]] 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 87)
+module_eval(<<'.,.,', 'parser.racc', 88)
   def _reduce_37(val, _values, result)
-        result = [Kernel.const_get(val[0]), val[2]]
-  
+     result = [val[0].to_i, val[2]] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 89)
   def _reduce_38(val, _values, result)
-     result = [val[0], val[2]] 
+     result = [val[0].to_f, val[2]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 92)
+module_eval(<<'.,.,', 'parser.racc', 91)
   def _reduce_39(val, _values, result)
-     result = val[0] 
+        result = [Kernel.const_get(val[0]), val[2]]
+  
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 93)
   def _reduce_40(val, _values, result)
-     result = val[0] + val[2] 
+     result = [val[0], val[2]] 
     result
   end
 .,.,
@@ -592,20 +598,34 @@ module_eval(<<'.,.,', 'parser.racc', 96)
 
 module_eval(<<'.,.,', 'parser.racc', 97)
   def _reduce_42(val, _values, result)
-     result = RDL::Type::UnionType.new val[0], val[2] 
+     result = val[0] + val[2] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 100)
   def _reduce_43(val, _values, result)
-     result = RDL::Type::SingletonType.new(val[0].to_sym) 
+     result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 102)
+module_eval(<<'.,.,', 'parser.racc', 101)
   def _reduce_44(val, _values, result)
+     result = RDL::Type::UnionType.new val[0], val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 104)
+  def _reduce_45(val, _values, result)
+     result = RDL::Type::SingletonType.new(val[0].to_sym) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 106)
+  def _reduce_46(val, _values, result)
           if val[0] == 'nil' then
         result = RDL::Type::NilType.new
       elsif val[0] =~ /^[a-z_]+\w*\'?/ then
@@ -618,8 +638,8 @@ module_eval(<<'.,.,', 'parser.racc', 102)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 111)
-  def _reduce_45(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 115)
+  def _reduce_47(val, _values, result)
           if $__rdl_special_types.has_key? val[0] then
         result = $__rdl_special_types[val[0]]
       else
@@ -630,8 +650,8 @@ module_eval(<<'.,.,', 'parser.racc', 111)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 118)
-  def _reduce_46(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 122)
+  def _reduce_48(val, _values, result)
           n = RDL::Type::NominalType.new(val[0])
       result = RDL::Type::GenericType.new(n, *val[2])
     
@@ -639,54 +659,61 @@ module_eval(<<'.,.,', 'parser.racc', 118)
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 122)
-  def _reduce_47(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 125)
+  def _reduce_49(val, _values, result)
+     result = val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 127)
+  def _reduce_50(val, _values, result)
           result = RDL::Type::TupleType.new(*val[1])
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 125)
-  def _reduce_48(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 130)
+  def _reduce_51(val, _values, result)
           result = RDL::Type::StructuralType.new(Hash[*val[1]])
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 128)
-  def _reduce_49(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 133)
+  def _reduce_52(val, _values, result)
           result = RDL::Type::FiniteHashType.new(Hash[*val[1]])
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 130)
-  def _reduce_50(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 135)
+  def _reduce_53(val, _values, result)
      result = RDL::Type::SingletonType.new(val[0].to_i) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 131)
-  def _reduce_51(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 136)
+  def _reduce_54(val, _values, result)
      result = RDL::Type::SingletonType.new(val[0].to_f) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 133)
-  def _reduce_52(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 138)
+  def _reduce_55(val, _values, result)
           result =  RDL::Type::SingletonType.new(Kernel.const_get(val[1]))
     
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.racc', 137)
-  def _reduce_53(val, _values, result)
+module_eval(<<'.,.,', 'parser.racc', 142)
+  def _reduce_56(val, _values, result)
      result = RDL::Type::WildQuery.new 
     result
   end