View source

From Reia

You do not have permission to do that, for the following reason:

The action you have requested is limited to users in the group user.

You can view and copy the source of this page:

== Assignment ==

The = operator can be used for simple assignment:

  <pre>
>> foo = 42
42</pre>

...but it can also be used for compound assignment using patterns:

  <pre>
>> (foo, [bar, baz]) = (1, [2, 3])
(1,[2,3])
>> foo
1
>> bar
2
>> baz
3</pre>

From this example, you hopefully see that the "equals" operator does much more than just simple assignment.  Rather, it matches expressions using patterns, and specifying a single variable as a pattern is the degenerate case.
  
This example binds the variables foo, bar, and baz to the values 1, 2, and 3 respectively.  All variables on the left side will be assigned, regardless of whether or not they're bound.  To override this behavior, the unary '''^''' operator can be used:

  <pre>
>> foo = 42
42
>> (^foo, [bar, baz]) = (1, [2, 3])
NoMatch: right hand side value 1</pre>

This example will raise a NoMatch exception, because foo does not match the respective variable 1.

== Case statement ==

Ordinarily variables are rebound in a pattern matching context.  However, using the '''^''' unary operator, the values variables are bound to become part of a pattern, and the variables themselves won't be rebound:

  <pre>
>> foo = 42
42
>> case (42, 1.61803)
.. when (^foo, phi)
..   (:yay, foo, phi)
.. else
..   :boo
.. end
..
=> (:yay, 42, 1.61803)</pre>

From this example, you can see the case statement matches statements using patterns.  The expressions at one level of indentation are patterns.  The value in the first slot of the tuple is compared against the value of foo, and if it matches, phi is bound, in this case to the value in its respective slot of the tuple, which is 1.61803.

Here's another example where the '''^''' operator isn't used:

  <pre>
>> foo = 69
69
>> case (42, 1.61803)
.. when (foo, phi)
..   (:yay, foo, phi)
.. else
..   :boo
.. end
..
=> (:yay, 42, 1.61803)</pre>

In this example, foo is bound to 42 and phi is bout to 1.61803.  The original value of foo is overwritten.

A final example:

  <pre>
>> foo = 69
69
>> case (42, 1.61803)
.. when (^foo, phi)
..   (:yay, foo, phi)
.. else
..   :boo
.. end
..
=> :boo</pre>

In this example, the specified pattern failed to match the one given to the case statement, since foo is not equal to 42.

Return to Pattern matching.

Retrieved from "http://wiki.reia-lang.org/wiki/Pattern_matching"

View source

From Reia

Views

Personal tools

Navigation

Search

Toolbox