rsec 0.3.2

data/examples/c_minus.rb

@@ -0,0 +1,175 @@
+$:.unshift '../lib'
+$:.unshift '../ext'
+require "rsec"
+require "pp"
+
+module FixPP
+  def pretty_print(q)
+    q.group(1, sprintf("<%s", self.class.name[/\w+$/]), '>') {
+      q.seplist(self.members, ->{}) {|member|
+        q.breakable
+        q.text member.to_s
+        q.text '='
+        q.group(1) {
+          q.breakable ''
+          q.pp self[member]
+        }
+      }
+    }
+  end
+end
+
+class CMinus
+  include Rsec::Helpers
+  extend Rsec::Helpers
+
+  # node decls
+  
+  class Function < Struct.new :type, :id, :params, :body
+    include FixPP
+  end
+
+  class Expr < Struct.new :expr
+    include FixPP
+  end
+
+  class Block < Struct.new :var_decls, :statements
+    include FixPP
+  end
+
+  class Call < Struct.new :function, :args
+    include FixPP
+  end
+
+  class GetIndex < Struct.new :id, :idx
+    include FixPP
+  end
+  
+  # "terminal" rules
+  
+  NUM       = prim :unsigned_int64
+  INT       = prim :int64
+  NBSP      = /[\ \t]*/.r
+  SPACE     = /\s*/.r
+  ID        = /[a-zA-Z]\w*/.r 'id'
+  TYPE      = (word('int') | word('void')).fail 'type'
+  EOSTMT    = ';'.r 'end of statement'
+  ELSE      = word('else').fail 'keyword_else'
+  IF        = word('if').fail 'keyword_if'
+  WHILE     = word('while').fail 'keyword_while'
+  RETURN    = word('return').fail 'keyword_return'
+  MUL_OP    = symbol(/[\*\/%]/)
+  ADD_OP    = symbol(/[\+\-]/)
+  COMP_OP   = symbol(/(\<=|\<|\>|\>=|==|!=)/).fail 'compare operator'
+  COMMA     = /\s*,\s*/.r 'comma'
+  EMPTY_BRA = /\[\s*\]/.r 'empty square bracket'
+
+  # call(function apply) expression
+  def call expr
+    args = expr.join(COMMA).even
+    seq_(ID, '(', args._?, ')') {
+      |(id, _, args, _)|
+      Call[id, *args]
+    }
+  end
+
+  # (binary) expression
+  def expression
+    binary_arithmetic = lazy{factor}
+      .join(MUL_OP).unbox
+      .join(ADD_OP).unbox
+      .join(COMP_OP).unbox
+    expr = lazy{assign} | binary_arithmetic
+    # abc
+    # abc[12]
+    var = seq_(ID, seq_('[', expr, ']')[1]._?) {
+      |(id, (index))|
+      index ? GetIndex[id, index] : id
+    }
+    assign = seq_(var, '=', expr)
+    factor = seq_('(', expr, ')')[1] | call(expr) | var | INT
+    # p expr.parse! "gcd (v ,u- u/v *v)"
+    expr.map{|e| Expr[e] }
+  end
+    
+  # statement parser builder, returns [stmt, block]
+  def statement var_decl
+    expr = expression()
+    brace = seq_('(', expr, ')')[1]
+    # statement
+    _stmt = lazy{stmt} # to reduce the use of lazy{}
+    
+    expr_stmt = seq_(expr, EOSTMT)[0] | EOSTMT
+    else_stmt = seq_(ELSE, _stmt)[1]
+    if_stmt = seq_(IF, brace, _stmt, else_stmt._?)
+    while_stmt = seq_(WHILE, brace, _stmt)
+    return_stmt = seq_(RETURN, expr._?, EOSTMT){
+      |(ret, maybe_expr)|
+      [ret, *maybe_expr]
+    }
+    # { var_decls statements }
+    block = seq('{', SPACE.join(var_decl).odd, SPACE.join(_stmt).odd, '}'){
+      |(_, vars, stats, _)|
+      Block[vars, stats]
+    }
+    stmt = block | if_stmt | while_stmt | return_stmt | expr_stmt
+    # p if_stmt.parse! 'if(v == 0)return u;'
+    [stmt, block]
+  end
+  
+  def initialize
+    type_id = seq_(TYPE, ID).cached
+    # p type_id.parse! 'int a'
+    
+    var_decl = seq_(type_id, seq_('[', NUM, ']')[1]._?, EOSTMT){
+      |(id, maybe_num)|
+      [id, *maybe_num]
+    }
+    # p var_decl.parse! 'int a[12];'
+    # p var_decl.parse! 'int a;'
+
+    stmt, block = statement(var_decl)
+    # p block.parse! "{int a;}"
+    # p stmt.parse! 'if(3==2) {return 4;}'
+    
+    param = seq_(type_id, EMPTY_BRA._?) {
+      |((ty, id), maybe_bra)|
+      [ty, id, *maybe_bra]
+    }
+    params = param.join(COMMA).even | 'void'.r{[]}
+    brace = seq_('(', params, ')')[1]
+    fun_decl = seq_(type_id, brace, block){
+      |(type, id), params, block|
+      Function[type, id, params, block]
+    }
+    # p fun_decl.parse! 'int gcd(int u, int v){return 2;}'
+    @program = SPACE.join(fun_decl | var_decl | EOSTMT).odd.eof
+  end
+  
+  attr_reader :program
+end
+
+if __FILE__ == $PROGRAM_NAME
+  c_minus = CMinus.new
+  nodes = c_minus.program.parse! %Q[
+    int gcd(int u, int v)
+    {
+      if (v == 0) return u;
+      else return gcd(v,u-u / v*v);
+    }
+
+    void main(void)
+    {
+      int x; int y;
+      while (1) {
+        x = input();
+        y = input();
+        output(gcd(x ,y)) ;
+      }
+    }
+  ]
+  nodes.each do |node|
+    pp node
+  end
+end
+

