Guide:Control flow - Revision history

Olabini: /* Control flow */

2009-12-22T18:37:16Z

‎Control flow

spambot_Tumble: /* Comprehensions */

2009-04-12T06:53:19Z

‎Comprehensions

spambot_Tumble: /* until */

2009-04-12T06:22:02Z

‎until

spambot_Tumble: /* Iteration */

2009-04-12T06:20:52Z

‎Iteration

Olabini at 08:07, 26 January 2009

2009-01-26T08:07:34Z

Show changes

Cv at 23:14, 25 January 2009

2009-01-25T23:14:56Z

Show changes

Cv: New page: = Control flow = Ioke has some standard control flow operators, like most other languages. In Ioke, all of these are regular method calls though, and they can usually be implemented in te...

2009-01-25T23:13:38Z

New page: = Control flow = Ioke has some standard control flow operators, like most other languages. In Ioke, all of these are regular method calls though, and they can usually be implemented in te...

Show changes

@@ Line 5: / Line 5: @@
 == Comparison ==
-There are several comparison operators in Ioke, but the most important is called the spaceship operator. This operator is &lt;=&gt;. It takes one argument and returns -1, 0 or 1 depending on the ordering of the receiver and the argument. If the two objects can't be compared, it returns nil. If you implement this operator and mixin Mixins Comparing, you get the operators ==, !=, &lt;, &lt;=, &gt; and &gt;= implemented in terms of the spaceship operator. There are two other common operators in Ioke. The first =~, which can also be called the match operator. It's only implemented for Regexp right now. The === operator also exists, but isn't implemented for most objects. This operator doesn't do much right now, but is planned to be the basis of a Ruby-like case-statement further down the line. The contract of comparison operators is that they should return a true value (not necessarily the true) if the comparison is true, and otherwise return either false or nil.
+There are several comparison operators in Ioke, but the most important is called the spaceship operator. This operator is &lt;=&gt;. It takes one argument and returns -1, 0 or 1 depending on the ordering of the receiver and the argument. If the two objects can't be compared, it returns nil. If you implement this operator and mixin Mixins Comparing, you get the operators ==, !=, &lt;, &lt;=, &gt; and &gt;= implemented in terms of the spaceship operator. There are two other common operators in Ioke. The first =~, which can also be called the match operator. It's only implemented for Regexp right now. The === operator also exists, but implements matching slightly differently for all different types of objects. It is the basis for the case-expression. The contract of comparison operators is that they should return a true value (not necessarily the true) if the comparison is true, and otherwise return either false or nil.
 The contract for === should be matching or not matching. It is among other things used in Ranges to see if something is included in that range or not.
@@ Line 104: / Line 104: @@
 == Iteration ==
-Ioke supports most of the expected control flow operations for iteration. The one thing that is missing is the for-loop. Since the for-loop encourages low level stepping, and can be replaced by other kinds of operations, I don't see any reason in having it in Ioke. In fact, the for-statement in Ruby is generally considered bad form too. And if someone really wants a for-loop it's really easy to implement. For now I'm reserving the name if I would like to add comprehensions at some point.
+Ioke supports most of the expected control flow operations for iteration. The one thing that is missing is the for-loop. Since the for-loop encourages low level stepping, and can be replaced by other kinds of operations, I don't see any reason in having it in Ioke. In fact, the for-statement in Ruby is generally considered bad form too. And if someone really wants a for-loop it's really easy to implement. The name 'for' is also currently taken for list comprehensions.
 === loop ===
@@ Line 178: / Line 178: @@
 : 16
 : 36</source>
 === break, continue ===

@@ Line 201: / Line 201: @@
 == Comprehensions ==
-Ioke's Enumerable mimic makes it really easy to use higher order operations to transform and work with collections of data. But in some cases the code for doing that might not be as clear as it could be. Comprehensions allow a list, set or dict to be created based on a more abstract definition of what should be done. The specific parts of a comprehension is generators, filters and the mapping. The generators are what data to work on, the filters chooses more specifically among the generated data, and the mapping decides what the output should look like.
+Ioke's Enumerable mimic makes it really easy to use higher order operations to transform and work with collections of data. But in some cases the code for doing that might not be as clear as it could be. Comprehensions allow a list, set or dict to be created based on a more abstract definition of what should be done. The specific parts of a comprehension are generators, filters and the mapping. The generators are what data to work on, the filters chooses more specifically among the generated data, and the mapping decides what the output should look like.
 The following example does three nested iterations and returns all combinations where the product of the number is larger than 100:

@@ Line 131: / Line 131: @@
 === until ===
-The until-loop works the same as the while-loop, except it expects it's condition argument to evaluate to false. It will stop iterating when the conditional is true for the first time.
+The until-loop works the same as the while-loop, except it expects its condition argument to evaluate to false. It will stop iterating when the conditional is true for the first time.
 <source lang="ioke">x = 0

@@ Line 104: / Line 104: @@
 == Iteration ==
-Ioke supports most of the expected control flow operations for iteration. The one thing that is missing is the for-loop. Since the for-loop encourages low level stepping, and canbe replaced by other kinds of operations, I don't see any reason in having it in Ioke. In fact, the for-statement in Ruby is generally considered bad form too. And if someone really wants a for-loop it's really easy to implement. For now I'm reserving the name if I would like to add comprehensions at some point.
+Ioke supports most of the expected control flow operations for iteration. The one thing that is missing is the for-loop. Since the for-loop encourages low level stepping, and can be replaced by other kinds of operations, I don't see any reason in having it in Ioke. In fact, the for-statement in Ruby is generally considered bad form too. And if someone really wants a for-loop it's really easy to implement. For now I'm reserving the name if I would like to add comprehensions at some point.
 === loop ===