module Regexp::Expression

def capturing?; self.class.capturing? end }

def capturing?; false end }

def capturing?; true  end }

def comment?; self.class.comment? end }

def comment?; false end }

def comment?; true  end }

def comment?; true  end }

def decorative?; self.class.decorative? end }

def decorative?; false end }

def decorative?; true  end }

def decorative?; true  end }

def human_name; 'alternation'                 end }

def human_name; 'alternative'                 end }

def human_name; 'beginning of line'           end }

def human_name; 'beginning of string'         end }

def human_name; 'end of line'                 end }

def human_name; 'end of string'               end }

def human_name; 'newline-ready end of string' end }

def human_name; 'match start'                 end }

def human_name; 'no word boundary'            end }

def human_name; 'word boundary'               end }

def human_name; 'lookahead'                   end }

def human_name; 'lookbehind'                  end }

def human_name; 'negative lookahead'          end }

def human_name; 'negative lookbehind'         end }

def human_name; 'backreference by name'       end }

def human_name; 'subexpression call by name'  end }

def human_name; 'backreference'               end }

def human_name; 'relative backreference'      end }

def human_name; 'subexpression call'          end }

def human_name; 'relative subexpression call' end }

def human_name; 'intersected sequence'        end }

def human_name; 'intersection'                end }

def human_name; 'character range'             end }

def human_name; 'match-all'                   end }

def human_name; 'comment'                     end }

def human_name; 'conditional branch'          end }

def human_name; 'condition'                   end }

def human_name; 'conditional'                 end }

def human_name; "capture group #{number}"     end }

def human_name; 'named capture group'         end }

def human_name; 'keep-mark lookbehind'        end }

def human_name; 'literal'                     end }

def human_name; 'root'                        end }

def human_name; 'free space'                  end }

def negative?; true                          end }

def negative?; true                          end }

def negative?; true                          end }

def negative?; negative                      end }

def negative?; token.to_s.start_with?('non') end }

def negative?; type == :nonposixclass        end }

def negative?; type == :nonproperty          end }

def parts; ["#{text}#{'^' if negated?}", *expressions, ']']        end }

def parts; intersperse(expressions, text.dup)                      end }

def parts; [text.dup, condition, *intersperse(branches, '|'), ')'] end }

def parts; [text.dup, *expressions, ')']                           end }

def parts; implicit? ? expressions : super                         end }

def parts; [text.dup]                                              end }

def parts; expressions                                             end }

def parts; intersperse(expressions, text.dup)                      end }

def referential?; self.class.referential? end }

def referential?; false end }

def referential?; true  end }

def referential?; true  end }

def referential?; true  end }

def terminal?; self.class.terminal? end }

def terminal?; true  end }

def terminal?; false end }