data/examples/hello.scm

@@ -0,0 +1,18 @@
+(display 4)
+
+(define (fact x)
+  (if (= x 0)
+      1
+      (* x (fact (- x 1)))))
+ 
+(display (fact 6))
+ 
+(define (add x)
+  (lambda (y)
+    (+ x y)))
+ 
+(define add4 (add 4))
+(define add5 (add 5))
+ 
+(display (add4 3))
+(display (add5 3))

data/examples/s_exp.rb

@@ -0,0 +1,17 @@
+# s-expression parser
+
+require "rsec"
+
+include Rsec::Helpers
+
+def s_exp
+  id    = /[a-zA-Z][\w\-]*/.r.fail 'id'
+  num   = prim(:double).fail 'num'
+
+  naked_unit = id | num | seq_('(', lazy{exp}, ')')[1]
+  unit  = naked_unit | seq_('(', lazy{unit}, ')')[1]
+  units = unit.join(/\s+/).even._?
+  exp   = seq_(id, units) {|(id, (units))| [id, *units]}
+  seq_('(', exp, ')')[1].eof
+end
+

data/examples/scheme.rb

@@ -0,0 +1,84 @@
+# A simple-as-shit scheme interpreter. Usage: ruby scheme.rb hello.scm
+require "rsec"
+
+class Scheme
+  include Rsec::Helpers
+
+  Value = Struct.new :val
+
+  class Bind < Hash
+    def initialize parent = {}
+      @parent = parent
+    end
+
+    def define id, &p # define lambda
+      self[id] = -> bind, xs {
+        p[* xs.map{|x| bind.eval x }]
+      }
+    end
+
+    def eval node
+      case node
+      when Value;  node.val
+      when String; self[node]
+      when Array
+        head, *tail = node
+        case head
+        when String
+          pr = self[head]
+          pr.is_a?(Proc) ? pr[self, tail] : pr # invoke lambda
+        when Array
+          node.map{|n| self.eval n }.last # sequence execution
+        end
+      end
+    end
+
+    def [] key
+      super(key) || @parent[key]
+    end
+  end
+
+  def initialize
+    boolean = /\#[tf]/.    r {|n| Value[n=='#t'] }
+    integer = /0|[1-9]\d*/.r {|n| Value[n.to_i]  }
+    id      = /[^\s\(\)\[\]]+/.r
+    atom    = boolean | integer | id
+    cell    = atom | lazy{list}
+    cells   = /\s*/.r.join(cell).odd
+    list    = '('.r >> cells << ')'
+    @parser = cells.eof
+
+    @vm = Bind.new
+    @vm['define'] = -> bind, (param, body) {
+      if param.is_a?(String)
+        @vm[param] = bind.eval body
+      else
+        func, *xs = param
+        @vm[func] = @vm['lambda'][bind, [xs, body]]
+      end
+    }
+    # declare: (lambda (xs[0] xs[1]) body)
+    @vm['lambda'] = -> bind_def, (xs, body) {
+      xs = [xs] if xs.is_a?(String)
+      # calling: (some vs[0] vs[1])
+      -> bind_call, vs {
+        vs = vs.map{|v| bind_call.eval v }
+        new_bind = Bind.new bind_def
+        xs.zip(vs){|x, v| new_bind[x] = v }
+        new_bind.eval body
+      }
+    }
+    @vm['if'] = -> bind, (p, left, right) {
+      bind.eval(bind.eval(p) ? left : right)
+    }
+    %w|+ - * / ** % > <|.each{|s| @vm.define s, &s.to_sym }
+    @vm.define '=', &:==
+    @vm.define('display'){|x| puts x}
+  end
+
+  def run source
+    @vm.eval @parser.parse! source
+  end
+end
+
+ARGV[0] ? Scheme.new.run(File.read ARGV[0]) : puts('need a scheme file name')

