Guide - Revision history

Olabini at 20:32, 22 December 2009

2009-12-22T20:32:51Z

Olabini at 14:32, 5 April 2009

2009-04-05T14:32:19Z

Cv at 23:21, 25 January 2009

2009-01-25T23:21:29Z

Cv at 23:18, 25 January 2009

2009-01-25T23:18:08Z

Cv at 23:17, 25 January 2009

2009-01-25T23:17:01Z

Cv at 23:15, 25 January 2009

2009-01-25T23:15:30Z

Cv at 23:13, 25 January 2009

2009-01-25T23:13:17Z

Cv: /* Control flow */

2009-01-25T23:12:43Z

‎Control flow

Show changes

Cv: /* Control flow */

2009-01-25T23:11:38Z

‎Control flow

Cv: /* Assignment */

2009-01-25T23:06:51Z

‎Assignment

← Older revision		Revision as of 20:32, 22 December 2009
Line 16:		Line 16:

	{{:Guide:Aspects}}		{{:Guide:Aspects}}
		+
		+	{{:Guide:Hooks}}

	{{:Guide:Importing}}		{{:Guide:Importing}}

← Older revision		Revision as of 14:32, 5 April 2009
Line 20:		Line 20:

	{{:Guide:Core kinds}}		{{:Guide:Core kinds}}
		+
		+	{{:Guide:Java integration}}

	{{:Guide:Libraries}}		{{:Guide:Libraries}}

← Older revision		Revision as of 23:21, 25 January 2009
Line 16:		Line 16:

	{{:Guide:Aspects}}		{{:Guide:Aspects}}
		+
		+	{{:Guide:Importing}}
		+
		+	{{:Guide:Core kinds}}
		+
		+	{{:Guide:Libraries}}
		+
		+	{{:Guide:What is missing}}
		+
		+	{{:Guide:Future plans}}

← Older revision		Revision as of 23:18, 25 January 2009
Line 14:		Line 14:

	{{:Guide:Introspection and Reflection}}		{{:Guide:Introspection and Reflection}}
		+
		+	{{:Guide:Aspects}}

← Older revision		Revision as of 23:17, 25 January 2009
Line 1:		Line 1:
−
	{{:Guide:Introduction}}		{{:Guide:Introduction}}

Line 13:		Line 12:

	{{:Guide:Code}}		{{:Guide:Code}}
		+
		+	{{:Guide:Introspection and Reflection}}

@@ Line 1: / Line 1: @@
 {{:Guide:Introduction}}
 {{:Guide:Syntax}}
 {{:Guide:Execution Model}}
 {{:Guide:Objects}}
 {{:Guide:Assignment}}
 {{:Guide:Control flow}}

@@ Line 8: / Line 8: @@
 {{:Guide:Assignment}}
-=== Control flow ===
+= 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 terms of Ioke. This chapter will chiefly talk about comparisons, conditionals and iteration constructs.
-==== Comparison ====
+== 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.
@@ Line 26: / Line 26: @@
 iik&gt; &quot;foo&quot; &lt;=&gt; &quot;fop&quot;
 +&gt; -1</pre>
-==== Conditionals ====
 Ioke has two different ways of doing conditionals. The first one is the default, and is also the traditional conditional from other languages. The second version looks more like Smalltalk conditionals.
@@ Line 57: / Line 58: @@
 Ioke also supports the expected short circuiting boolean evaluators. They are implemented as regular methods and are available on all objects. All of the expected combinators are available, including &quot;and&quot;, &quot;&amp;&amp;&quot;, &quot;or&quot;, &quot;||&quot;, &quot;xor&quot;, &quot;nor&quot; and &quot;nand&quot;.
-==== cond ====
+=== cond ===
 Ioke doesn't have any else-if expression, which means that when you want to do several nested checks, you end up with lots of indentation. Cond is a macro that expands to that code. The code using cond will not have more indentation, which means it might be easier to read. A cond has one or more conditional expressions followed by an action part to execute if that condition is true. As soon as a condition has evaluated to true cond will not evaluate any more conditions or actions. If no conditions evaluate to true, nil will be returned, unless there is an action part following the last action-part. In other terms, if the cond-expression has an odd number of arguments, the last argument is the default case to execute if nothing else matches.
@@ Line 72: / Line 73: @@
 As you can see, it becomes quite clear what happens here. Keep in mind that cond is an expression, just like anything else in Ioke, and will return the last value evaluated.
-==== case ====
+=== case ===
 A thing that you very often want to do is to check one value against several different conditions. The case expression allows this to be done succinctly. The core to the case-expression is the === method, that is used for matching. The expression takes one value, then one or more conditionals followed by actions, and then an optional default part. Once something matches, no more conditionals will be executed. The conditional part should not be a complete conditional statement. Instead it should return something that implements a fitting ===. So, a small example follows:
@@ Line 109: / Line 110: @@
 otherwise
 : Returns a matcher that always returns true. This is useful to make the default argument read better.
-==== 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.
-===== loop =====
+=== loop ===
 For creating infinte loops, the &quot;loop&quot;-method is the thing. It will just take a piece of code and execute it over and over again until some non-local flow control rips the execution up. Using it is as simple as calling it:
@@ Line 126: / Line 128: @@
 The first example will loop forever, printing hello over and over again. The second example will increment a variable until it's larger then 10, and then it will break out of the loop.
-===== while =====
+=== while ===
 The Ioke while loop works exactly like while-loops in other languages. It takes one argument that is a condition to reevaluate on each iteration, and another argument that is the code to evaluate each iteration. The result of the while-loop is the result of the last executed expression in the body.
@@ Line 135: / Line 137: @@
    x++
 )</pre>
-===== 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.
@@ Line 144: / Line 147: @@
    x++
 )</pre>
-===== times =====
 A very common need is to iterate something a certain number of times. The Number Integer kind defines a method called &quot;times&quot; that does exactly this. It's got two forms - one with one argument and one with two arguments. With one argument, it will just run the argument code the specified number of times, and with two arguments the first argument should be the name of a cell to assign the current iteration value to and the second is the code to execute.
@@ Line 154: / Line 158: @@
 The first example will print hello three times, while the second example will count up from 0 to 3, printing the number followed by &quot;wow&quot;.
-===== each =====
+=== each ===
 For most iteration needs, you want to traverse a collection in some way. The standard way of doing this is with the &quot;each&quot;-method. It's defined on all central collection classes and is also the basis of the contract for Mixins Enumerable. The contract for each has three different forms, and all should be implemented if you decide to implement the each method.
@@ Line 183: / Line 187: @@
 : 16
 : 36</pre>
-===== break, continue =====
 When executing loops it is sometimes important to be able to interrupt execution prematurely. In this cases the break and continue methods allow this for &quot;loop&quot;, &quot;while&quot; and &quot;until&quot;. Both break and continue work lexically, so if you send code to another method that uses these methods, they will generally jump out of a lexically visible loop, just like expected.
@@ Line 203: / Line 208: @@
 This code uses continue to jump over a specific number, so it will only print 0 to 5, and 7 to 9.
-==== Comprehensions ====
+== 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.