Gecko [ www.beriskala.com ]

Name	Size	Permission	Date
CompilationError	[ DIR ]	drwxr-xr-x	2026-05-05 23:08
cdesc-Pattern.ri	2.48 KB	-rw-r--r--	2026-04-07 16:51
combine_and-i.ri	382 B	-rw-r--r--	2026-04-07 16:51
combine_or-i.ri	383 B	-rw-r--r--	2026-04-07 16:51
compile-i.ri	363 B	-rw-r--r--	2026-04-07 16:51
compile_alternation_pattern_node-i.ri	349 B	-rw-r--r--	2026-04-07 16:51
compile_array_pattern_node-i.ri	343 B	-rw-r--r--	2026-04-07 16:51
compile_constant_name-i.ri	363 B	-rw-r--r--	2026-04-07 16:51
compile_constant_path_node-i.ri	351 B	-rw-r--r--	2026-04-07 16:51
compile_constant_read_node-i.ri	354 B	-rw-r--r--	2026-04-07 16:51
compile_error-i.ri	354 B	-rw-r--r--	2026-04-07 16:51
compile_hash_pattern_node-i.ri	384 B	-rw-r--r--	2026-04-07 16:51
compile_nil_node-i.ri	311 B	-rw-r--r--	2026-04-07 16:51
compile_node-i.ri	400 B	-rw-r--r--	2026-04-07 16:51
compile_regular_expression_node-i.ri	343 B	-rw-r--r--	2026-04-07 16:51
compile_string_node-i.ri	325 B	-rw-r--r--	2026-04-07 16:51
compile_symbol_node-i.ri	324 B	-rw-r--r--	2026-04-07 16:51
new-c.ri	398 B	-rw-r--r--	2026-04-07 16:51
query-i.ri	322 B	-rw-r--r--	2026-04-07 16:51
scan-i.ri	554 B	-rw-r--r--	2026-04-07 16:51

Rename

U:RDoc::NormalClass[iI"Pattern:ETI"Prism::Pattern;TI"Object;To:RDoc::Markup::Document:@parts[o;;[
o:RDoc::Markup::Paragraph;[I"�A pattern is an object that wraps a Ruby pattern matching expression. The
expression would normally be passed to an <code>in</code> clause within a <code>case</code>
expression or a rightward assignment expression. For example, in the
following snippet:;To:RDoc::Markup::Verbatim;[I"case node
;TI"[in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
;TI"	end
;T:@format0o;	;[I"Bthe pattern is the <tt>ConstantPathNode[...]</tt> expression.;To;	;[I"IThe pattern gets compiled into an object that responds to #call by running
the #compile method. This method itself will run back through Prism to
parse the expression into a tree, then walk the tree to generate the
necessary callable objects. For example, if you wanted to compile the
expression above into a callable, you would:;To;
;[I"|callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
;TI"callable.call(node)
;T;0o;	;[I"�The callable object returned by #compile is guaranteed to respond to #call
with a single argument, which is the node to match against. It also is
guaranteed to respond to #===, which means it itself can be used in a <code>case</code>
expression, as in:;To;
;[I"case node
;TI"when callable
;TI"	end
;T;0o;	;[I"�If the query given to the initializer cannot be compiled into a valid
matcher (either because of a syntax error or because it is using syntax we
do not yet support) then a Prism::Pattern::CompilationError will be
raised.;T:
@fileI"lib/prism/pattern.rb;T:0@omit_headings_from_table_of_contents_below0;0;
0[[
I"
query;TI"R;T:publicFI"lib/prism/pattern.rb;T[�[�[[I"
class;T[[;[[I"new;T@0[:protected[�[:private[�[I"
instance;T[[;[[I"compile;T@0[I"	scan;T@0[;[�[;[[I"combine_and;T@0[I"combine_or;T@0[I"%compile_alternation_pattern_node;T@0[I"compile_array_pattern_node;T@0[I"compile_constant_name;T@0[I"compile_constant_path_node;T@0[I"compile_constant_read_node;T@0[I"compile_error;T@0[I"compile_hash_pattern_node;T@0[I"compile_nil_node;T@0[I"compile_node;T@0[I"$compile_regular_expression_node;T@0[I"compile_string_node;T@0[I"compile_symbol_node;T@0[�[U:RDoc::Context::Section[i�0o;;[�;0;
0[@+I"
Prism;TcRDoc::NormalModule