data/examples/slow_json.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+
+# grammar from
+#   http://www.json.org/
+
+require "rsec"
+
+class SlowJSON
+
+  include Rsec::Helper
+
+  def initialize
+    generate_parser
+    @parser = seq(/\s*/, @value, /\s*/)[1].eof
+  end
+
+  def parse s
+    @parser.parse! s
+  end
+
+  private
+
+  # term (, term)*
+  def elem_parser term
+    term.join(/\s*,\s*/.r).even
+  end
+
+  def chars_parser
+    unicode_bytes = /[0-9a-f]{4}/i.r{|bytes|
+      [bytes].pack('H*').force_encoding('utf-16be').encode!('utf-8')
+    }
+    escape_char = '"'.r | "\\" | '/' |
+                  'b'.r{"\b"} |
+                  'f'.r{"\f"} |
+                  'n'.r{"\n"} |
+                  'r'.r{"\r"} |
+                  't'.r{"\t"} |
+                  seq('u'.r, unicode_bytes)[1]
+    /[^"\\]+/.r | seq('\\', escape_char)[1]
+  end
+
+  def generate_parser
+    string  = '"'.r >> chars_parser.star.map(&:join) << '"'
+    # -? int frac? exp?
+    number  = prim(:double, allowed_sign: '-')
+    @value  = string | number | lazy{@object} | lazy{@array} |
+              'true'.r{true} |
+              'false'.r{false} |
+              'null'.r{nil}
+    pair    = seq(string, /\s*:\s*/.r, @value){|k, _, v| [k, v]}
+    @array  = /\[\s*\]/.r{[]} | '['.r >> elem_parser(@value) << ']'
+    @object = /\{\s*\}/.r{{}} | ('{'.r >> elem_parser(pair) << '}').map{|arr|Hash[arr]}
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  j = SlowJSON.new
+  p j.parse '""'
+  p j.parse '123.4e5'
+  p j.parse 'null'
+  p j.parse '[]'
+  p j.parse '{}'
+  p j.parse '{"no": [3, 4]}'
+  p j.parse '[{}]'
+  p j.parse '[{"S":321061,"T":"GetAttributeResp"},{"ERROR":null,"TS":0,"VAL":{"SqlList":[{"BatchSizeMax":0,"BatchSizeTotal":0,"ConcurrentMax":1,"DataSource":"jdbc:wrap-jdbc:filters=default,encoding:name=ds-offer:jdbc:mysql://100.10.10.10:8066/xxxx","EffectedRowCount":0,"ErrorCount":0,"ExecuteCount":5,"FetchRowCount":5,"File":null,"ID":2001,"LastError":null,"LastTime":1292742908178,"MaxTimespan":16,"MaxTimespanOccurTime":1292742668191,"Name":null,"RunningCount":0,"SQL":"SELECT @@SQL_MODE","TotalTime":83}]}}]'
+end
+

data/lib/rsec.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+# load the gem
+
+# All code is under this module
+module Rsec
+  # preload configs
+  
+  # config method name
+  # default is :r
+  unless Rsec.const_defined?(:TO_PARSER_METHOD)
+    TO_PARSER_METHOD = :r
+  end
+
+  # config C extension usage
+  # options:
+  #   :try - default
+  #   :no  - don't use
+  #   :yes - use
+  unless Rsec.const_defined?(:USE_CEXT)
+    USE_CEXT = :try
+  end
+
+  VERSION = '0.3'
+end
+
+require "strscan"
+require "rsec/utils"
+require "rsec/parser"
+require "rsec/helpers"
+
+case Rsec::USE_CEXT
+when :try
+  require "rsec/ext" rescue nil
+when :yes
+  require "rsec/ext"
+when :no
+else
+  warn "Rsec::USE_CEXT should be one of :try, :yes, :no"
+end
+

data/lib/rsec/helpers.rb

@@ -0,0 +1,447 @@
+# coding: utf-8
+# ------------------------------------------------------------------------------
+# Helpers(combinators) to construct parser
+
+module Rsec #:nodoc:
+
+  # ------------------------------------------------------------------------------
+  # these are not callable from a parser
+  module Helpers
+ 
+    # @ desc.helper
+    #   Lazy parser
+    # @ example
+    #   parser = lazy{future}
+    #   future = 'jim'.r
+    #   assert_equal 'jim', parser.parse '12323'
+    def lazy &p
+      raise ArgumentError, 'lazy() requires a block' unless p
+      Lazy[p]
+    end
+    
+    # @ desc.helper
+    #   Parses one of chars in str
+    # @ example
+    #   multiplicative = one_of '*/%'
+    #   assert_equal '/', multiplicative.parse '/'
+    #   assert_equal Rsec::INVALID, actualmultiplicative.parse '+'
+    def one_of str, &p
+      Rsec.assert_type str, String
+      raise ArgumentError, 'str len should > 0' if str.empty?
+      one_of_klass =
+        if (str.bytesize == str.size) and Rsec.const_defined?(:OneOfByte)
+          # for C-ext
+          OneOfByte
+        else
+          OneOf
+        end
+      one_of_klass[str.dup.freeze].map p
+    end
+
+    # @ desc.helper
+    #   See also #one_of#, with leading and trailing optional breakable spaces
+    # @ example
+    #   additive = one_of_('+-')
+    #   assert_equal '+', additive.parse('  +')
+    def one_of_ str, &p
+      Rsec.assert_type str, String
+      raise ArgumentError, 'str len should > 0' if str.empty?
+      raise ArgumentError, 'str should be ascii' unless str.bytesize == str.size
+      raise ArgumentError, 'str should not contain space' if str =~ /\s/
+      spaced_one_of_klass =
+        if (str.bytesize == str.size) and Rsec.const_defined?(:OneOfByte_)
+          # for C-ext
+          OneOfByte_
+        else
+          OneOf_
+        end
+      spaced_one_of_klass[str.dup.freeze].map p
+    end
+
+    # @ desc.helper
+    #   Primitive parser, returns nil if overflow or underflow.
+    #   There can be an optional '+' or '-' at the beginning of string except unsinged_int32 | unsinged_int64.
+    #   type =
+    #     :double |
+    #     :hex_double |
+    #     :int32 |
+    #     :int64 |
+    #     :unsigned_int32 |
+    #     :unsigned_int64
+    #   options:
+    #     :allowed_sign => '+' | '-' | '' | '+-' (default '+-')
+    #     :allowed_signs => (same as :allowed_sign)
+    #     :base => integer only (default 10)
+    # @ example
+    #   p = prim :double
+    #   assert_equal 1.23, p.parse('1.23')
+    #   p = prim :double, allowed_sign: '-'
+    #   assert_equal 1.23, p.parse('1.23')
+    #   assert_equal -1.23, p.parse('-1.23')
+    #   assert_equal Rsec::INVALID, p.parse('+1.23')
+    #   p = prim :int32, base: 36
+    #   assert_equal 49713, p.parse('12cx')
+    def prim type, options={}, &p
+      base = options[:base]
+      if [:double, :hex_double].index base
+        raise 'Floating points does not allow :base'
+      end
+      base ||= 10
+      Rsec.assert_type base, Fixnum
+      unless (2..36).include? base
+        raise RangeError, ":base should be in 2..36, but got #{base}"
+      end
+      
+      sign_strategy = \
+        case (options[:allowed_sign] or options[:allowed_signs])
+        when nil, '+-', '-+'; 3
+        when '+'; 2
+        when '-'; 1
+        when ''; 0
+        else raise "allowed_sign should be one of nil, '', '+', '-', '+-', '-+'"
+        end
+
+      parser = \
+        case type
+        when :double; PDouble.new sign_strategy, false # decimal
+        when :hex_double; PDouble.new sign_strategy, true # hex
+        when :int32;  PInt32.new sign_strategy, base
+        when :int64;  PInt64.new sign_strategy, base
+        when :unsigned_int32;
+          raise 'unsigned int not allow - sign' if options[:allowed_signs] =~ /-/
+          PUnsignedInt32.new sign_strategy, base
+        when :unsigned_int64;
+          raise 'unsigned int not allow - sign' if options[:allowed_signs] =~ /-/
+          PUnsignedInt64.new sign_strategy, base
+        else
+          raise "Invalid primitive type #{type}"
+        end
+      parser.map p
+    end
+
+    # @ desc.helper
+    #   Sequence parser
+    # @ example
+    #   assert_equal ['a', 'b', 'c'], actualseq('a', 'b', 'c').parse('abc')
+    def seq *xs, &p
+      xs.map! {|x| Rsec.make_parser x }
+      Seq[xs].map p
+    end
+
+    # @ desc.helper
+    #   Sequence parser with skippable pattern(or parser)
+    #   option
+    #     :skip default= /\s*/
+    # @ example
+    #   assert_equal ['a', 'b', 'c'], actualseq_('a', 'b', 'c', skip: ',').parse('a,b,c')
+    def seq_ *xs, &p
+      skipper = 
+        if (xs.last.is_a? Hash)
+          xs.pop[:skip]
+        end
+      skipper = skipper ? Rsec.make_parser(skipper) : /\s*/.r
+      xs.map! {|x| Rsec.make_parser x }
+      first, *rest = xs
+      raise 'sequence should not be empty' unless first
+      Seq_[first, rest, skipper].map p
+    end
+
+    # @ desc.helper
+    #   A symbol is something wrapped with optional space
+    def symbol pattern, skip=/\s*/, &p
+      pattern = Rsec.make_parser pattern
+      skip = Rsec.try_skip_pattern Rsec.make_parser skip
+      SeqOne[[skip, pattern, skip], 1].map p
+    end
+
+    # @ desc.helper
+    #   A word is wrapped with word boundaries
+    # @ example
+    #   assert_equal ['yes', '3'], seq('yes', '3').parse('yes3')
+    #   assert_equal INVALID, seq(word('yes'), '3').parse('yes3')
+    def word pattern, &p
+      parser = Rsec.make_parser pattern
+      # TODO check pattern type
+      Pattern[/\b#{parser.some}\b/].map p
+    end
+  end # helpers
+
+  # robust
+  Helper = Helpers
+
+  # ------------------------------------------------------------------------------
+  # combinators attached to parsers
+
+  module Parser #:nodoc:
+
+    # @ desc
+    #   Transform result
+    # @ example
+    #   parser = /\w+/.r.map{|word| word * 2}
+    #   assert_equal 'hellohello', parser.parse!('hello')
+    def map lambda_p=nil, &p
+      return self if (lambda_p.nil? and p.nil?)
+      p = lambda_p || p
+      raise TypeError, 'should give a proc or lambda' unless (p.is_a? Proc)
+      Map[self, p]
+    end
+
+    # @ desc
+    #   "p.join('+')" parses strings like "p+p+p+p+p".
+    #   Note that at least 1 of p appears in the string.
+    #   Sometimes it is useful to reverse the joining:
+    #   /\s*/.r.join('p').odd parses string like " p p  p "
+    def join inter, &p
+      inter = Rsec.make_parser inter
+      Join[self, inter].map p
+    end
+
+    # @ desc
+    #   Branch parser, note that rsec is a PEG parser generator,
+    #   beware of the difference between PEG and CFG.
+    def | y, &p
+      y = Rsec.make_parser y
+      arr =
+        if (is_a?(Branch) and !p)
+          [*some, y]
+        else
+          [self, y]
+        end
+      Branch[arr].map p
+    end
+
+    # @ desc
+    #   Repeat n or in a range.
+    #   If range.end < 0, repeat at least range.begin
+    #   (Infinity and -Infinity are considered)
+    def * n, &p
+      # FIXME if self is an epsilon parser, will cause infinite loop
+      parser =
+        if n.is_a?(Range)
+          raise "invalid n: #{n}" if n.begin < 0
+          Rsec.assert_type n.begin, Integer
+          end_inf = (n.end.infinite? rescue false)
+          (Rsec.assert_type n.end, Integer) unless end_inf
+          if n.end > 0
+            RepeatRange[self, n]
+          else
+            RepeatAtLeastN[self, n.begin]
+          end
+        else
+          Rsec.assert_type n, Integer
+          raise "invalid n: #{n}" if n < 0
+          RepeatN[self, n]
+        end
+      parser.map p
+    end
+
+    # @ desc
+    #   Appears 0 or 1 times, result is wrapped in an array
+    # @ example
+    #   parser = 'a'.r.maybe
+    #   assert_equal ['a'], parser.parse('a')
+    #   assert_equal [], parser.parse('')
+    def maybe &p
+      Maybe[self].map &p
+    end
+    alias _? maybe
+
+    # @ desc
+    #   Kleen star, 0 or more any times
+    def star &p
+      self.* (0..-1), &p
+    end
+
+    # @ desc
+    #   Lookahead predicate, note that other can be a very complex parser
+    def & other, &p
+      other = Rsec.make_parser other
+      LookAhead[self, other].map p
+    end
+
+    # @ desc
+    #   Negative lookahead predicate
+    def ^ other, &p
+      other = Rsec.make_parser other
+      NegativeLookAhead[self, other].map p
+    end
+
+    # @ desc
+    #   When parsing failed, show "expect tokens" error
+    def fail *tokens, &p
+      return self if tokens.empty?
+      Fail[self, tokens].map p
+    end
+    alias expect fail
+
+    # @ desc
+    #   Short for seq_(parser, other)[1]
+    def >> other, &p
+      other = Rsec.make_parser other
+      left = Rsec.try_skip_pattern self
+      SeqOne_[left, [other], SkipPattern[/\s*/], 1].map p
+    end
+
+    # @ desc
+    #   Short for seq_(parser, other)[0]
+    def << other, &p
+      other = Rsec.make_parser other
+      right = Rsec.try_skip_pattern other
+      SeqOne_[self, [right], SkipPattern[/\s*/], 0].map p
+    end
+
+    # @ desc
+    #   Should be end of input after parse
+    def eof &p
+      Eof[self].map p
+    end
+
+    # @ desc
+    #   Packrat parser combinator, returns a parser that caches parse result, may optimize performance
+    def cached &p
+      Cached[self].map p
+    end
+  end
+
+  # ------------------------------------------------------------------------------
+  # additional helper methods for special classes
+
+  class Seq
+    # @ desc.seq, seq_
+    #   Returns the parse result at idx, shorter and faster than map{|array| array[idx]}
+    # @ example
+    #   assert_equal 'b', seq('a', 'b', 'c')[1].parse('abc')
+    def [] idx, &p
+      raise 'index out of range' if (idx >= some().size or idx < 0)
+      # optimize
+      parsers = some().map.with_index do |p, i|
+        i == idx ? p : Rsec.try_skip_pattern(p)
+      end
+      SeqOne[parsers, idx].map p
+    end
+
+    # @ desc.seq, seq_, join, join.even, join.odd
+    #   If parse result contains only 1 element, return the element instead of the array
+    def unbox &p
+      Unbox[self].map p
+    end
+
+    # @ desc
+    #   Think about "innerHTML"!
+    # @ example
+    #   parser = seq('<b>', /[\w\s]+/, '</b>').inner
+    #   parser.parse('<b>the inside</b>')
+    def inner &p
+      Inner[self].map p
+    end
+  end
+
+  class Seq_
+    def [] idx, &p
+      raise 'index out of range' if idx > rest.size or idx < 0
+      # optimize parsers, use skip if possible
+      new_first = (0 == idx ? first : Rsec.try_skip_pattern(first))
+      new_rest = rest().map.with_index do |p, i|
+        # NOTE rest start with 1
+        (i+1) == idx ? p : Rsec.try_skip_pattern(p)
+      end
+      SeqOne_[new_first, new_rest, skipper, idx].map p
+    end
+
+    def unbox &p
+      Unbox[self].map p
+    end
+
+    def inner &p
+      Inner[self].map p
+    end
+  end
+
+  class Join
+    def unbox &p
+      Unbox[self].map p
+    end
+
+    # @ desc.join
+    #   Only keep the even(left, token) parts
+    def even &p
+      JoinEven[left, Rsec.try_skip_pattern(right)].map p
+    end
+
+    # @ desc.join
+    #   Only keep the odd(right, inter) parts
+    def odd &p
+      JoinOdd[Rsec.try_skip_pattern(left), right].map p
+    end
+  end
+
+  class JoinEven
+    def unbox &p
+      Unbox[self].map p
+    end
+  end
+
+  class JoinOdd
+    def unbox &p
+      Unbox[self].map p
+    end
+  end
+
+  class Pattern
+    # @ desc.r
+    #   Scan until the pattern happens
+    def until &p
+      UntilPattern[some()].map p
+    end
+  end
+
+  # ------------------------------------------------------------------------------
+  # helper methods for parser generation
+
+  # ensure x is a parser
+  def Rsec.make_parser x
+    return x if x.is_a?(Parser)
+    x = x.send(TO_PARSER_METHOD) if x.respond_to?(TO_PARSER_METHOD)
+    Rsec.assert_type x, Parser
+    x
+  end
+
+  # type assertion
+  def Rsec.assert_type obj, type
+    (raise TypeError, "#{obj} should be a #{type}") unless (obj.is_a? type)
+  end
+
+  # try to convert Pattern -> SkipPattern
+  def Rsec.try_skip_pattern p
+    # for C-ext
+    if Rsec.const_defined?(:FixString) and p.is_a?(FixString)
+      return SkipPattern[/#{Regexp.escape p.some}/]
+    end
+
+    case p
+    when Pattern
+      SkipPattern[p.some]
+    when UntilPattern
+      SkipUntilPattern[p.some]
+    else
+      p
+    end
+  end
+end
+
+class String #:nodoc:
+  # String#r: convert self to parser
+  # convienient string-to-parser transformer
+  define_method ::Rsec::TO_PARSER_METHOD, ->(*expects, &p){
+    ::Rsec::Pattern[/#{Regexp.escape self}/].fail(*expects).map p
+  }
+end
+
+class Regexp #:nodoc:
+  # Regexp#r: convert self to parser
+  # convienient regexp-to-parser transformer
+  define_method ::Rsec::TO_PARSER_METHOD, ->(*expects, &p){
+    ::Rsec::Pattern[self].fail(*expects).map p
+  }
+end
+