mirror of
https://github.com/wren-lang/wren.git
synced 2026-01-18 13:49:59 +01:00
Regenerate docs.
This commit is contained in:
Bob Nystrom
156
classes.html
156
classes.html
@ -67,16 +67,16 @@ which are stored in the class. State is defined in <em>fields</em>, whose values
|
|||||||
stored in each instance.</p>
|
stored in each instance.</p>
|
||||||
<h2>Defining a class <a href="#defining-a-class" name="defining-a-class" class="header-anchor">#</a></h2>
|
<h2>Defining a class <a href="#defining-a-class" name="defining-a-class" class="header-anchor">#</a></h2>
|
||||||
<p>Classes are created using the <code>class</code> keyword, unsurprisingly:</p>
|
<p>Classes are created using the <code>class</code> keyword, unsurprisingly:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{}</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>This creates a class named <code>Unicorn</code> with no methods or fields.</p>
|
<p>This creates a class named <code>Unicorn</code> with no methods or fields.</p>
|
||||||
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
||||||
<p>To let our unicorn do stuff, we need to give it methods.</p>
|
<p>To let our unicorn do stuff, we need to give it methods.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="n">prance</span><span class="p">()</span> <span class="p">{</span>
|
<span class="n">prance</span><span class="p">()</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"The unicorn prances in a fancy manner!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"The unicorn prances in a fancy manner!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -84,9 +84,9 @@ stored in each instance.</p>
|
|||||||
|
|
||||||
<p>This defines a <code>prance()</code> method that takes no arguments. To support
|
<p>This defines a <code>prance()</code> method that takes no arguments. To support
|
||||||
parameters, put their names inside the parentheses:</p>
|
parameters, put their names inside the parentheses:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="n">prance</span><span class="p">(</span><span class="n">where</span><span class="p">,</span> <span class="n">when</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">prance</span><span class="p">(</span><span class="n">where</span><span class="p">,</span> <span class="n">when</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"The unicorn prances in "</span> <span class="o">+</span> <span class="n">where</span> <span class="o">+</span> <span class="s2">" at "</span> <span class="o">+</span> <span class="n">when</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"The unicorn prances in "</span> <span class="o">+</span> <span class="n">where</span> <span class="o">+</span> <span class="s">" at "</span> <span class="o">+</span> <span class="n">when</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -97,27 +97,27 @@ parameters, put their names inside the parentheses:</p>
|
|||||||
methods in a class with the same name, as long as they have a different
|
methods in a class with the same name, as long as they have a different
|
||||||
<em>signature</em>. In technical terms, you can <em>overload by arity</em>. So this class is
|
<em>signature</em>. In technical terms, you can <em>overload by arity</em>. So this class is
|
||||||
fine:</p>
|
fine:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="n">prance</span><span class="p">()</span> <span class="p">{</span>
|
<span class="n">prance</span><span class="p">()</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"The unicorn prances in a fancy manner!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"The unicorn prances in a fancy manner!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">prance</span><span class="p">(</span><span class="n">where</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">prance</span><span class="p">(</span><span class="n">where</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"The unicorn prances in "</span> <span class="o">+</span> <span class="n">where</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"The unicorn prances in "</span> <span class="o">+</span> <span class="n">where</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">prance</span><span class="p">(</span><span class="n">where</span><span class="p">,</span> <span class="n">when</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">prance</span><span class="p">(</span><span class="n">where</span><span class="p">,</span> <span class="n">when</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"The unicorn prances in "</span> <span class="o">+</span> <span class="n">where</span> <span class="o">+</span> <span class="s2">" at "</span> <span class="o">+</span> <span class="n">when</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"The unicorn prances in "</span> <span class="o">+</span> <span class="n">where</span> <span class="o">+</span> <span class="s">" at "</span> <span class="o">+</span> <span class="n">when</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>And you can call each of the methods like so:</p>
|
<p>And you can call each of the methods like so:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">unicorn</span> <span class="o">=</span> <span class="n">Unicorn</span><span class="p">.</span><span class="k">new</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">unicorn</span> <span class="o">=</span> <span class="vg">Unicorn</span><span class="o">.</span><span class="n">new</span><span class="p">()</span>
|
||||||
<span class="n">unicorn</span><span class="p">.</span><span class="n">prance</span><span class="p">()</span>
|
<span class="n">unicorn</span><span class="o">.</span><span class="n">prance</span><span class="p">()</span>
|
||||||
<span class="n">unicorn</span><span class="p">.</span><span class="n">prance</span><span class="p">(</span><span class="s2">"Antwerp"</span><span class="p">)</span>
|
<span class="n">unicorn</span><span class="o">.</span><span class="n">prance</span><span class="p">(</span><span class="s">"Antwerp"</span><span class="p">)</span>
|
||||||
<span class="n">unicorn</span><span class="p">.</span><span class="n">prance</span><span class="p">(</span><span class="s2">"Brussels"</span><span class="p">,</span> <span class="s2">"high noon"</span><span class="p">)</span>
|
<span class="n">unicorn</span><span class="o">.</span><span class="n">prance</span><span class="p">(</span><span class="s">"Brussels"</span><span class="p">,</span> <span class="s">"high noon"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -130,13 +130,13 @@ treats them as different methods that you can implement separately.</p>
|
|||||||
<h3>Getters <a href="#getters" name="getters" class="header-anchor">#</a></h3>
|
<h3>Getters <a href="#getters" name="getters" class="header-anchor">#</a></h3>
|
||||||
<p>Many methods on a class exist to expose or compute some property of the object.
|
<p>Many methods on a class exist to expose or compute some property of the object.
|
||||||
For example:</p>
|
For example:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"string"</span><span class="p">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// "6".</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"string"</span><span class="o">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// "6".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>These <em>getters</em> are just another kind of method—one without a parameter
|
<p>These <em>getters</em> are just another kind of method—one without a parameter
|
||||||
list. You can define them like so:</p>
|
list. You can define them like so:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="n">isFancy</span> <span class="p">{</span> <span class="kc">true</span> <span class="p">}</span> <span class="c1">// Unicorns are always fancy.</span>
|
<span class="n">isFancy</span> <span class="p">{</span> <span class="kc">true</span> <span class="p">}</span> <span class="c1">// Unicorns are always fancy.</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -145,14 +145,14 @@ list. You can define them like so:</p>
|
|||||||
<p>Whether or not a method name has parentheses is also part of its signature.
|
<p>Whether or not a method name has parentheses is also part of its signature.
|
||||||
This lets you distinguish between a method that takes an <em>empty</em> argument list
|
This lets you distinguish between a method that takes an <em>empty</em> argument list
|
||||||
(<code>()</code>) and no argument list at all:</p>
|
(<code>()</code>) and no argument list at all:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Confusing</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Confusing</span> <span class="p">{</span>
|
||||||
<span class="n">method</span> <span class="p">{</span> <span class="s2">"no argument list"</span> <span class="p">}</span>
|
<span class="n">method</span> <span class="p">{</span> <span class="s">"no argument list"</span> <span class="p">}</span>
|
||||||
<span class="n">method</span><span class="p">()</span> <span class="p">{</span> <span class="s2">"empty argument list"</span> <span class="p">}</span>
|
<span class="n">method</span><span class="p">()</span> <span class="p">{</span> <span class="s">"empty argument list"</span> <span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">var</span> <span class="n">confusing</span> <span class="o">=</span> <span class="n">Confusing</span><span class="p">.</span><span class="k">new</span><span class="p">()</span>
|
<span class="k">var</span> <span class="n">confusing</span> <span class="o">=</span> <span class="vg">Confusing</span><span class="o">.</span><span class="n">new</span><span class="p">()</span>
|
||||||
<span class="n">confusing</span><span class="p">.</span><span class="n">method</span> <span class="c1">// "no argument list".</span>
|
<span class="n">confusing</span><span class="o">.</span><span class="n">method</span> <span class="c1">// "no argument list".</span>
|
||||||
<span class="n">confusing</span><span class="p">.</span><span class="n">method</span><span class="p">()</span> <span class="c1">// "empty argument list".</span>
|
<span class="n">confusing</span><span class="o">.</span><span class="n">method</span><span class="p">()</span> <span class="c1">// "empty argument list".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -162,23 +162,23 @@ ensures that the way you <em>declare</em> the method is the way you <em>call</em
|
|||||||
<p>Unlike other languages with "optional parentheses", Wren wants to make sure you
|
<p>Unlike other languages with "optional parentheses", Wren wants to make sure you
|
||||||
call a getter like a getter and a <code>()</code> method like a <code>()</code> method. These don't
|
call a getter like a getter and a <code>()</code> method like a <code>()</code> method. These don't
|
||||||
work:</p>
|
work:</p>
|
||||||
<div class="codehilite"><pre><span class="s2">"string"</span><span class="p">.</span><span class="n">count</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="s">"string"</span><span class="o">.</span><span class="n">count</span><span class="p">()</span>
|
||||||
<span class="n">list</span><span class="p">.</span><span class="n">clear</span>
|
<span class="n">list</span><span class="o">.</span><span class="n">clear</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Methods that don't need arguments and don't modify the underlying object are
|
<p>Methods that don't need arguments and don't modify the underlying object are
|
||||||
usually getters:</p>
|
usually getters:</p>
|
||||||
<div class="codehilite"><pre><span class="s2">"string"</span><span class="p">.</span><span class="n">count</span>
|
<div class="codehilite"><pre><span class="s">"string"</span><span class="o">.</span><span class="n">count</span>
|
||||||
<span class="p">(</span><span class="m">1.</span><span class="p">.</span><span class="m">10</span><span class="p">).</span><span class="n">min</span>
|
<span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">10</span><span class="p">)</span><span class="o">.</span><span class="n">min</span>
|
||||||
<span class="m">1.23</span><span class="p">.</span><span class="n">sin</span>
|
<span class="mf">1.23</span><span class="o">.</span><span class="n">sin</span>
|
||||||
<span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">isEmpty</span>
|
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">isEmpty</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>When a method doesn't need any parameters, but does modify the object, it's
|
<p>When a method doesn't need any parameters, but does modify the object, it's
|
||||||
helpful to draw attention to that by requiring an empty set of parentheses:</p>
|
helpful to draw attention to that by requiring an empty set of parentheses:</p>
|
||||||
<div class="codehilite"><pre><span class="n">list</span><span class="p">.</span><span class="n">clear</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="n">list</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -194,15 +194,15 @@ in the zero-argument case to be consistent with the other versions:</p>
|
|||||||
(or only operand in the case of unary operators like <code>!</code> and <code>~</code>). In other
|
(or only operand in the case of unary operators like <code>!</code> and <code>~</code>). In other
|
||||||
words, you can think of <code>a + b</code> as meaning <code>a.+(b)</code>.</p>
|
words, you can think of <code>a + b</code> as meaning <code>a.+(b)</code>.</p>
|
||||||
<p>You can define operators in your class like so:</p>
|
<p>You can define operators in your class like so:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="c1">// Infix:</span>
|
<span class="c1">// Infix:</span>
|
||||||
<span class="o">+</span><span class="p">(</span><span class="n">other</span><span class="p">)</span> <span class="p">{</span>
|
<span class="o">+</span><span class="p">(</span><span class="n">other</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Adding to a unicorn?"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Adding to a unicorn?"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="c1">// Prefix:</span>
|
<span class="c1">// Prefix:</span>
|
||||||
<span class="o">!</span> <span class="p">{</span>
|
<span class="o">!</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Negating a unicorn?!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Negating a unicorn?!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -228,9 +228,9 @@ overloading by arity, it's no problem for a class to define both.</p>
|
|||||||
<p>Unicorns can prance around now, but we don't actually <em>have</em> any unicorns to do
|
<p>Unicorns can prance around now, but we don't actually <em>have</em> any unicorns to do
|
||||||
it. To create instances of a class, we need a <em>constructor</em>. You can define one
|
it. To create instances of a class, we need a <em>constructor</em>. You can define one
|
||||||
like so:</p>
|
like so:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="n">construct</span> <span class="k">new</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">color</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">construct</span> <span class="n">new</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">color</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s2">" and I am "</span> <span class="o">+</span> <span class="n">color</span> <span class="o">+</span> <span class="s2">"."</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s">" and I am "</span> <span class="o">+</span> <span class="n">color</span> <span class="o">+</span> <span class="s">"."</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -240,19 +240,19 @@ like so:</p>
|
|||||||
name. In Wren, all constructors have names, just like [methods][#methods]. The
|
name. In Wren, all constructors have names, just like [methods][#methods]. The
|
||||||
word "new" isn't special to Wren, it's just a common constructor name.</p>
|
word "new" isn't special to Wren, it's just a common constructor name.</p>
|
||||||
<p>To make a unicorn now, we just call the constructor method on the class itself:</p>
|
<p>To make a unicorn now, we just call the constructor method on the class itself:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fred</span> <span class="o">=</span> <span class="n">Unicorn</span><span class="p">.</span><span class="k">new</span><span class="p">(</span><span class="s2">"Fred"</span><span class="p">,</span> <span class="s2">"palomino"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fred</span> <span class="o">=</span> <span class="vg">Unicorn</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s">"Fred"</span><span class="p">,</span> <span class="s">"palomino"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Giving constructors names is handy because it means you can have more than one,
|
<p>Giving constructors names is handy because it means you can have more than one,
|
||||||
and each can clarify how it creates the instance:</p>
|
and each can clarify how it creates the instance:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="n">construct</span> <span class="n">brown</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">construct</span> <span class="n">brown</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s2">" and I am brown."</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s">" and I am brown."</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">var</span> <span class="n">dave</span> <span class="o">=</span> <span class="n">Unicorn</span><span class="p">.</span><span class="n">brown</span><span class="p">(</span><span class="s2">"Dave"</span><span class="p">)</span>
|
<span class="k">var</span> <span class="n">dave</span> <span class="o">=</span> <span class="vg">Unicorn</span><span class="o">.</span><span class="n">brown</span><span class="p">(</span><span class="s">"Dave"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -266,7 +266,7 @@ overloaded by <a href="#signature">arity</a>. A constructor <em>must</em> be a n
|
|||||||
a (possibly empty) argument list. Operators, getters, and setters cannot be
|
a (possibly empty) argument list. Operators, getters, and setters cannot be
|
||||||
constructors.</p>
|
constructors.</p>
|
||||||
<p>A constructor is actually a pair of methods. You get a method on the class:</p>
|
<p>A constructor is actually a pair of methods. You get a method on the class:</p>
|
||||||
<div class="codehilite"><pre><span class="n">Unicorn</span><span class="p">.</span><span class="n">brown</span><span class="p">(</span><span class="s2">"Dave"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">Unicorn</span><span class="o">.</span><span class="n">brown</span><span class="p">(</span><span class="s">"Dave"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -278,8 +278,8 @@ constructors, etc.</p>
|
|||||||
<h2>Fields <a href="#fields" name="fields" class="header-anchor">#</a></h2>
|
<h2>Fields <a href="#fields" name="fields" class="header-anchor">#</a></h2>
|
||||||
<p>All state stored in instances is stored in <em>fields</em>. Each field has a named
|
<p>All state stored in instances is stored in <em>fields</em>. Each field has a named
|
||||||
that starts with an underscore.</p>
|
that starts with an underscore.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Rectangle</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Rectangle</span> <span class="p">{</span>
|
||||||
<span class="n">area</span> <span class="p">{</span> <span class="n">_width</span> <span class="o">*</span> <span class="n">_height</span> <span class="p">}</span>
|
<span class="n">area</span> <span class="p">{</span> <span class="vi">_width</span> <span class="o">*</span> <span class="vi">_height</span> <span class="p">}</span>
|
||||||
|
|
||||||
<span class="c1">// Other stuff...</span>
|
<span class="c1">// Other stuff...</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
@ -303,9 +303,9 @@ accessed from within methods defined on the object's class. You cannot even
|
|||||||
access fields on another instance of your own class, unlike C++ and Java.</p>
|
access fields on another instance of your own class, unlike C++ and Java.</p>
|
||||||
<p>If you want to make a property of an object visible, you need to define a
|
<p>If you want to make a property of an object visible, you need to define a
|
||||||
getter to expose it:</p>
|
getter to expose it:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Rectangle</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Rectangle</span> <span class="p">{</span>
|
||||||
<span class="n">width</span> <span class="p">{</span> <span class="n">_width</span> <span class="p">}</span>
|
<span class="n">width</span> <span class="p">{</span> <span class="vi">_width</span> <span class="p">}</span>
|
||||||
<span class="n">height</span> <span class="p">{</span> <span class="n">_height</span> <span class="p">}</span>
|
<span class="n">height</span> <span class="p">{</span> <span class="vi">_height</span> <span class="p">}</span>
|
||||||
|
|
||||||
<span class="c1">// ...</span>
|
<span class="c1">// ...</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
@ -313,9 +313,9 @@ getter to expose it:</p>
|
|||||||
|
|
||||||
|
|
||||||
<p>To allow outside code to modify the field, you'll also need to provide setters:</p>
|
<p>To allow outside code to modify the field, you'll also need to provide setters:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Rectangle</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Rectangle</span> <span class="p">{</span>
|
||||||
<span class="n">width</span><span class="o">=</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="p">{</span> <span class="n">_width</span> <span class="o">=</span> <span class="n">value</span> <span class="p">}</span>
|
<span class="n">width</span><span class="o">=</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="p">{</span> <span class="vi">_width</span> <span class="o">=</span> <span class="n">value</span> <span class="p">}</span>
|
||||||
<span class="n">height</span><span class="o">=</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="p">{</span> <span class="n">_height</span> <span class="o">=</span> <span class="n">value</span> <span class="p">}</span>
|
<span class="n">height</span><span class="o">=</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="p">{</span> <span class="vi">_height</span> <span class="o">=</span> <span class="n">value</span> <span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -330,43 +330,43 @@ to or even should define getters or setters for most of your object's fields.</p
|
|||||||
<p>A name that starts with <em>two</em> underscores is a <em>static</em> field. They work
|
<p>A name that starts with <em>two</em> underscores is a <em>static</em> field. They work
|
||||||
similar to <a href="#fields">fields</a> except the data is stored on the class itself, and
|
similar to <a href="#fields">fields</a> except the data is stored on the class itself, and
|
||||||
not the instance. They can be used in <em>both</em> instance and static methods.</p>
|
not the instance. They can be used in <em>both</em> instance and static methods.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Foo</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Foo</span> <span class="p">{</span>
|
||||||
<span class="c1">// Set the static field.</span>
|
<span class="c1">// Set the static field.</span>
|
||||||
<span class="kd">static</span> <span class="kd">set</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">static</span> <span class="n">set</span><span class="p">(</span><span class="err">a</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">__a</span> <span class="o">=</span> <span class="n">a</span>
|
<span class="vc">__a</span> <span class="o">=</span> <span class="err">a</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">setFromInstance</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">setFromInstance</span><span class="p">(</span><span class="err">a</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">__a</span> <span class="o">=</span> <span class="n">a</span>
|
<span class="vc">__a</span> <span class="o">=</span> <span class="err">a</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="c1">// Can use __a in both static methods...</span>
|
<span class="c1">// Can use __a in both static methods...</span>
|
||||||
<span class="kd">static</span> <span class="n">bar</span> <span class="p">{</span> <span class="n">__a</span> <span class="p">}</span>
|
<span class="k">static</span> <span class="n">bar</span> <span class="p">{</span> <span class="vc">__a</span> <span class="p">}</span>
|
||||||
|
|
||||||
<span class="c1">// ...and instance ones.</span>
|
<span class="c1">// ...and instance ones.</span>
|
||||||
<span class="n">baz</span> <span class="p">{</span> <span class="n">__a</span> <span class="p">}</span>
|
<span class="n">baz</span> <span class="p">{</span> <span class="vc">__a</span> <span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Just like instance fields, static fields are initially <code>null</code>:</p>
|
<p>Just like instance fields, static fields are initially <code>null</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Foo</span><span class="p">.</span><span class="n">bar</span><span class="p">)</span> <span class="c1">// null.</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Foo</span><span class="o">.</span><span class="n">bar</span><span class="p">)</span> <span class="c1">// null.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>They can be used from static methods:</p>
|
<p>They can be used from static methods:</p>
|
||||||
<div class="codehilite"><pre><span class="n">Foo</span><span class="p">.</span><span class="kd">set</span><span class="p">(</span><span class="s2">"foo"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">Foo</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="s">"foo"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Foo</span><span class="p">.</span><span class="n">bar</span><span class="p">)</span> <span class="c1">// foo.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Foo</span><span class="o">.</span><span class="n">bar</span><span class="p">)</span> <span class="c1">// foo.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>And also instance methods. When you do so, there is still only one static field
|
<p>And also instance methods. When you do so, there is still only one static field
|
||||||
shared among all instances of the class:</p>
|
shared among all instances of the class:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">foo1</span> <span class="o">=</span> <span class="n">Foo</span><span class="p">.</span><span class="k">new</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">foo1</span> <span class="o">=</span> <span class="vg">Foo</span><span class="o">.</span><span class="n">new</span><span class="p">()</span>
|
||||||
<span class="kd">var</span> <span class="n">foo2</span> <span class="o">=</span> <span class="n">Foo</span><span class="p">.</span><span class="k">new</span><span class="p">()</span>
|
<span class="k">var</span> <span class="n">foo2</span> <span class="o">=</span> <span class="vg">Foo</span><span class="o">.</span><span class="n">new</span><span class="p">()</span>
|
||||||
|
|
||||||
<span class="n">foo1</span><span class="p">.</span><span class="n">setFromInstance</span><span class="p">(</span><span class="s2">"updated"</span><span class="p">)</span>
|
<span class="n">foo1</span><span class="o">.</span><span class="n">setFromInstance</span><span class="p">(</span><span class="s">"updated"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">foo2</span><span class="p">.</span><span class="n">baz</span><span class="p">)</span> <span class="c1">// updated.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">foo2</span><span class="o">.</span><span class="n">baz</span><span class="p">)</span> <span class="c1">// updated.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -377,7 +377,7 @@ superclasses looking for it there.</p>
|
|||||||
<p>By default, any new class inherits from <code>Object</code>, which is the superclass from
|
<p>By default, any new class inherits from <code>Object</code>, which is the superclass from
|
||||||
which all other classes ultimately descend. You can specify a different parent
|
which all other classes ultimately descend. You can specify a different parent
|
||||||
class using <code>is</code> when you declare the class:</p>
|
class using <code>is</code> when you declare the class:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Pegasus</span> <span class="k">is</span> <span class="n">Unicorn</span> <span class="p">{}</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Pegasus</span> <span class="k">is</span> <span class="vg">Unicorn</span> <span class="p">{}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -387,27 +387,27 @@ class using <code>is</code> when you declare the class:</p>
|
|||||||
<code>Pegasus</code> inherits from <code>Unicorn</code>, <code>Pegasus</code>'s metaclass will not inherit from
|
<code>Pegasus</code> inherits from <code>Unicorn</code>, <code>Pegasus</code>'s metaclass will not inherit from
|
||||||
<code>Unicorn</code>'s metaclass. In more prosaic terms, this means that static methods
|
<code>Unicorn</code>'s metaclass. In more prosaic terms, this means that static methods
|
||||||
are not inherited.</p>
|
are not inherited.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="c1">// Unicorns cannot fly. :(</span>
|
<span class="c1">// Unicorns cannot fly. :(</span>
|
||||||
<span class="kd">static</span> <span class="n">canFly</span> <span class="p">{</span> <span class="kc">false</span> <span class="p">}</span>
|
<span class="k">static</span> <span class="n">canFly</span> <span class="p">{</span> <span class="kc">false</span> <span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">class</span> <span class="nc">Pegasus</span> <span class="k">is</span> <span class="n">Unicorn</span> <span class="p">{}</span>
|
<span class="k">class</span> <span class="vg">Pegasus</span> <span class="k">is</span> <span class="vg">Unicorn</span> <span class="p">{}</span>
|
||||||
|
|
||||||
<span class="n">Pegasus</span><span class="p">.</span><span class="n">canFly</span> <span class="c1">// ERROR: Static methods are not inherited.</span>
|
<span class="vg">Pegasus</span><span class="o">.</span><span class="n">canFly</span> <span class="c1">// ERROR: Static methods are not inherited.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>This also means constructors are not inherited:</p>
|
<p>This also means constructors are not inherited:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="k">this</span> <span class="k">new</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
<span class="nb">this</span> <span class="n">new</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s2">"."</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s">"."</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">class</span> <span class="nc">Pegasus</span> <span class="k">is</span> <span class="n">Unicorn</span> <span class="p">{}</span>
|
<span class="k">class</span> <span class="vg">Pegasus</span> <span class="k">is</span> <span class="vg">Unicorn</span> <span class="p">{}</span>
|
||||||
|
|
||||||
<span class="n">Pegasus</span><span class="p">.</span><span class="k">new</span><span class="p">(</span><span class="s2">"Fred"</span><span class="p">)</span> <span class="c1">// Error!</span>
|
<span class="vg">Pegasus</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s">"Fred"</span><span class="p">)</span> <span class="c1">// Error!</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -415,19 +415,19 @@ are not inherited.</p>
|
|||||||
classes. However, constructor <em>initializers</em> are inherited since those are
|
classes. However, constructor <em>initializers</em> are inherited since those are
|
||||||
instance methods on the new object.</p>
|
instance methods on the new object.</p>
|
||||||
<p>This means you can do <code>super</code> calls inside a constructor:</p>
|
<p>This means you can do <code>super</code> calls inside a constructor:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Unicorn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="k">this</span> <span class="k">new</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
<span class="nb">this</span> <span class="n">new</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s2">"."</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"My name is "</span> <span class="o">+</span> <span class="n">name</span> <span class="o">+</span> <span class="s">"."</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">class</span> <span class="nc">Pegasus</span> <span class="k">is</span> <span class="n">Unicorn</span> <span class="p">{</span>
|
<span class="k">class</span> <span class="vg">Pegasus</span> <span class="k">is</span> <span class="vg">Unicorn</span> <span class="p">{</span>
|
||||||
<span class="k">this</span> <span class="k">new</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
<span class="nb">this</span> <span class="n">new</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="k">super</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
|
<span class="k">super</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">Pegasus</span><span class="p">.</span><span class="k">new</span><span class="p">(</span><span class="s2">"Fred"</span><span class="p">)</span> <span class="c1">// Prints "My name is Fred.".</span>
|
<span class="vg">Pegasus</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="s">"Fred"</span><span class="p">)</span> <span class="c1">// Prints "My name is Fred.".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
@ -83,7 +83,39 @@ the system and highlight problems and missing features.</p>
|
|||||||
significant change or addition, please file a <a href="https://github.com/munificent/wren/labels/proposal">proposal</a> to discuss it
|
significant change or addition, please file a <a href="https://github.com/munificent/wren/labels/proposal">proposal</a> to discuss it
|
||||||
before writing lots of code. Wren tries very <em>very</em> hard to be minimal which
|
before writing lots of code. Wren tries very <em>very</em> hard to be minimal which
|
||||||
means often having to say "no" to language additions, even really cool ones.</p>
|
means often having to say "no" to language additions, even really cool ones.</p>
|
||||||
<h2>Making a change <a href="#making-a-change" name="making-a-change" class="header-anchor">#</a></h2>
|
<h2>Hacking on docs <a href="#hacking-on-docs" name="hacking-on-docs" class="header-anchor">#</a></h2>
|
||||||
|
<p>The <a href="/">documentation</a> is one of the easiest—and most
|
||||||
|
important!—parts of Wren to contribute to. The source for the site is
|
||||||
|
written in <a href="http://daringfireball.net/projects/markdown/">Markdown</a> (and a little <a href="http://sass-lang.com/">SASS</a>) and lives under <code>doc/site</code>. A
|
||||||
|
simple Python script, <code>util/generate_docs.py</code>, converts that to HTML and CSS.</p>
|
||||||
|
<p>The site uses <a href="http://pygments.org">Pygments</a> for syntax highlighting, with a custom lexer plug-in
|
||||||
|
for Wren. To install that, run:</p>
|
||||||
|
<div class="codehilite"><pre><span class="nv">$ </span><span class="nb">cd </span>util/pygments-lexer
|
||||||
|
<span class="nv">$ </span>sudo python setup.py develop
|
||||||
|
<span class="nv">$ </span><span class="nb">cd</span> ../.. <span class="c"># Back to the root Wren directory.</span>
|
||||||
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
<p>Now you can build the docs:</p>
|
||||||
|
<div class="codehilite"><pre><span class="nv">$ </span>make docs
|
||||||
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
<p>This generates the site in <code>build/docs/</code>. You can run any simple static web
|
||||||
|
server from there. Python includes one:</p>
|
||||||
|
<div class="codehilite"><pre><span class="nv">$ </span><span class="nb">cd </span>build/docs
|
||||||
|
<span class="nv">$ </span>python -m SimpleHTTPServer
|
||||||
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
<p>Running <code>make docs</code> is a drag every time you change a line of Markdown or SASS,
|
||||||
|
so there is also a file watching version that will automatically regenerate the
|
||||||
|
docs when you edit a file:</p>
|
||||||
|
<div class="codehilite"><pre><span class="nv">$ </span>make watchdocs
|
||||||
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
<h2>Hacking on the VM <a href="#hacking-on-the-vm" name="hacking-on-the-vm" class="header-anchor">#</a></h2>
|
||||||
<p>The basic process is simple:</p>
|
<p>The basic process is simple:</p>
|
||||||
<ol>
|
<ol>
|
||||||
<li>
|
<li>
|
||||||
|
|||||||
@ -82,7 +82,7 @@ values.</p>
|
|||||||
<h2>If statements <a href="#if-statements" name="if-statements" class="header-anchor">#</a></h2>
|
<h2>If statements <a href="#if-statements" name="if-statements" class="header-anchor">#</a></h2>
|
||||||
<p>The simplest branching statement, <code>if</code> lets you conditionally skip a chunk of
|
<p>The simplest branching statement, <code>if</code> lets you conditionally skip a chunk of
|
||||||
code. It looks like this:</p>
|
code. It looks like this:</p>
|
||||||
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"go!"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"go!"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -90,23 +90,23 @@ code. It looks like this:</p>
|
|||||||
statement after the condition is evaluated. Otherwise it is skipped. Instead of
|
statement after the condition is evaluated. Otherwise it is skipped. Instead of
|
||||||
a statement, you can have a <a href="syntax.html#blocks">block</a>:</p>
|
a statement, you can have a <a href="syntax.html#blocks">block</a>:</p>
|
||||||
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"getSet"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"getSet"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"go!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"go!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>You may also provide an <code>else</code> branch. It will be executed if the condition is
|
<p>You may also provide an <code>else</code> branch. It will be executed if the condition is
|
||||||
false:</p>
|
false:</p>
|
||||||
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"go!"</span><span class="p">)</span> <span class="k">else</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"not ready!"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"go!"</span><span class="p">)</span> <span class="k">else</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"not ready!"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>And, of course, it can take a block too:</p>
|
<p>And, of course, it can take a block too:</p>
|
||||||
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">ready</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"go!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"go!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
|
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"not ready!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"not ready!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -118,12 +118,12 @@ they should be familiar if you've used other imperative languages.</p>
|
|||||||
<p>The simplest, a <code>while</code> statement executes a chunk of code as long as a
|
<p>The simplest, a <code>while</code> statement executes a chunk of code as long as a
|
||||||
condition continues to hold. For example:</p>
|
condition continues to hold. For example:</p>
|
||||||
<div class="codehilite"><pre><span class="c1">// Hailstone sequence.</span>
|
<div class="codehilite"><pre><span class="c1">// Hailstone sequence.</span>
|
||||||
<span class="kd">var</span> <span class="n">n</span> <span class="o">=</span> <span class="m">27</span>
|
<span class="k">var</span> <span class="err">n</span> <span class="o">=</span> <span class="mi">27</span>
|
||||||
<span class="k">while</span> <span class="p">(</span><span class="n">n</span> <span class="o">!=</span> <span class="m">1</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">while</span> <span class="p">(</span><span class="err">n</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="k">if</span> <span class="p">(</span><span class="n">n</span> <span class="o">%</span> <span class="m">2</span> <span class="o">==</span> <span class="m">0</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">if</span> <span class="p">(</span><span class="err">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">n</span> <span class="o">=</span> <span class="n">n</span> <span class="o">/</span> <span class="m">2</span>
|
<span class="err">n</span> <span class="o">=</span> <span class="err">n</span> <span class="o">/</span> <span class="mi">2</span>
|
||||||
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
|
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
|
||||||
<span class="n">n</span> <span class="o">=</span> <span class="m">3</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="m">1</span>
|
<span class="err">n</span> <span class="o">=</span> <span class="mi">3</span> <span class="o">*</span> <span class="err">n</span> <span class="o">+</span> <span class="mi">1</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -136,8 +136,8 @@ something true.</p>
|
|||||||
<p>The condition for a while loop can be any expression, and must be surrounded by
|
<p>The condition for a while loop can be any expression, and must be surrounded by
|
||||||
parentheses. The body of the loop is usually a curly block but can also be a
|
parentheses. The body of the loop is usually a curly block but can also be a
|
||||||
single statement:</p>
|
single statement:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">n</span> <span class="o">=</span> <span class="m">27</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">n</span> <span class="o">=</span> <span class="mi">27</span>
|
||||||
<span class="k">while</span> <span class="p">(</span><span class="n">n</span> <span class="o">!=</span> <span class="m">1</span><span class="p">)</span> <span class="k">if</span> <span class="p">(</span><span class="n">n</span> <span class="o">%</span> <span class="m">2</span> <span class="o">==</span> <span class="m">0</span><span class="p">)</span> <span class="n">n</span> <span class="o">=</span> <span class="n">n</span> <span class="o">/</span> <span class="m">2</span> <span class="k">else</span> <span class="n">n</span> <span class="o">=</span> <span class="m">3</span> <span class="o">*</span> <span class="n">n</span> <span class="o">+</span> <span class="m">1</span>
|
<span class="k">while</span> <span class="p">(</span><span class="err">n</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">)</span> <span class="k">if</span> <span class="p">(</span><span class="err">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="err">n</span> <span class="o">=</span> <span class="err">n</span> <span class="o">/</span> <span class="mi">2</span> <span class="k">else</span> <span class="err">n</span> <span class="o">=</span> <span class="mi">3</span> <span class="o">*</span> <span class="err">n</span> <span class="o">+</span> <span class="mi">1</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -146,8 +146,8 @@ single statement:</p>
|
|||||||
some complex condition. But in most cases, you're looping through a
|
some complex condition. But in most cases, you're looping through a
|
||||||
<a href="lists.html">list</a>, a series of numbers, or some other "sequence" object.
|
<a href="lists.html">list</a>, a series of numbers, or some other "sequence" object.
|
||||||
That's what <code>for</code> is for. It looks like this:</p>
|
That's what <code>for</code> is for. It looks like this:</p>
|
||||||
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">beatle</span> <span class="k">in</span> <span class="p">[</span><span class="s2">"george"</span><span class="p">,</span> <span class="s2">"john"</span><span class="p">,</span> <span class="s2">"paul"</span><span class="p">,</span> <span class="s2">"ringo"</span><span class="p">])</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">beatle</span> <span class="k">in</span> <span class="p">[</span><span class="s">"george"</span><span class="p">,</span> <span class="s">"john"</span><span class="p">,</span> <span class="s">"paul"</span><span class="p">,</span> <span class="s">"ringo"</span><span class="p">])</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">beatle</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">beatle</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -173,9 +173,9 @@ That's what <code>for</code> is for. It looks like this:</p>
|
|||||||
and stop. To do that, you can use a <code>break</code> statement. It's just the <code>break</code>
|
and stop. To do that, you can use a <code>break</code> statement. It's just the <code>break</code>
|
||||||
keyword all by itself. That will immediately exit out of the nearest enclosing
|
keyword all by itself. That will immediately exit out of the nearest enclosing
|
||||||
<code>while</code> or <code>for</code> loop.</p>
|
<code>while</code> or <code>for</code> loop.</p>
|
||||||
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">i</span> <span class="k">in</span> <span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">,</span> <span class="m">4</span><span class="p">])</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="err">i</span> <span class="k">in</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">i</span><span class="p">)</span>
|
||||||
<span class="k">if</span> <span class="p">(</span><span class="n">i</span> <span class="o">==</span> <span class="m">3</span><span class="p">)</span> <span class="k">break</span>
|
<span class="k">if</span> <span class="p">(</span><span class="err">i</span> <span class="o">==</span> <span class="mi">3</span><span class="p">)</span> <span class="k">break</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -185,16 +185,16 @@ keyword all by itself. That will immediately exit out of the nearest enclosing
|
|||||||
<p>Lists are one common use for <code>for</code> loops, but sometimes you want to walk over a
|
<p>Lists are one common use for <code>for</code> loops, but sometimes you want to walk over a
|
||||||
sequence of numbers, or loop a number of times. For that, you can create a
|
sequence of numbers, or loop a number of times. For that, you can create a
|
||||||
<a href="values.html#ranges">range</a>, like so:</p>
|
<a href="values.html#ranges">range</a>, like so:</p>
|
||||||
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">i</span> <span class="k">in</span> <span class="m">1.</span><span class="p">.</span><span class="m">100</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="err">i</span> <span class="k">in</span> <span class="mi">1</span><span class="o">..</span><span class="mi">100</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">i</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>This loops over the numbers from 1 to 100, including 100 itself. If you want to
|
<p>This loops over the numbers from 1 to 100, including 100 itself. If you want to
|
||||||
leave off the last value, use three dots instead of two:</p>
|
leave off the last value, use three dots instead of two:</p>
|
||||||
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">i</span> <span class="k">in</span> <span class="m">1.</span><span class="p">..</span><span class="m">100</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="err">i</span> <span class="k">in</span> <span class="mi">1</span><span class="o">...</span><span class="mi">100</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">i</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -212,18 +212,18 @@ are defined in terms of an "iterator protocol". The loop itself doesn't know
|
|||||||
anything about lists or ranges, it just knows how to call two particular
|
anything about lists or ranges, it just knows how to call two particular
|
||||||
methods on the object that resulted from evaluating the sequence expression.</p>
|
methods on the object that resulted from evaluating the sequence expression.</p>
|
||||||
<p>When you write a loop like this:</p>
|
<p>When you write a loop like this:</p>
|
||||||
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">i</span> <span class="k">in</span> <span class="m">1.</span><span class="p">.</span><span class="m">100</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="err">i</span> <span class="k">in</span> <span class="mi">1</span><span class="o">..</span><span class="mi">100</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">i</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Wren sees it something like this:</p>
|
<p>Wren sees it something like this:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">iter_</span> <span class="o">=</span> <span class="kc">null</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">iter_</span> <span class="o">=</span> <span class="kc">null</span>
|
||||||
<span class="kd">var</span> <span class="n">seq_</span> <span class="o">=</span> <span class="m">1.</span><span class="p">.</span><span class="m">100</span>
|
<span class="k">var</span> <span class="n">seq_</span> <span class="o">=</span> <span class="mi">1</span><span class="o">..</span><span class="mi">100</span>
|
||||||
<span class="k">while</span> <span class="p">(</span><span class="n">iter_</span> <span class="o">=</span> <span class="n">seq_</span><span class="p">.</span><span class="n">iterate</span><span class="p">(</span><span class="n">iter_</span><span class="p">))</span> <span class="p">{</span>
|
<span class="k">while</span> <span class="p">(</span><span class="n">iter_</span> <span class="o">=</span> <span class="n">seq_</span><span class="o">.</span><span class="n">iterate</span><span class="p">(</span><span class="n">iter_</span><span class="p">))</span> <span class="p">{</span>
|
||||||
<span class="kd">var</span> <span class="n">i</span> <span class="o">=</span> <span class="n">seq_</span><span class="p">.</span><span class="n">iteratorValue</span><span class="p">(</span><span class="n">iter_</span><span class="p">)</span>
|
<span class="k">var</span> <span class="err">i</span> <span class="o">=</span> <span class="n">seq_</span><span class="o">.</span><span class="n">iteratorValue</span><span class="p">(</span><span class="n">iter_</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">i</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -48,10 +48,8 @@
|
|||||||
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
||||||
<h3><strong>!</strong> operator <a href="#-operator" name="-operator" class="header-anchor">#</a></h3>
|
<h3><strong>!</strong> operator <a href="#-operator" name="-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Returns the logical complement of the value.</p>
|
<p>Returns the logical complement of the value.</p>
|
||||||
<div class="codehilite"><pre>> !true
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="o">!</span><span class="kc">true</span><span class="p">)</span> <span class="c1">// "false".</span>
|
||||||
false
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="o">!</span><span class="kc">false</span><span class="p">)</span> <span class="c1">// "true".</span>
|
||||||
> !false
|
|
||||||
true
|
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -49,20 +49,20 @@
|
|||||||
<p>The name of the class.</p>
|
<p>The name of the class.</p>
|
||||||
<h3><strong>supertype</strong> <a href="#supertype" name="supertype" class="header-anchor">#</a></h3>
|
<h3><strong>supertype</strong> <a href="#supertype" name="supertype" class="header-anchor">#</a></h3>
|
||||||
<p>The superclass of this class.</p>
|
<p>The superclass of this class.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Crustacean</span> <span class="p">{}</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Crustacean</span> <span class="p">{}</span>
|
||||||
<span class="kd">class</span> <span class="nc">Crab</span> <span class="k">is</span> <span class="n">Crustacean</span> <span class="p">{}</span>
|
<span class="k">class</span> <span class="vg">Crab</span> <span class="k">is</span> <span class="vg">Crustacean</span> <span class="p">{}</span>
|
||||||
|
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Crab</span><span class="p">.</span><span class="n">supertype</span><span class="p">)</span> <span class="c1">// "Crustacean"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Crab</span><span class="o">.</span><span class="n">supertype</span><span class="p">)</span> <span class="c1">// "Crustacean".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>A class with no explicit superclass implicitly inherits Object:</p>
|
<p>A class with no explicit superclass implicitly inherits Object:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Crustacean</span><span class="p">.</span><span class="n">supertype</span><span class="p">)</span> <span class="c1">// "Object"</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Crustacean</span><span class="o">.</span><span class="n">supertype</span><span class="p">)</span> <span class="c1">// "Object".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Object forms the root of the class hierarchy and has no supertype:</p>
|
<p>Object forms the root of the class hierarchy and has no supertype:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="kt">Object</span><span class="p">.</span><span class="n">supertype</span><span class="p">)</span> <span class="c1">// "null"</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Object</span><span class="o">.</span><span class="n">supertype</span><span class="p">)</span> <span class="c1">// "null".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -48,8 +48,8 @@
|
|||||||
<h3>Fiber.<strong>new</strong>(function) <a href="#fibernew(function)" name="fibernew(function)" class="header-anchor">#</a></h3>
|
<h3>Fiber.<strong>new</strong>(function) <a href="#fibernew(function)" name="fibernew(function)" class="header-anchor">#</a></h3>
|
||||||
<p>Creates a new fiber that executes <code>function</code> in a separate coroutine when the
|
<p>Creates a new fiber that executes <code>function</code> in a separate coroutine when the
|
||||||
fiber is run. Does not immediately start running the fiber.</p>
|
fiber is run. Does not immediately start running the fiber.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"I won't get printed"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"I won't get printed"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -65,27 +65,27 @@ again. If there is still a reference to the suspended fiber, it can be resumed.<
|
|||||||
<h3>Fiber.<strong>yield</strong>() <a href="#fiberyield()" name="fiberyield()" class="header-anchor">#</a></h3>
|
<h3>Fiber.<strong>yield</strong>() <a href="#fiberyield()" name="fiberyield()" class="header-anchor">#</a></h3>
|
||||||
<p>Pauses the current fiber and transfers control to the parent fiber. "Parent"
|
<p>Pauses the current fiber and transfers control to the parent fiber. "Parent"
|
||||||
here means the last fiber that was started using <code>call</code> and not <code>run</code>.</p>
|
here means the last fiber that was started using <code>call</code> and not <code>run</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Before yield"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Before yield"</span><span class="p">)</span>
|
||||||
<span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">()</span>
|
<span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"After yield"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"After yield"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// "Before yield"</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// "Before yield"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"After call"</span><span class="p">)</span> <span class="c1">// "After call"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"After call"</span><span class="p">)</span> <span class="c1">// "After call"</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// "After yield"</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// "After yield"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>When resumed, the parent fiber's <code>call()</code> method returns <code>null</code>.</p>
|
<p>When resumed, the parent fiber's <code>call()</code> method returns <code>null</code>.</p>
|
||||||
<p>If a yielded fiber is resumed by calling <code>call()</code> or <code>run()</code> with an argument,
|
<p>If a yielded fiber is resumed by calling <code>call()</code> or <code>run()</code> with an argument,
|
||||||
<code>yield()</code> returns that value.</p>
|
<code>yield()</code> returns that value.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">())</span> <span class="c1">// "value"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">())</span> <span class="c1">// "value"</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Run until the first yield.</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Run until the first yield.</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">(</span><span class="s2">"value"</span><span class="p">)</span> <span class="c1">// Resume the fiber.</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s">"value"</span><span class="p">)</span> <span class="c1">// Resume the fiber.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -94,33 +94,33 @@ here means the last fiber that was started using <code>call</code> and not <code
|
|||||||
<p>If there is no parent fiber to return to, this exits the interpreter. This can
|
<p>If there is no parent fiber to return to, this exits the interpreter. This can
|
||||||
be useful to pause execution until the host application wants to resume it
|
be useful to pause execution until the host application wants to resume it
|
||||||
later.</p>
|
later.</p>
|
||||||
<div class="codehilite"><pre><span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"this does not get reached"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"this does not get reached"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h3>Fiber.<strong>yield</strong>(value) <a href="#fiberyield(value)" name="fiberyield(value)" class="header-anchor">#</a></h3>
|
<h3>Fiber.<strong>yield</strong>(value) <a href="#fiberyield(value)" name="fiberyield(value)" class="header-anchor">#</a></h3>
|
||||||
<p>Similar to <code>Fiber.yield</code> but provides a value to return to the parent fiber's
|
<p>Similar to <code>Fiber.yield</code> but provides a value to return to the parent fiber's
|
||||||
<code>call</code>.</p>
|
<code>call</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">(</span><span class="s2">"value"</span><span class="p">)</span>
|
<span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">(</span><span class="s">"value"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// "value"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// "value"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
||||||
<h3><strong>call</strong>() <a href="#call()" name="call()" class="header-anchor">#</a></h3>
|
<h3><strong>call</strong>() <a href="#call()" name="call()" class="header-anchor">#</a></h3>
|
||||||
<p>Starts or resumes the fiber if it is in a paused state.</p>
|
<p>Starts or resumes the fiber if it is in a paused state.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Fiber called"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Fiber called"</span><span class="p">)</span>
|
||||||
<span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">()</span>
|
<span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Fiber called again"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Fiber called again"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Start it.</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Start it.</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Resume after the yield() call.</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Resume after the yield() call.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -128,24 +128,24 @@ later.</p>
|
|||||||
called it.</p>
|
called it.</p>
|
||||||
<p>If the called fiber is resuming from a yield, the <code>yield()</code> method returns
|
<p>If the called fiber is resuming from a yield, the <code>yield()</code> method returns
|
||||||
<code>null</code> in the called fiber.</p>
|
<code>null</code> in the called fiber.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">())</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">())</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Prints "null".</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span> <span class="c1">// Prints "null".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h3><strong>call</strong>(value) <a href="#call(value)" name="call(value)" class="header-anchor">#</a></h3>
|
<h3><strong>call</strong>(value) <a href="#call(value)" name="call(value)" class="header-anchor">#</a></h3>
|
||||||
<p>Invokes the fiber or resumes the fiber if it is in a paused state and sets
|
<p>Invokes the fiber or resumes the fiber if it is in a paused state and sets
|
||||||
<code>value</code> as the returned value of the fiber's call to <code>yield</code>.</p>
|
<code>value</code> as the returned value of the fiber's call to <code>yield</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">())</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">())</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">(</span><span class="s2">"value"</span><span class="p">)</span> <span class="c1">// Prints "value".</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s">"value"</span><span class="p">)</span> <span class="c1">// Prints "value".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
16
core/fn.html
16
core/fn.html
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -51,8 +51,8 @@
|
|||||||
function, so this really just returns the argument. It exists mainly to let you
|
function, so this really just returns the argument. It exists mainly to let you
|
||||||
create a "bare" function when you don't want to immediately pass it as a <a href="../functions.html#block-arguments">block
|
create a "bare" function when you don't want to immediately pass it as a <a href="../functions.html#block-arguments">block
|
||||||
argument</a> to some other method.</p>
|
argument</a> to some other method.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fn</span> <span class="o">=</span> <span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fn</span> <span class="o">=</span> <span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"The body"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"The body"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -61,18 +61,18 @@ argument</a> to some other method.</p>
|
|||||||
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
||||||
<h3><strong>arity</strong> <a href="#arity" name="arity" class="header-anchor">#</a></h3>
|
<h3><strong>arity</strong> <a href="#arity" name="arity" class="header-anchor">#</a></h3>
|
||||||
<p>The number of arguments the function requires.</p>
|
<p>The number of arguments the function requires.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{}.</span><span class="n">arity</span><span class="p">)</span> <span class="c1">// 0.</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{}</span><span class="o">.</span><span class="n">arity</span><span class="p">)</span> <span class="c1">// 0.</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span><span class="o">|</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="o">|</span> <span class="n">a</span> <span class="p">}.</span><span class="n">arity</span><span class="p">)</span> <span class="c1">// 3.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span><span class="o">|</span><span class="err">a</span><span class="p">,</span> <span class="err">b</span><span class="p">,</span> <span class="err">c</span><span class="o">|</span> <span class="err">a</span> <span class="p">}</span><span class="o">.</span><span class="n">arity</span><span class="p">)</span> <span class="c1">// 3.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h3><strong>call</strong>(args...) <a href="#call(args)" name="call(args)" class="header-anchor">#</a></h3>
|
<h3><strong>call</strong>(args...) <a href="#call(args)" name="call(args)" class="header-anchor">#</a></h3>
|
||||||
<p>Invokes the function with the given arguments.</p>
|
<p>Invokes the function with the given arguments.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fn</span> <span class="o">=</span> <span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span> <span class="o">|</span><span class="n">arg</span><span class="o">|</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fn</span> <span class="o">=</span> <span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span> <span class="o">|</span><span class="n">arg</span><span class="o">|</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">fn</span><span class="p">.</span><span class="n">call</span><span class="p">(</span><span class="s2">"Hello world"</span><span class="p">)</span> <span class="c1">// Prints "Hello world".</span>
|
<span class="n">fn</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s">"Hello world"</span><span class="p">)</span> <span class="c1">// Prints "Hello world".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -62,7 +62,7 @@ interfaces for this.</p>
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -55,29 +55,29 @@
|
|||||||
<p>The number of elements in the list.</p>
|
<p>The number of elements in the list.</p>
|
||||||
<h3><strong>insert</strong>(index, item) <a href="#insert(index,-item)" name="insert(index,-item)" class="header-anchor">#</a></h3>
|
<h3><strong>insert</strong>(index, item) <a href="#insert(index,-item)" name="insert(index,-item)" class="header-anchor">#</a></h3>
|
||||||
<p>Inserts the <code>item</code> at <code>index</code> in the list.</p>
|
<p>Inserts the <code>item</code> at <code>index</code> in the list.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">,</span> <span class="s">"d"</span><span class="p">]</span>
|
||||||
<span class="n">list</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="s2">"e"</span><span class="p">)</span>
|
<span class="n">list</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s">"e"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, e, b, c, d]"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, e, b, c, d]".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>The <code>index</code> may be one past the last index in the list to append an element.</p>
|
<p>The <code>index</code> may be one past the last index in the list to append an element.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">]</span>
|
||||||
<span class="n">list</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="m">3</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">)</span>
|
<span class="n">list</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="s">"d"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, b, c, d]"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, b, c, d]".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>If <code>index</code> is negative, it counts backwards from the end of the list. It bases this on the length of the list <em>after</em> inserted the element, so that <code>-1</code> will append the element, not insert it before the last element.</p>
|
<p>If <code>index</code> is negative, it counts backwards from the end of the list. It bases this on the length of the list <em>after</em> inserted the element, so that <code>-1</code> will append the element, not insert it before the last element.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">]</span>
|
||||||
<span class="n">list</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="o">-</span><span class="m">1</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">)</span>
|
<span class="n">list</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="s">"d"</span><span class="p">)</span>
|
||||||
<span class="n">list</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="o">-</span><span class="m">2</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">)</span>
|
<span class="n">list</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="s">"c"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, b, c, d]"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, b, c, d]".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Returns the inserted item.</p>
|
<p>Returns the inserted item.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">([</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">].</span><span class="n">insert</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">))</span> <span class="c1">// "b".</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">]</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s">"b"</span><span class="p">))</span> <span class="c1">// "b".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -89,14 +89,14 @@ for iterating over the elements in the list.</p>
|
|||||||
<p>Removes the element at <code>index</code>. If <code>index</code> is negative, it counts backwards
|
<p>Removes the element at <code>index</code>. If <code>index</code> is negative, it counts backwards
|
||||||
from the end of the list where <code>-1</code> is the last element. All trailing elements
|
from the end of the list where <code>-1</code> is the last element. All trailing elements
|
||||||
are shifted up to fill in where the removed element was.</p>
|
are shifted up to fill in where the removed element was.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">,</span> <span class="s">"d"</span><span class="p">]</span>
|
||||||
<span class="n">list</span><span class="p">.</span><span class="n">removeAt</span><span class="p">(</span><span class="m">1</span><span class="p">)</span>
|
<span class="n">list</span><span class="o">.</span><span class="n">removeAt</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, c, d]".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, c, d]".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Returns the removed item.</p>
|
<p>Returns the removed item.</p>
|
||||||
<div class="codehilite"><pre>IO.print(["a", "b", "c"].removeAt(1)) // "b".
|
<div class="codehilite"><pre>System.print(["a", "b", "c"].removeAt(1)) // "b".
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -104,8 +104,8 @@ are shifted up to fill in where the removed element was.</p>
|
|||||||
<h3><strong>[</strong>index<strong>]</strong> operator <a href="#[index]-operator" name="[index]-operator" class="header-anchor">#</a></h3>
|
<h3><strong>[</strong>index<strong>]</strong> operator <a href="#[index]-operator" name="[index]-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Gets the element at <code>index</code>. If <code>index</code> is negative, it counts backwards from
|
<p>Gets the element at <code>index</code>. If <code>index</code> is negative, it counts backwards from
|
||||||
the end of the list where <code>-1</code> is the last element.</p>
|
the end of the list where <code>-1</code> is the last element.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">]</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">[</span><span class="m">1</span><span class="p">])</span> <span class="c1">// "b".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span> <span class="c1">// "b".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -113,9 +113,9 @@ the end of the list where <code>-1</code> is the last element.</p>
|
|||||||
<h3><strong>[</strong>index<strong>]=</strong>(item) operator <a href="#[index]=(item)-operator" name="[index]=(item)-operator" class="header-anchor">#</a></h3>
|
<h3><strong>[</strong>index<strong>]=</strong>(item) operator <a href="#[index]=(item)-operator" name="[index]=(item)-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Replaces the element at <code>index</code> with <code>item</code>. If <code>index</code> is negative, it counts
|
<p>Replaces the element at <code>index</code> with <code>item</code>. If <code>index</code> is negative, it counts
|
||||||
backwards from the end of the list where <code>-1</code> is the last element.</p>
|
backwards from the end of the list where <code>-1</code> is the last element.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">]</span>
|
||||||
<span class="n">list</span><span class="p">[</span><span class="m">1</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"new"</span>
|
<span class="n">list</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="s">"new"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, new, c]".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">list</span><span class="p">)</span> <span class="c1">// "[a, new, c]".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -71,9 +71,9 @@ multiple times in the sequence.</p>
|
|||||||
<h3><strong>[</strong>key<strong>]</strong> operator <a href="#[key]-operator" name="[key]-operator" class="header-anchor">#</a></h3>
|
<h3><strong>[</strong>key<strong>]</strong> operator <a href="#[key]-operator" name="[key]-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Gets the value associated with <code>key</code> in the map. If <code>key</code> is not present in the
|
<p>Gets the value associated with <code>key</code> in the map. If <code>key</code> is not present in the
|
||||||
map, returns <code>null</code>.</p>
|
map, returns <code>null</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">map</span> <span class="o">=</span> <span class="p">{</span><span class="s2">"george"</span><span class="o">:</span> <span class="s2">"harrison"</span><span class="p">,</span> <span class="s2">"ringo"</span><span class="o">:</span> <span class="s2">"starr"</span><span class="p">}</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">map</span> <span class="o">=</span> <span class="p">{</span><span class="s">"george"</span><span class="o">:</span> <span class="s">"harrison"</span><span class="p">,</span> <span class="s">"ringo"</span><span class="o">:</span> <span class="s">"starr"</span><span class="p">}</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">map</span><span class="p">[</span><span class="s2">"ringo"</span><span class="p">])</span> <span class="c1">// "starr".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">map</span><span class="p">[</span><span class="s">"ringo"</span><span class="p">])</span> <span class="c1">// "starr".</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">map</span><span class="p">[</span><span class="s2">"pete"</span><span class="p">])</span> <span class="c1">// "null".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">map</span><span class="p">[</span><span class="s">"pete"</span><span class="p">])</span> <span class="c1">// "null".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -47,8 +47,7 @@
|
|||||||
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
||||||
<h3><strong>!</strong> operator <a href="#-operator" name="-operator" class="header-anchor">#</a></h3>
|
<h3><strong>!</strong> operator <a href="#-operator" name="-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Returns <code>true</code>, since <code>null</code> is considered <a href="../control-flow.html#truth">false</a>.</p>
|
<p>Returns <code>true</code>, since <code>null</code> is considered <a href="../control-flow.html#truth">false</a>.</p>
|
||||||
<div class="codehilite"><pre>> !null
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="o">!</span><span class="kc">null</span><span class="p">)</span> <span class="c1">// "true".</span>
|
||||||
true
|
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -54,7 +54,7 @@
|
|||||||
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
<h2>Methods <a href="#methods" name="methods" class="header-anchor">#</a></h2>
|
||||||
<h3><strong>abs</strong> <a href="#abs" name="abs" class="header-anchor">#</a></h3>
|
<h3><strong>abs</strong> <a href="#abs" name="abs" class="header-anchor">#</a></h3>
|
||||||
<p>The absolute value of the number.</p>
|
<p>The absolute value of the number.</p>
|
||||||
<div class="codehilite"><pre><span class="o">-</span><span class="m">123.</span><span class="n">abs</span> <span class="c1">// 123</span>
|
<div class="codehilite"><pre><span class="o">-</span><span class="mi">123</span><span class="o">.</span><span class="n">abs</span> <span class="c1">// 123</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -69,8 +69,8 @@
|
|||||||
numbers to determine the quadrant of the result.</p>
|
numbers to determine the quadrant of the result.</p>
|
||||||
<h3><strong>ceil</strong> <a href="#ceil" name="ceil" class="header-anchor">#</a></h3>
|
<h3><strong>ceil</strong> <a href="#ceil" name="ceil" class="header-anchor">#</a></h3>
|
||||||
<p>Rounds the number up to the nearest integer.</p>
|
<p>Rounds the number up to the nearest integer.</p>
|
||||||
<div class="codehilite"><pre><span class="m">1.5</span><span class="p">.</span><span class="n">ceil</span> <span class="c1">// 2</span>
|
<div class="codehilite"><pre><span class="mf">1.5</span><span class="o">.</span><span class="n">ceil</span> <span class="c1">// 2</span>
|
||||||
<span class="p">(</span><span class="o">-</span><span class="m">3.2</span><span class="p">).</span><span class="n">ceil</span> <span class="c1">// -3</span>
|
<span class="p">(</span><span class="o">-</span><span class="mf">3.2</span><span class="p">)</span><span class="o">.</span><span class="n">ceil</span> <span class="c1">// -3</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -78,8 +78,8 @@ numbers to determine the quadrant of the result.</p>
|
|||||||
<p>The cosine of the number.</p>
|
<p>The cosine of the number.</p>
|
||||||
<h3><strong>floor</strong> <a href="#floor" name="floor" class="header-anchor">#</a></h3>
|
<h3><strong>floor</strong> <a href="#floor" name="floor" class="header-anchor">#</a></h3>
|
||||||
<p>Rounds the number down to the nearest integer.</p>
|
<p>Rounds the number down to the nearest integer.</p>
|
||||||
<div class="codehilite"><pre><span class="m">1.5</span><span class="p">.</span><span class="n">floor</span> <span class="c1">// 1</span>
|
<div class="codehilite"><pre><span class="mf">1.5</span><span class="o">.</span><span class="n">floor</span> <span class="c1">// 1</span>
|
||||||
<span class="p">(</span><span class="o">-</span><span class="m">3.2</span><span class="p">).</span><span class="n">floor</span> <span class="c1">// -4</span>
|
<span class="p">(</span><span class="o">-</span><span class="mf">3.2</span><span class="p">)</span><span class="o">.</span><span class="n">floor</span> <span class="c1">// -4</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -95,8 +95,8 @@ numbers to determine the quadrant of the result.</p>
|
|||||||
<p>The tangent of the number.</p>
|
<p>The tangent of the number.</p>
|
||||||
<h3><strong>-</strong> operator <a href="#--operator" name="--operator" class="header-anchor">#</a></h3>
|
<h3><strong>-</strong> operator <a href="#--operator" name="--operator" class="header-anchor">#</a></h3>
|
||||||
<p>Negates the number.</p>
|
<p>Negates the number.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="m">123</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="mi">123</span>
|
||||||
<span class="o">-</span><span class="n">a</span> <span class="c1">// -123</span>
|
<span class="o">-</span><span class="err">a</span> <span class="c1">// -123</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -127,20 +127,20 @@ unsigned values. The result is then a 32-bit unsigned number where each bit is
|
|||||||
<h3><strong>..</strong>(other) operator <a href="#(other)-operator" name="(other)-operator" class="header-anchor">#</a></h3>
|
<h3><strong>..</strong>(other) operator <a href="#(other)-operator" name="(other)-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Creates a <a href="core/range.html">Range</a> representing a consecutive range of numbers
|
<p>Creates a <a href="core/range.html">Range</a> representing a consecutive range of numbers
|
||||||
from the beginning number to the ending number.</p>
|
from the beginning number to the ending number.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">range</span> <span class="o">=</span> <span class="m">1.2</span><span class="p">..</span><span class="m">3.4</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">range</span> <span class="o">=</span> <span class="mf">1.2</span><span class="o">..</span><span class="mf">3.4</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="p">.</span><span class="n">min</span><span class="p">)</span> <span class="c1">// 1.2</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="o">.</span><span class="n">min</span><span class="p">)</span> <span class="c1">// 1.2</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="p">.</span><span class="n">max</span><span class="p">)</span> <span class="c1">// 3.4</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="o">.</span><span class="n">max</span><span class="p">)</span> <span class="c1">// 3.4</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="p">.</span><span class="n">isInclusive</span><span class="p">)</span> <span class="c1">// true</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="o">.</span><span class="n">isInclusive</span><span class="p">)</span> <span class="c1">// true</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h3><strong>...</strong>(other) operator <a href="#(other)-operator" name="(other)-operator" class="header-anchor">#</a></h3>
|
<h3><strong>...</strong>(other) operator <a href="#(other)-operator" name="(other)-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Creates a <a href="core/range.html">Range</a> representing a consecutive range of numbers
|
<p>Creates a <a href="core/range.html">Range</a> representing a consecutive range of numbers
|
||||||
from the beginning number to the ending number not including the ending number.</p>
|
from the beginning number to the ending number not including the ending number.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">range</span> <span class="o">=</span> <span class="m">1.2</span><span class="p">...</span><span class="m">3.4</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">range</span> <span class="o">=</span> <span class="mf">1.2</span><span class="o">...</span><span class="mf">3.4</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="p">.</span><span class="n">min</span><span class="p">)</span> <span class="c1">// 1.2</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="o">.</span><span class="n">min</span><span class="p">)</span> <span class="c1">// 1.2</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="p">.</span><span class="n">max</span><span class="p">)</span> <span class="c1">// 3.4</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="o">.</span><span class="n">max</span><span class="p">)</span> <span class="c1">// 3.4</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="p">.</span><span class="n">isInclusive</span><span class="p">)</span> <span class="c1">// false</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">range</span><span class="o">.</span><span class="n">isInclusive</span><span class="p">)</span> <span class="c1">// false</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
|
|||||||
@ -38,7 +38,7 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
@ -52,8 +52,8 @@ core <a href="../control-flow.html#the-iterator-protocol">iterator protocol</a>
|
|||||||
<p>Iterates over the sequence, passing each element to the function <code>predicate</code>.
|
<p>Iterates over the sequence, passing each element to the function <code>predicate</code>.
|
||||||
If it returns something <a href="../control-flow.html#truth">false</a>, stops iterating
|
If it returns something <a href="../control-flow.html#truth">false</a>, stops iterating
|
||||||
and returns the value. Otherwise, returns <code>true</code>.</p>
|
and returns the value. Otherwise, returns <code>true</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">all</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o">></span> <span class="m">2</span><span class="p">}</span> <span class="c1">// False.</span>
|
<div class="codehilite"><pre><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">all</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">></span> <span class="mi">2</span><span class="p">}</span> <span class="c1">// False.</span>
|
||||||
<span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">all</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o"><</span> <span class="m">4</span><span class="p">}</span> <span class="c1">// True.</span>
|
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">all</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o"><</span> <span class="mi">4</span><span class="p">}</span> <span class="c1">// True.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -62,8 +62,8 @@ and returns the value. Otherwise, returns <code>true</code>.</p>
|
|||||||
<p>Iterates over the sequence, passing each element to the function <code>predicate</code>.
|
<p>Iterates over the sequence, passing each element to the function <code>predicate</code>.
|
||||||
If it returns something <a href="../control-flow.html#truth">true</a>, stops iterating and
|
If it returns something <a href="../control-flow.html#truth">true</a>, stops iterating and
|
||||||
returns that value. Otherwise, returns <code>false</code>.</p>
|
returns that value. Otherwise, returns <code>false</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">any</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o"><</span> <span class="m">1</span><span class="p">}</span> <span class="c1">// False.</span>
|
<div class="codehilite"><pre><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">any</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o"><</span> <span class="mi">1</span><span class="p">}</span> <span class="c1">// False.</span>
|
||||||
<span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">any</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o">></span> <span class="m">2</span><span class="p">}</span> <span class="c1">// True.</span>
|
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">any</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">></span> <span class="mi">2</span><span class="p">}</span> <span class="c1">// True.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -77,14 +77,14 @@ sequence in order to determine how many elements it contains.</p>
|
|||||||
<p>Returns the number of elements in the sequence that pass the <code>predicate</code>.</p>
|
<p>Returns the number of elements in the sequence that pass the <code>predicate</code>.</p>
|
||||||
<p>Iterates over the sequence, passing each element to the function <code>predicate</code>
|
<p>Iterates over the sequence, passing each element to the function <code>predicate</code>
|
||||||
and counting the number of times the returned value evaluates to <code>true</code>.</p>
|
and counting the number of times the returned value evaluates to <code>true</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">count</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o">></span> <span class="m">2</span><span class="p">}</span> <span class="c1">// 1.</span>
|
<div class="codehilite"><pre><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">count</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">></span> <span class="mi">2</span><span class="p">}</span> <span class="c1">// 1.</span>
|
||||||
<span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">count</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o"><</span> <span class="m">4</span><span class="p">}</span> <span class="c1">// 3.</span>
|
<span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">count</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o"><</span> <span class="mi">4</span><span class="p">}</span> <span class="c1">// 3.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h3><strong>each</strong>(function) <a href="#each(function)" name="each(function)" class="header-anchor">#</a></h3>
|
<h3><strong>each</strong>(function) <a href="#each(function)" name="each(function)" class="header-anchor">#</a></h3>
|
||||||
<p>Iterates over the sequence, passing each element to the given <code>function</code>.</p>
|
<p>Iterates over the sequence, passing each element to the given <code>function</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="p">[</span><span class="s2">"one"</span><span class="p">,</span> <span class="s2">"two"</span><span class="p">,</span> <span class="s2">"three"</span><span class="p">].</span><span class="n">each</span> <span class="p">{</span><span class="o">|</span><span class="n">word</span><span class="o">|</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">word</span><span class="p">)</span> <span class="p">}</span>
|
<div class="codehilite"><pre><span class="p">[</span><span class="s">"one"</span><span class="p">,</span> <span class="s">"two"</span><span class="p">,</span> <span class="s">"three"</span><span class="p">]</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span><span class="o">|</span><span class="n">word</span><span class="o">|</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">word</span><span class="p">)</span> <span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -92,19 +92,19 @@ and counting the number of times the returned value evaluates to <code>true</cod
|
|||||||
<p>Returns whether the sequence contains any elements.</p>
|
<p>Returns whether the sequence contains any elements.</p>
|
||||||
<p>This can be more efficient that <code>count == 0</code> because this does not iterate over
|
<p>This can be more efficient that <code>count == 0</code> because this does not iterate over
|
||||||
the entire sequence.</p>
|
the entire sequence.</p>
|
||||||
<h3><strong>join</strong>(sep) <a href="#join(sep)" name="join(sep)" class="header-anchor">#</a></h3>
|
<h3><strong>join</strong>(separator) <a href="#join(separator)" name="join(separator)" class="header-anchor">#</a></h3>
|
||||||
<p>Returns a string representation of the sequence. The string representations of
|
<p>Converts every element in the sequence to a string and then joins the results
|
||||||
the elements in the sequence is concatenated with intervening occurrences of
|
together into a single string, each separated by <code>separator</code>.</p>
|
||||||
<code>sep</code>.</p>
|
<p>It is a runtime error if <code>separator</code> is not a string.</p>
|
||||||
<p>It is a runtime error if <code>sep</code> is not a string.</p>
|
<h3><strong>join</strong>() <a href="#join()" name="join()" class="header-anchor">#</a></h3>
|
||||||
<h3><strong>join</strong> <a href="#join" name="join" class="header-anchor">#</a></h3>
|
<p>Converts every element in the sequence to a string and then joins the results
|
||||||
<p>Calls <code>join</code> with the empty string as the separator.</p>
|
together into a single string.</p>
|
||||||
<h3><strong>map</strong>(transformation) <a href="#map(transformation)" name="map(transformation)" class="header-anchor">#</a></h3>
|
<h3><strong>map</strong>(transformation) <a href="#map(transformation)" name="map(transformation)" class="header-anchor">#</a></h3>
|
||||||
<p>Creates a new sequence that applies the <code>transformation</code> to each element in the
|
<p>Creates a new sequence that applies the <code>transformation</code> to each element in the
|
||||||
original sequence while it is iterated.</p>
|
original sequence while it is iterated.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">doubles</span> <span class="o">=</span> <span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">].</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o">*</span> <span class="m">2</span> <span class="p">}</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">doubles</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">*</span> <span class="mi">2</span> <span class="p">}</span>
|
||||||
<span class="k">for</span> <span class="p">(</span><span class="n">n</span> <span class="k">in</span> <span class="n">doubles</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">for</span> <span class="p">(</span><span class="err">n</span> <span class="k">in</span> <span class="n">doubles</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="c1">// "2", "4", "6".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">n</span><span class="p">)</span> <span class="c1">// "2", "4", "6".</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -116,10 +116,10 @@ sequence.</p>
|
|||||||
that have side effects when you iterate over them. But it also means that
|
that have side effects when you iterate over them. But it also means that
|
||||||
changes to the original sequence will be reflected in the mapped sequence.</p>
|
changes to the original sequence will be reflected in the mapped sequence.</p>
|
||||||
<p>To force eager evaluation, just call <code>.toList</code> on the result.</p>
|
<p>To force eager evaluation, just call <code>.toList</code> on the result.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
|
||||||
<span class="kd">var</span> <span class="n">doubles</span> <span class="o">=</span> <span class="n">numbers</span><span class="p">.</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o">*</span> <span class="m">2</span> <span class="p">}.</span><span class="n">toList</span>
|
<span class="k">var</span> <span class="n">doubles</span> <span class="o">=</span> <span class="n">numbers</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">*</span> <span class="mi">2</span> <span class="p">}</span><span class="o">.</span><span class="n">toList</span>
|
||||||
<span class="n">numbers</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="m">4</span><span class="p">)</span>
|
<span class="n">numbers</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">doubles</span><span class="p">)</span> <span class="c1">// [2, 4, 6].</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">doubles</span><span class="p">)</span> <span class="c1">// [2, 4, 6].</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -135,7 +135,7 @@ iteratively updating the accumulator.</p>
|
|||||||
the sequence is empty, returns <code>seed</code>.</p>
|
the sequence is empty, returns <code>seed</code>.</p>
|
||||||
<h3><strong>toList</strong> <a href="#tolist" name="tolist" class="header-anchor">#</a></h3>
|
<h3><strong>toList</strong> <a href="#tolist" name="tolist" class="header-anchor">#</a></h3>
|
||||||
<p>Creates a <a href="list.html">list</a> containing all the elements in the sequence.</p>
|
<p>Creates a <a href="list.html">list</a> containing all the elements in the sequence.</p>
|
||||||
<div class="codehilite"><pre><span class="p">(</span><span class="m">1.</span><span class="p">.</span><span class="m">3</span><span class="p">).</span><span class="n">toList</span> <span class="c1">// [1, 2, 3].</span>
|
<div class="codehilite"><pre><span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">3</span><span class="p">)</span><span class="o">.</span><span class="n">toList</span> <span class="c1">// [1, 2, 3].</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -145,9 +145,9 @@ the sequence is empty, returns <code>seed</code>.</p>
|
|||||||
that pass the <code>predicate</code>.</p>
|
that pass the <code>predicate</code>.</p>
|
||||||
<p>During iteration, each element in the original sequence is passed to the
|
<p>During iteration, each element in the original sequence is passed to the
|
||||||
function <code>predicate</code>. If it returns <code>false</code>, the element is skipped.</p>
|
function <code>predicate</code>. If it returns <code>false</code>, the element is skipped.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">odds</span> <span class="o">=</span> <span class="p">(</span><span class="m">1.</span><span class="p">.</span><span class="m">10</span><span class="p">).</span><span class="n">where</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o">%</span> <span class="m">2</span> <span class="o">==</span> <span class="m">1</span> <span class="p">}</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">odds</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">10</span><span class="p">)</span><span class="o">.</span><span class="n">where</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">1</span> <span class="p">}</span>
|
||||||
<span class="k">for</span> <span class="p">(</span><span class="n">n</span> <span class="k">in</span> <span class="n">odds</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">for</span> <span class="p">(</span><span class="err">n</span> <span class="k">in</span> <span class="n">odds</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="c1">// "1", "3", "5", "7", "9".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">n</span><span class="p">)</span> <span class="c1">// "1", "3", "5", "7", "9".</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -160,10 +160,10 @@ sequences that have side effects when you iterate over them. But it also means
|
|||||||
that changes to the original sequence will be reflected in the filtered
|
that changes to the original sequence will be reflected in the filtered
|
||||||
sequence.</p>
|
sequence.</p>
|
||||||
<p>To force eager evaluation, just call <code>.toList</code> on the result.</p>
|
<p>To force eager evaluation, just call <code>.toList</code> on the result.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">,</span> <span class="m">4</span><span class="p">,</span> <span class="m">5</span><span class="p">,</span> <span class="m">6</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]</span>
|
||||||
<span class="kd">var</span> <span class="n">odds</span> <span class="o">=</span> <span class="n">numbers</span><span class="p">.</span><span class="n">where</span> <span class="p">{</span><span class="o">|</span><span class="n">n</span><span class="o">|</span> <span class="n">n</span> <span class="o">%</span> <span class="m">2</span> <span class="o">==</span> <span class="m">1</span> <span class="p">}.</span><span class="n">toList</span>
|
<span class="k">var</span> <span class="n">odds</span> <span class="o">=</span> <span class="n">numbers</span><span class="o">.</span><span class="n">where</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">1</span> <span class="p">}</span><span class="o">.</span><span class="n">toList</span>
|
||||||
<span class="n">numbers</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="m">7</span><span class="p">)</span>
|
<span class="n">numbers</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">odds</span><span class="p">)</span> <span class="c1">// [1, 3, 5].</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">odds</span><span class="p">)</span> <span class="c1">// [1, 3, 5].</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
@ -38,57 +38,60 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
<main>
|
<main>
|
||||||
<h1>String Class</h1>
|
<h1>String Class</h1>
|
||||||
<p>A string is an immutable array of bytes. Strings usually store text, in which
|
<p>A string is an immutable array of bytes. Strings usually store text, in which
|
||||||
case it will be the UTF-8 encoding of the text's code points. But you can put
|
case the bytes are the UTF-8 encoding of the text's code points. But you can put
|
||||||
any kind of byte values in there you want, including null bytes or invalid UTF-8
|
any kind of byte values in there you want, including null bytes or invalid
|
||||||
sequences.</p>
|
UTF-8.</p>
|
||||||
<p>There are a few ways to think of a string:</p>
|
<p>There are a few ways to think of a string:</p>
|
||||||
<ul>
|
<ul>
|
||||||
<li>
|
<li>
|
||||||
<p>As a searchable chunk of text composed of a sequence of textual code points.</p>
|
<p>As a searchable chunk of text composed of a sequence of textual code points.</p>
|
||||||
</li>
|
</li>
|
||||||
<li>
|
<li>
|
||||||
<p>As an iterable sequence of numeric code points.</p>
|
<p>As an iterable sequence of code point numbers.</p>
|
||||||
</li>
|
</li>
|
||||||
<li>
|
<li>
|
||||||
<p>As a flat array of directly indexable bytes.</p>
|
<p>As a flat array of directly indexable bytes.</p>
|
||||||
</li>
|
</li>
|
||||||
</ul>
|
</ul>
|
||||||
<p>All of those are useful for some problems, so the string API supports all three.
|
<p>All of those are useful for some problems, so the string API supports all three.
|
||||||
The first one is the most common, so that's what most methods directly on the
|
The first one is the most common, so that's what methods directly on the string
|
||||||
string class cater towards.</p>
|
class cater to.</p>
|
||||||
<p>In UTF-8, a single Unicode code point—very roughly a single
|
<p>In UTF-8, a single Unicode code point—very roughly a single
|
||||||
"character"— may be encoded as one or more bytes. This means you can't
|
"character"—may encode to one or more bytes. This means you can't
|
||||||
efficiently index by code point. There's no way to jump directly to, say, the
|
efficiently index by code point. There's no way to jump directly to, say, the
|
||||||
fifth code unit in a string without walking the string from the beginning and
|
fifth code point in a string without walking the string from the beginning and
|
||||||
counting them as you go.</p>
|
counting them as you go.</p>
|
||||||
<p>Because counting code units is relatively slow, the indexes passed to string
|
<p>Because counting code points is relatively slow, the indexes passed to string
|
||||||
methods are <em>byte</em> offsets, not <em>code point</em> offsets. When you do:</p>
|
methods are <em>byte</em> offsets, not <em>code point</em> offsets. When you do:</p>
|
||||||
<div class="codehilite"><pre><span class="n">someString</span><span class="p">[</span><span class="m">3</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="n">someString</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>That means "get the code unit starting at <em>byte</em> three", not "get the third
|
<p>That means "get the code point starting at <em>byte</em> three", not "get the third
|
||||||
code unit in the string". This sounds scary, but keep in mind that the methods
|
code point in the string". This sounds scary, but keep in mind that the methods
|
||||||
on string <em>return</em> byte indices too. So, for example, this does what you want:</p>
|
on strings <em>return</em> byte indexes too. So, for example, this does what you want:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">metalBand</span> <span class="o">=</span> <span class="s2">"Fäcëhämmër"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">metalBand</span> <span class="o">=</span> <span class="s">"Fäcëhämmër"</span>
|
||||||
<span class="kd">var</span> <span class="n">hPosition</span> <span class="o">=</span> <span class="n">metalBand</span><span class="p">.</span><span class="n">indexOf</span><span class="p">(</span><span class="s2">"h"</span><span class="p">)</span>
|
<span class="k">var</span> <span class="n">hPosition</span> <span class="o">=</span> <span class="n">metalBand</span><span class="o">.</span><span class="n">indexOf</span><span class="p">(</span><span class="s">"h"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">metalBand</span><span class="p">[</span><span class="n">hPosition</span><span class="p">])</span> <span class="c1">// "h"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">metalBand</span><span class="p">[</span><span class="n">hPosition</span><span class="p">])</span> <span class="c1">// "h"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>If you want to work with a string as a sequence numeric code points, call the <code>codePoints</code> getter. It returns a <a href="sequence.html">Sequence</a> that will decide UTF-8 and iterate over the code points, returning each as a number.</p>
|
<p>If you want to work with a string as a sequence numeric code points, call the
|
||||||
<p>If you want to get at the raw bytes, call <code>bytes</code>. This returns a Sequence that ignores any UTF-8 encoding and works directly at the byte level.</p>
|
<code>codePoints</code> getter. It returns a <a href="sequence.html">Sequence</a> that decodes UTF-8
|
||||||
|
and iterates over the code points, returning each as a number.</p>
|
||||||
|
<p>If you want to get at the raw bytes, call <code>bytes</code>. This returns a Sequence that
|
||||||
|
ignores any UTF-8 encoding and works directly at the byte level.</p>
|
||||||
<h2>Static Methods <a href="#static-methods" name="static-methods" class="header-anchor">#</a></h2>
|
<h2>Static Methods <a href="#static-methods" name="static-methods" class="header-anchor">#</a></h2>
|
||||||
<h3>String.<strong>fromCodePoint</strong>(codePoint) <a href="#stringfromcodepoint(codepoint)" name="stringfromcodepoint(codepoint)" class="header-anchor">#</a></h3>
|
<h3>String.<strong>fromCodePoint</strong>(codePoint) <a href="#stringfromcodepoint(codepoint)" name="stringfromcodepoint(codepoint)" class="header-anchor">#</a></h3>
|
||||||
<p>Creates a new string containing the UTF-8 encoding of <code>codePoint</code>.</p>
|
<p>Creates a new string containing the UTF-8 encoding of <code>codePoint</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="kt">String</span><span class="p">.</span><span class="n">fromCodePoint</span><span class="p">(</span><span class="m">8225</span><span class="p">)</span> <span class="c1">// "‡"</span>
|
<div class="codehilite"><pre><span class="vg">String</span><span class="o">.</span><span class="n">fromCodePoint</span><span class="p">(</span><span class="mi">8225</span><span class="p">)</span> <span class="c1">// "‡"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -100,7 +103,7 @@ on string <em>return</em> byte indices too. So, for example, this does what you
|
|||||||
the string and ignore any UTF-8 encoding. In addition to the normal sequence
|
the string and ignore any UTF-8 encoding. In addition to the normal sequence
|
||||||
methods, the returned object also has a subscript operator that can be used to
|
methods, the returned object also has a subscript operator that can be used to
|
||||||
directly index bytes.</p>
|
directly index bytes.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"hello"</span><span class="p">.</span><span class="n">bytes</span><span class="p">[</span><span class="m">1</span><span class="p">])</span> <span class="c1">// 101, for "e".</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"hello"</span><span class="o">.</span><span class="n">bytes</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span> <span class="c1">// 101, for "e".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -112,16 +115,16 @@ the string, and runs in constant time instead.</p>
|
|||||||
code points of the string <em>as numbers</em>. Iteration and subscripting work similar
|
code points of the string <em>as numbers</em>. Iteration and subscripting work similar
|
||||||
to the string itself. The difference is that instead of returning
|
to the string itself. The difference is that instead of returning
|
||||||
single-character strings, this returns the numeric code point values.</p>
|
single-character strings, this returns the numeric code point values.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">string</span> <span class="o">=</span> <span class="s2">"(ᵔᴥᵔ)"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">string</span> <span class="o">=</span> <span class="s">"(ᵔᴥᵔ)"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">string</span><span class="p">.</span><span class="n">codePoints</span><span class="p">[</span><span class="m">0</span><span class="p">])</span> <span class="c1">// 40, for "(".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">string</span><span class="o">.</span><span class="n">codePoints</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="c1">// 40, for "(".</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">string</span><span class="p">.</span><span class="n">codePoints</span><span class="p">[</span><span class="m">4</span><span class="p">])</span> <span class="c1">// 7461, for "ᴥ".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">string</span><span class="o">.</span><span class="n">codePoints</span><span class="p">[</span><span class="mi">4</span><span class="p">])</span> <span class="c1">// 7461, for "ᴥ".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>If the byte at <code>index</code> does not begin a valid UTF-8 sequence, or the end of the
|
<p>If the byte at <code>index</code> does not begin a valid UTF-8 sequence, or the end of the
|
||||||
string is reached before the sequence is complete, returns <code>-1</code>.</p>
|
string is reached before the sequence is complete, returns <code>-1</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">string</span> <span class="o">=</span> <span class="s2">"(ᵔᴥᵔ)"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">string</span> <span class="o">=</span> <span class="s">"(ᵔᴥᵔ)"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">string</span><span class="p">.</span><span class="n">codePoints</span><span class="p">[</span><span class="m">2</span><span class="p">])</span> <span class="c1">// -1, in the middle of "ᵔ".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">string</span><span class="o">.</span><span class="n">codePoints</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span> <span class="c1">// -1, in the middle of "ᵔ".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -144,12 +147,12 @@ count as well.</p>
|
|||||||
<h3><strong>iterate</strong>(iterator), <strong>iteratorValue</strong>(iterator) <a href="#iterate(iterator),-iteratorvalue(iterator)" name="iterate(iterator),-iteratorvalue(iterator)" class="header-anchor">#</a></h3>
|
<h3><strong>iterate</strong>(iterator), <strong>iteratorValue</strong>(iterator) <a href="#iterate(iterator),-iteratorvalue(iterator)" name="iterate(iterator),-iteratorvalue(iterator)" class="header-anchor">#</a></h3>
|
||||||
<p>Implements the <a href="../control-flow.html#the-iterator-protocol">iterator protocol</a>
|
<p>Implements the <a href="../control-flow.html#the-iterator-protocol">iterator protocol</a>
|
||||||
for iterating over the <em>code points</em> in the string:</p>
|
for iterating over the <em>code points</em> in the string:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">codePoints</span> <span class="o">=</span> <span class="p">[]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">codePoints</span> <span class="o">=</span> <span class="p">[]</span>
|
||||||
<span class="k">for</span> <span class="p">(</span><span class="n">c</span> <span class="k">in</span> <span class="s2">"(ᵔᴥᵔ)"</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">for</span> <span class="p">(</span><span class="err">c</span> <span class="k">in</span> <span class="s">"(ᵔᴥᵔ)"</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">codePoints</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
|
<span class="n">codePoints</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="err">c</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">codePoints</span><span class="p">)</span> <span class="c1">// ["(", "ᵔ", "ᴥ", "ᵔ", ")"].</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">codePoints</span><span class="p">)</span> <span class="c1">// ["(", "ᵔ", "ᴥ", "ᵔ", ")"].</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -166,17 +169,16 @@ those too, one byte at a time.</p>
|
|||||||
<h3><strong>!=</strong>(other) operator <a href="#=(other)-operator" name="=(other)-operator" class="header-anchor">#</a></h3>
|
<h3><strong>!=</strong>(other) operator <a href="#=(other)-operator" name="=(other)-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Check if the string is not equal to <code>other</code>.</p>
|
<p>Check if the string is not equal to <code>other</code>.</p>
|
||||||
<h3><strong>[</strong>index<strong>]</strong> operator <a href="#[index]-operator" name="[index]-operator" class="header-anchor">#</a></h3>
|
<h3><strong>[</strong>index<strong>]</strong> operator <a href="#[index]-operator" name="[index]-operator" class="header-anchor">#</a></h3>
|
||||||
<p>Returns a string containing the code unit starting at byte <code>index</code>.</p>
|
<p>Returns a string containing the code point starting at byte <code>index</code>.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"ʕ•ᴥ•ʔ"</span><span class="p">[</span><span class="m">5</span><span class="p">])</span> <span class="c1">// "ᴥ".</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"ʕ•ᴥ•ʔ"</span><span class="p">[</span><span class="mi">5</span><span class="p">])</span> <span class="c1">// "ᴥ".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Since <code>ʕ</code> is two bytes in UTF-8 and <code>•</code> is three, the fifth byte points to the
|
<p>Since <code>ʕ</code> is two bytes in UTF-8 and <code>•</code> is three, the fifth byte points to the
|
||||||
bear's nose.</p>
|
bear's nose.</p>
|
||||||
<p>If <code>index</code> points into the middle of a UTF-8 sequence or at otherwise invalid
|
<p>If <code>index</code> points into the middle of a UTF-8 sequence or at otherwise invalid
|
||||||
UTF-8, this returns a one-byte string containing the value of the byte at that
|
UTF-8, this returns a one-byte string containing the byte at that index:</p>
|
||||||
index:</p>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"I ♥ NY"</span><span class="p">[</span><span class="mi">3</span><span class="p">])</span> <span class="c1">// One-byte string whose value is 153.</span>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"I ♥ NY"</span><span class="p">[</span><span class="m">3</span><span class="p">])</span> <span class="c1">// One-byte string whose value is 153.</span>
|
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -2,7 +2,7 @@
|
|||||||
<html>
|
<html>
|
||||||
<head>
|
<head>
|
||||||
<meta http-equiv="Content-type" content="text/html;charset=UTF-8" />
|
<meta http-equiv="Content-type" content="text/html;charset=UTF-8" />
|
||||||
<title>IO Class – Wren</title>
|
<title>System Class – Wren</title>
|
||||||
<link rel="stylesheet" type="text/css" href="../style.css" />
|
<link rel="stylesheet" type="text/css" href="../style.css" />
|
||||||
<link href='//fonts.googleapis.com/css?family=Source+Sans+Pro:400,700,400italic,700italic|Source+Code+Pro:400|Lato:400|Sanchez:400italic,400' rel='stylesheet' type='text/css'>
|
<link href='//fonts.googleapis.com/css?family=Source+Sans+Pro:400,700,400italic,700italic|Source+Code+Pro:400|Lato:400|Sanchez:400italic,400' rel='stylesheet' type='text/css'>
|
||||||
<!-- Tell mobile browsers we're optimized for them and they don't need to crop
|
<!-- Tell mobile browsers we're optimized for them and they don't need to crop
|
||||||
@ -38,62 +38,43 @@
|
|||||||
<li><a href="range.html">Range</a></li>
|
<li><a href="range.html">Range</a></li>
|
||||||
<li><a href="sequence.html">Sequence</a></li>
|
<li><a href="sequence.html">Sequence</a></li>
|
||||||
<li><a href="string.html">String</a></li>
|
<li><a href="string.html">String</a></li>
|
||||||
<li><a href="io.html">IO</a></li>
|
<li><a href="system.html">System</a></li>
|
||||||
</ul>
|
</ul>
|
||||||
</section>
|
</section>
|
||||||
</nav>
|
</nav>
|
||||||
<main>
|
<main>
|
||||||
<h1>IO Class</h1>
|
<h1>System Class</h1>
|
||||||
<p>The IO class can be used to read and write to and from the console.</p>
|
<p>The System class is a grab-bag of functionality exposed by the VM, mostly for
|
||||||
|
use during development or debugging.</p>
|
||||||
<h2>Static Methods <a href="#static-methods" name="static-methods" class="header-anchor">#</a></h2>
|
<h2>Static Methods <a href="#static-methods" name="static-methods" class="header-anchor">#</a></h2>
|
||||||
<h3>IO.<strong>print</strong>(objects...) <a href="#ioprint(objects)" name="ioprint(objects)" class="header-anchor">#</a></h3>
|
<h3>System.<strong>print</strong>() <a href="#systemprint()" name="systemprint()" class="header-anchor">#</a></h3>
|
||||||
<p>Prints a series of objects to the console followed by a newline. Each object is
|
<p>Prints a single newline to the console.</p>
|
||||||
converted to a string by calling <code>toString</code> on it. This is overloaded to
|
<h3>System.<strong>print</strong>(object) <a href="#systemprint(object)" name="systemprint(object)" class="header-anchor">#</a></h3>
|
||||||
support up to 16 objects. To pass more, use <code>printAll()</code>.</p>
|
<p>Prints [object] to the console followed by a newline. If not already a string,
|
||||||
<blockquote>
|
the object is converted to a string by calling <code>toString</code> on it.</p>
|
||||||
<p>IO.print("I like bananas")
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"I like bananas"</span><span class="p">)</span> <span class="c1">// Prints "I like bananas".</span>
|
||||||
I like bananas
|
</pre></div>
|
||||||
IO.print("Oranges", 10)
|
|
||||||
Oranges10</p>
|
|
||||||
</blockquote>
|
<h3>System.<strong>printAll</strong>(sequence) <a href="#systemprintall(sequence)" name="systemprintall(sequence)" class="header-anchor">#</a></h3>
|
||||||
<h3>IO.<strong>printAll</strong>(sequence) <a href="#ioprintall(sequence)" name="ioprintall(sequence)" class="header-anchor">#</a></h3>
|
|
||||||
<p>Iterates over [sequence] and prints each element, then prints a single newline
|
<p>Iterates over [sequence] and prints each element, then prints a single newline
|
||||||
at the end. Each element is converted to a string by calling <code>toString</code> on it.</p>
|
at the end. Each element is converted to a string by calling <code>toString</code> on it.</p>
|
||||||
<blockquote>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">printAll</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="mi">4</span><span class="p">])</span> <span class="c1">// Prints "1[2, 3]4".</span>
|
||||||
<p>IO.printAll([1, [2, 3], 4])
|
</pre></div>
|
||||||
1[2, 3]4</p>
|
|
||||||
</blockquote>
|
|
||||||
<h3>IO.<strong>write</strong>(object) <a href="#iowrite(object)" name="iowrite(object)" class="header-anchor">#</a></h3>
|
<h3>System.<strong>write</strong>(object) <a href="#systemwrite(object)" name="systemwrite(object)" class="header-anchor">#</a></h3>
|
||||||
<p>Prints a single value to the console, but does not print a newline character
|
<p>Prints a single value to the console, but does not print a newline character
|
||||||
afterwards. Converts the value to a string by calling <code>toString</code> on it.</p>
|
afterwards. Converts the value to a string by calling <code>toString</code> on it.</p>
|
||||||
<blockquote>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="mi">4</span> <span class="o">+</span> <span class="mi">5</span><span class="p">)</span> <span class="c1">// Prints "9".</span>
|
||||||
<p>IO.write(4 + 5)
|
</pre></div>
|
||||||
9></p>
|
|
||||||
</blockquote>
|
|
||||||
<p>In the above example, the result of <code>4 + 5</code> is printed, and then the prompt is
|
<p>In the above example, the result of <code>4 + 5</code> is printed, and then the prompt is
|
||||||
printed on the same line because no newline character was printed afterwards.</p>
|
printed on the same line because no newline character was printed afterwards.</p>
|
||||||
<h3>IO.<strong>read</strong>() <a href="#ioread()" name="ioread()" class="header-anchor">#</a></h3>
|
<h3>System.<strong>clock</strong> <a href="#systemclock" name="systemclock" class="header-anchor">#</a></h3>
|
||||||
<p>Reads in a line of text from stdin. Note that the returned text includes the
|
<p>Returns the number of seconds (including fractional seconds) since the program
|
||||||
trailing newline.</p>
|
was started. This is usually used for benchmarking.</p>
|
||||||
<blockquote>
|
|
||||||
<p>var name = IO.read()
|
|
||||||
John
|
|
||||||
IO.print("Hello " + name + "!")
|
|
||||||
Hello John
|
|
||||||
!
|
|
||||||
</p>
|
|
||||||
</blockquote>
|
|
||||||
<h3>IO.<strong>read</strong>(prompt) <a href="#ioread(prompt)" name="ioread(prompt)" class="header-anchor">#</a></h3>
|
|
||||||
<p>Displays <code>prompt</code> then reads in a line of text from stdin. Note that the
|
|
||||||
returned text includes the trailing newline.</p>
|
|
||||||
<blockquote>
|
|
||||||
<p>var name = IO.read("Enter your name: ")
|
|
||||||
Enter your name: John
|
|
||||||
IO.print("Hello " + name + "!")
|
|
||||||
Hello John
|
|
||||||
!
|
|
||||||
</p>
|
|
||||||
</blockquote>
|
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
<footer>
|
<footer>
|
||||||
@ -119,7 +119,7 @@ VM, waiting to run some code!</p>
|
|||||||
<p>You can tell the VM to execute a string of Wren source code like so:</p>
|
<p>You can tell the VM to execute a string of Wren source code like so:</p>
|
||||||
<div class="codehilite"><pre><span class="n">WrenInterpretResult</span> <span class="n">result</span> <span class="o">=</span> <span class="n">wrenInterpret</span><span class="p">(</span><span class="n">vm</span><span class="p">,</span>
|
<div class="codehilite"><pre><span class="n">WrenInterpretResult</span> <span class="n">result</span> <span class="o">=</span> <span class="n">wrenInterpret</span><span class="p">(</span><span class="n">vm</span><span class="p">,</span>
|
||||||
<span class="s">"<where>"</span><span class="p">,</span>
|
<span class="s">"<where>"</span><span class="p">,</span>
|
||||||
<span class="s">"IO.print(</span><span class="se">\"</span><span class="s">Hi!</span><span class="se">\"</span><span class="s">)"</span><span class="p">);</span>
|
<span class="s">"System.print(</span><span class="se">\"</span><span class="s">Hi!</span><span class="se">\"</span><span class="s">)"</span><span class="p">);</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -63,7 +63,7 @@
|
|||||||
<h2>Syntax errors <a href="#syntax-errors" name="syntax-errors" class="header-anchor">#</a></h2>
|
<h2>Syntax errors <a href="#syntax-errors" name="syntax-errors" class="header-anchor">#</a></h2>
|
||||||
<p>The first errors you're likely to run into are syntax errors. These include
|
<p>The first errors you're likely to run into are syntax errors. These include
|
||||||
simple bugs where your code doesn't follow the language's grammar, like:</p>
|
simple bugs where your code doesn't follow the language's grammar, like:</p>
|
||||||
<div class="codehilite"><pre><span class="m">1</span> <span class="o">+</span> <span class="o">*</span> <span class="m">2</span>
|
<div class="codehilite"><pre><span class="mi">1</span> <span class="o">+</span> <span class="o">*</span> <span class="mi">2</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -76,8 +76,8 @@ hits one, you'll get a friendly error message, like:</p>
|
|||||||
<p>Some slightly more "semantic" errors fall into this bucket too. Things like
|
<p>Some slightly more "semantic" errors fall into this bucket too. Things like
|
||||||
using a variable that hasn't been defined, or declaring two variables with the
|
using a variable that hasn't been defined, or declaring two variables with the
|
||||||
same name in the same scope. So if you do:</p>
|
same name in the same scope. So if you do:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="s2">"once"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="s">"once"</span>
|
||||||
<span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="s2">"twice"</span>
|
<span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="s">"twice"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -100,10 +100,10 @@ statically. Since they can't be found until your code is run, they're called
|
|||||||
perform an operation that the VM can't do. The most common error is a "method
|
perform an operation that the VM can't do. The most common error is a "method
|
||||||
not found" one. If you call a method on an object and its class (and all of its
|
not found" one. If you call a method on an object and its class (and all of its
|
||||||
superclasses) don't define that method, there's nothing Wren can do:</p>
|
superclasses) don't define that method, there's nothing Wren can do:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Foo</span> <span class="p">{}</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Foo</span> <span class="p">{}</span>
|
||||||
|
|
||||||
<span class="kd">var</span> <span class="n">foo</span> <span class="o">=</span> <span class="n">Foo</span><span class="p">.</span><span class="k">new</span><span class="p">()</span>
|
<span class="k">var</span> <span class="n">foo</span> <span class="o">=</span> <span class="vg">Foo</span><span class="o">.</span><span class="n">new</span><span class="p">()</span>
|
||||||
<span class="n">foo</span><span class="p">.</span><span class="n">someRandomMethod</span>
|
<span class="n">foo</span><span class="o">.</span><span class="n">someRandomMethod</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -120,8 +120,8 @@ and all of the method calls that led to it.</p>
|
|||||||
<p>Another common runtime error is passing an argument of the wrong type to a
|
<p>Another common runtime error is passing an argument of the wrong type to a
|
||||||
method. For example, lists are indexed using a number. If you try to pass some
|
method. For example, lists are indexed using a number. If you try to pass some
|
||||||
other type, it's an error:</p>
|
other type, it's an error:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">]</span>
|
||||||
<span class="n">list</span><span class="p">[</span><span class="s2">"1"</span><span class="p">]</span>
|
<span class="n">list</span><span class="p">[</span><span class="s">"1"</span><span class="p">]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -147,12 +147,12 @@ VM.</p>
|
|||||||
in the called fiber, the error is captured and the <code>try</code> method returns the
|
in the called fiber, the error is captured and the <code>try</code> method returns the
|
||||||
error message as a string.</p>
|
error message as a string.</p>
|
||||||
<p>For example, if you run this program:</p>
|
<p>For example, if you run this program:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="m">123.</span><span class="n">badMethod</span>
|
<span class="mi">123</span><span class="o">.</span><span class="n">badMethod</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">var</span> <span class="n">error</span> <span class="o">=</span> <span class="n">fiber</span><span class="p">.</span><span class="k">try</span><span class="p">()</span>
|
<span class="k">var</span> <span class="n">error</span> <span class="o">=</span> <span class="n">fiber</span><span class="o">.</span><span class="n">try</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Caught error: "</span><span class="p">,</span> <span class="n">error</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Caught error: "</span> <span class="o">+</span> <span class="n">error</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -164,7 +164,7 @@ error message as a string.</p>
|
|||||||
<p>The called fiber can no longer be used, but any other fibers can proceed as
|
<p>The called fiber can no longer be used, but any other fibers can proceed as
|
||||||
usual. When a fiber has been aborted because of a runtime error, you can also
|
usual. When a fiber has been aborted because of a runtime error, you can also
|
||||||
get the error from the fiber object. Continuing the above example:</p>
|
get the error from the fiber object. Continuing the above example:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">fiber</span><span class="p">.</span><span class="n">error</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">fiber</span><span class="o">.</span><span class="n">error</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -180,7 +180,7 @@ errors generated in fibers that are invoked by the one you called <code>try</cod
|
|||||||
<p>Most runtime errors come from within the Wren VM, but you may want to be able
|
<p>Most runtime errors come from within the Wren VM, but you may want to be able
|
||||||
to cause your own runtime errors to occur. This can be done by calling the
|
to cause your own runtime errors to occur. This can be done by calling the
|
||||||
<code>abort()</code> static method on <code>Fiber</code>:</p>
|
<code>abort()</code> static method on <code>Fiber</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="n">Fiber</span><span class="p">.</span><span class="n">abort</span><span class="p">(</span><span class="s2">"Something bad happened"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">Fiber</span><span class="o">.</span><span class="n">abort</span><span class="p">(</span><span class="s">"Something bad happened"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -78,22 +78,22 @@ instance of a <a href="classes.html">class</a>. All other names refer to
|
|||||||
<h2>Method calls <a href="#method-calls" name="method-calls" class="header-anchor">#</a></h2>
|
<h2>Method calls <a href="#method-calls" name="method-calls" class="header-anchor">#</a></h2>
|
||||||
<p>Wren is object-oriented, so most code consists of method calls. Most of them
|
<p>Wren is object-oriented, so most code consists of method calls. Most of them
|
||||||
look like so:</p>
|
look like so:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"hello"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"hello"</span><span class="p">)</span>
|
||||||
<span class="n">items</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="s2">"another"</span><span class="p">)</span>
|
<span class="n">items</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="s">"another"</span><span class="p">)</span>
|
||||||
<span class="n">items</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="s2">"value"</span><span class="p">)</span>
|
<span class="n">items</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s">"value"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>You have a <em>receiver</em> expression followed by a <code>.</code>, then a name and an argument
|
<p>You have a <em>receiver</em> expression followed by a <code>.</code>, then a name and an argument
|
||||||
list in parentheses. Arguments are separated by commas. Methods that do not
|
list in parentheses. Arguments are separated by commas. Methods that do not
|
||||||
take any arguments can omit the <code>()</code>:</p>
|
take any arguments can omit the <code>()</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="n">text</span><span class="p">.</span><span class="n">length</span>
|
<div class="codehilite"><pre><span class="n">text</span><span class="o">.</span><span class="n">length</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>These are special "getters" or "accessors" in other languages. In Wren, they're
|
<p>These are special "getters" or "accessors" in other languages. In Wren, they're
|
||||||
just method calls. You can also define methods that take an empty argument list:</p>
|
just method calls. You can also define methods that take an empty argument list:</p>
|
||||||
<div class="codehilite"><pre><span class="n">list</span><span class="p">.</span><span class="n">clear</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="n">list</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -107,8 +107,8 @@ method's <em>name</em>.</p>
|
|||||||
<p>If the last (or only) argument to a method call is a
|
<p>If the last (or only) argument to a method call is a
|
||||||
<a href="functions.html">function</a>, it may be passed as a <a href="functions.html#block-arguments">block
|
<a href="functions.html">function</a>, it may be passed as a <a href="functions.html#block-arguments">block
|
||||||
argument</a>:</p>
|
argument</a>:</p>
|
||||||
<div class="codehilite"><pre><span class="n">blondie</span><span class="p">.</span><span class="n">callMeAt</span><span class="p">(</span><span class="m">867</span><span class="p">,</span> <span class="m">5309</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="n">blondie</span><span class="o">.</span><span class="n">callMeAt</span><span class="p">(</span><span class="mi">867</span><span class="p">,</span> <span class="mi">5309</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"This is the body!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"This is the body!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -137,15 +137,15 @@ an overridden method when you want to access the original method being
|
|||||||
overridden.</p>
|
overridden.</p>
|
||||||
<p>To do that, you can use the special <code>super</code> keyword as the receiver in a method
|
<p>To do that, you can use the special <code>super</code> keyword as the receiver in a method
|
||||||
call:</p>
|
call:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Base</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Base</span> <span class="p">{</span>
|
||||||
<span class="n">method</span> <span class="p">{</span>
|
<span class="n">method</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"base method"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"base method"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">class</span> <span class="nc">Derived</span> <span class="k">is</span> <span class="n">Base</span> <span class="p">{</span>
|
<span class="k">class</span> <span class="vg">Derived</span> <span class="k">is</span> <span class="vg">Base</span> <span class="p">{</span>
|
||||||
<span class="n">method</span> <span class="p">{</span>
|
<span class="n">method</span> <span class="p">{</span>
|
||||||
<span class="k">super</span><span class="p">.</span><span class="n">method</span> <span class="c1">// Prints "base method".</span>
|
<span class="k">super</span><span class="o">.</span><span class="n">method</span> <span class="c1">// Prints "base method".</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -153,15 +153,15 @@ call:</p>
|
|||||||
|
|
||||||
<p>You can also use <code>super</code> without a method name inside a constructor to invoke a
|
<p>You can also use <code>super</code> without a method name inside a constructor to invoke a
|
||||||
base class constructor:</p>
|
base class constructor:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Base</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Base</span> <span class="p">{</span>
|
||||||
<span class="k">this</span> <span class="k">new</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span> <span class="p">{</span>
|
<span class="nb">this</span> <span class="n">new</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"base constructor got "</span><span class="p">,</span> <span class="n">arg</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"base constructor got "</span> <span class="o">+</span> <span class="n">arg</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">class</span> <span class="nc">Derived</span> <span class="k">is</span> <span class="n">Base</span> <span class="p">{</span>
|
<span class="k">class</span> <span class="vg">Derived</span> <span class="k">is</span> <span class="vg">Base</span> <span class="p">{</span>
|
||||||
<span class="k">this</span> <span class="k">new</span><span class="p">()</span> <span class="p">{</span>
|
<span class="nb">this</span> <span class="n">new</span><span class="p">()</span> <span class="p">{</span>
|
||||||
<span class="k">super</span><span class="p">(</span><span class="s2">"value"</span><span class="p">)</span> <span class="c1">// Prints "base constructor got value".</span>
|
<span class="k">super</span><span class="p">(</span><span class="s">"value"</span><span class="p">)</span> <span class="c1">// Prints "base constructor got value".</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -179,7 +179,7 @@ and associativity. Wren has three prefix operators:</p>
|
|||||||
expression like <code>!possible</code> means "call the <code>!</code> method on <code>possible</code>".</p>
|
expression like <code>!possible</code> means "call the <code>!</code> method on <code>possible</code>".</p>
|
||||||
<p>We have a few other operators to play with. The remaining ones are
|
<p>We have a few other operators to play with. The remaining ones are
|
||||||
infix—they have operators on either side. They are:</p>
|
infix—they have operators on either side. They are:</p>
|
||||||
<div class="codehilite"><pre><span class="o">==</span> <span class="o">!=</span> <span class="o"><</span> <span class="o">></span> <span class="o"><=</span> <span class="o">>=</span> <span class="p">..</span> <span class="p">...</span> <span class="o">|</span> <span class="o">&</span> <span class="o">+</span> <span class="o">-</span> <span class="o">*</span> <span class="o">/</span> <span class="o">%</span>
|
<div class="codehilite"><pre><span class="o">==</span> <span class="o">!=</span> <span class="o"><</span> <span class="o">></span> <span class="o"><=</span> <span class="o">>=</span> <span class="o">..</span> <span class="o">...</span> <span class="o">|</span> <span class="o">&</span> <span class="o">+</span> <span class="o">-</span> <span class="o">*</span> <span class="o">/</span> <span class="o">%</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -201,7 +201,7 @@ side can be any expression. If the left-hand side is an
|
|||||||
<a href="#identifiers">identifier</a>, then the value of the right operand is stored in
|
<a href="#identifiers">identifier</a>, then the value of the right operand is stored in
|
||||||
the referenced <a href="variables.html">variable</a> or <a href="classes.html#fields">field</a>.</p>
|
the referenced <a href="variables.html">variable</a> or <a href="classes.html#fields">field</a>.</p>
|
||||||
<p>The left-hand side may also be a method call, like:</p>
|
<p>The left-hand side may also be a method call, like:</p>
|
||||||
<div class="codehilite"><pre><span class="n">point</span><span class="p">.</span><span class="n">x</span> <span class="o">=</span> <span class="m">123</span>
|
<div class="codehilite"><pre><span class="n">point</span><span class="o">.</span><span class="err">x</span> <span class="o">=</span> <span class="mi">123</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -215,21 +215,21 @@ expression will always just store the value there.</p>
|
|||||||
<h2>Subscript operators <a href="#subscript-operators" name="subscript-operators" class="header-anchor">#</a></h2>
|
<h2>Subscript operators <a href="#subscript-operators" name="subscript-operators" class="header-anchor">#</a></h2>
|
||||||
<p>Most languages use square brackets (<code>[]</code>) for working with collection-like
|
<p>Most languages use square brackets (<code>[]</code>) for working with collection-like
|
||||||
objects. For example:</p>
|
objects. For example:</p>
|
||||||
<div class="codehilite"><pre><span class="n">list</span><span class="p">[</span><span class="m">0</span><span class="p">]</span> <span class="c1">// Gets the first item in a list.</span>
|
<div class="codehilite"><pre><span class="n">list</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="c1">// Gets the first item in a list.</span>
|
||||||
<span class="n">map</span><span class="p">[</span><span class="s2">"key"</span><span class="p">]</span> <span class="c1">// Gets the value associated with "key".</span>
|
<span class="n">map</span><span class="p">[</span><span class="s">"key"</span><span class="p">]</span> <span class="c1">// Gets the value associated with "key".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>You know the refrain by now. In Wren, these are just method calls that a class
|
<p>You know the refrain by now. In Wren, these are just method calls that a class
|
||||||
may define. Subscript operators may take multiple arguments, which is useful
|
may define. Subscript operators may take multiple arguments, which is useful
|
||||||
for things like multi-dimensional arrays:</p>
|
for things like multi-dimensional arrays:</p>
|
||||||
<div class="codehilite"><pre><span class="n">matrix</span><span class="p">[</span><span class="m">3</span><span class="p">,</span> <span class="m">5</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="n">matrix</span><span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Subscripts may also be used on the left-hand side of an assignment:</p>
|
<p>Subscripts may also be used on the left-hand side of an assignment:</p>
|
||||||
<div class="codehilite"><pre><span class="n">list</span><span class="p">[</span><span class="m">0</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"item"</span>
|
<div class="codehilite"><pre><span class="n">list</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s">"item"</span>
|
||||||
<span class="n">map</span><span class="p">[</span><span class="s2">"key"</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"value"</span>
|
<span class="n">map</span><span class="p">[</span><span class="s">"key"</span><span class="p">]</span> <span class="o">=</span> <span class="s">"value"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -245,16 +245,16 @@ fixed.</p>
|
|||||||
<p>A <code>&&</code> ("logical and") expression evaluates the left-hand argument. If it's
|
<p>A <code>&&</code> ("logical and") expression evaluates the left-hand argument. If it's
|
||||||
<a href="control-flow.html#truth">false</a>, it returns that value. Otherwise it evaluates
|
<a href="control-flow.html#truth">false</a>, it returns that value. Otherwise it evaluates
|
||||||
and returns the right-hand argument.</p>
|
and returns the right-hand argument.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="kc">false</span> <span class="o">&&</span> <span class="m">1</span><span class="p">)</span> <span class="c1">// false</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="kc">false</span> <span class="o">&&</span> <span class="mi">1</span><span class="p">)</span> <span class="c1">// false</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="m">1</span> <span class="o">&&</span> <span class="m">2</span><span class="p">)</span> <span class="c1">// 2</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="mi">1</span> <span class="o">&&</span> <span class="mi">2</span><span class="p">)</span> <span class="c1">// 2</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>An <code>||</code> ("logical or") expression is reversed. If the left-hand argument is
|
<p>An <code>||</code> ("logical or") expression is reversed. If the left-hand argument is
|
||||||
<a href="control-flow.html#truth">true</a>, it's returned, otherwise the right-hand
|
<a href="control-flow.html#truth">true</a>, it's returned, otherwise the right-hand
|
||||||
argument is evaluated and returned:</p>
|
argument is evaluated and returned:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="kc">false</span> <span class="o">||</span> <span class="m">1</span><span class="p">)</span> <span class="c1">// 1</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="kc">false</span> <span class="o">||</span> <span class="mi">1</span><span class="p">)</span> <span class="c1">// 1</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="m">1</span> <span class="o">||</span> <span class="m">2</span><span class="p">)</span> <span class="c1">// 1</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="mi">1</span> <span class="o">||</span> <span class="mi">2</span><span class="p">)</span> <span class="c1">// 1</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -262,7 +262,7 @@ argument is evaluated and returned:</p>
|
|||||||
<p>Also known as the "ternary" operator since it takes three arguments, Wren has
|
<p>Also known as the "ternary" operator since it takes three arguments, Wren has
|
||||||
the little "if statement in the form of an expression" you know and love from C
|
the little "if statement in the form of an expression" you know and love from C
|
||||||
and its brethren.</p>
|
and its brethren.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="m">1</span> <span class="o">!=</span> <span class="m">2</span> <span class="o">?</span> <span class="s2">"math is sane"</span> <span class="o">:</span> <span class="s2">"math is not sane!"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="mi">1</span> <span class="o">!=</span> <span class="mi">2</span> <span class="o">?</span> <span class="s">"math is sane"</span> <span class="o">:</span> <span class="s">"math is not sane!"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -275,11 +275,11 @@ it does the else expression.</p>
|
|||||||
operator. It performs a type test. The left operand is an object and the right
|
operator. It performs a type test. The left operand is an object and the right
|
||||||
operand is a class. It evaluates to <code>true</code> if the object is an instance of the
|
operand is a class. It evaluates to <code>true</code> if the object is an instance of the
|
||||||
class (or one of its subclasses).</p>
|
class (or one of its subclasses).</p>
|
||||||
<div class="codehilite"><pre><span class="m">123</span> <span class="k">is</span> <span class="n">Num</span> <span class="c1">// true</span>
|
<div class="codehilite"><pre><span class="mi">123</span> <span class="k">is</span> <span class="vg">Num</span> <span class="c1">// true</span>
|
||||||
<span class="s2">"s"</span> <span class="k">is</span> <span class="n">Num</span> <span class="c1">// false</span>
|
<span class="s">"s"</span> <span class="k">is</span> <span class="vg">Num</span> <span class="c1">// false</span>
|
||||||
<span class="kc">null</span> <span class="k">is</span> <span class="kt">String</span> <span class="c1">// false</span>
|
<span class="kc">null</span> <span class="k">is</span> <span class="vg">String</span> <span class="c1">// false</span>
|
||||||
<span class="p">[]</span> <span class="k">is</span> <span class="n">List</span> <span class="c1">// true</span>
|
<span class="p">[]</span> <span class="k">is</span> <span class="vg">List</span> <span class="c1">// true</span>
|
||||||
<span class="p">[]</span> <span class="k">is</span> <span class="n">Sequence</span> <span class="c1">// true</span>
|
<span class="p">[]</span> <span class="k">is</span> <span class="vg">Sequence</span> <span class="c1">// true</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
54
fibers.html
54
fibers.html
@ -78,8 +78,8 @@ fiber for every line of code you type in.</p>
|
|||||||
<p>All Wren code runs within the context of a fiber. When you first start a Wren
|
<p>All Wren code runs within the context of a fiber. When you first start a Wren
|
||||||
script, a main fiber is created for you automatically. You can spawn new fibers
|
script, a main fiber is created for you automatically. You can spawn new fibers
|
||||||
using the <code>Fiber</code> class's constructor:</p>
|
using the <code>Fiber</code> class's constructor:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"This runs in a separate fiber."</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"This runs in a separate fiber."</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -90,17 +90,17 @@ code sitting there waiting to be activated, a bit like a
|
|||||||
<h2>Invoking fibers <a href="#invoking-fibers" name="invoking-fibers" class="header-anchor">#</a></h2>
|
<h2>Invoking fibers <a href="#invoking-fibers" name="invoking-fibers" class="header-anchor">#</a></h2>
|
||||||
<p>Once you've created a fiber, you can invoke it (which suspends the current
|
<p>Once you've created a fiber, you can invoke it (which suspends the current
|
||||||
fiber) by calling its <code>call()</code> method:</p>
|
fiber) by calling its <code>call()</code> method:</p>
|
||||||
<div class="codehilite"><pre><span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>The called fiber will execute its code until it reaches the end of its body or
|
<p>The called fiber will execute its code until it reaches the end of its body or
|
||||||
until it passes control to another fiber. If it reaches the end of its body,
|
until it passes control to another fiber. If it reaches the end of its body,
|
||||||
it's considered <em>done</em>:</p>
|
it's considered <em>done</em>:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Hi"</span><span class="p">)</span> <span class="p">}</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Hi"</span><span class="p">)</span> <span class="p">}</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">isDone</span> <span class="c1">// false</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">isDone</span> <span class="c1">// false</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">isDone</span> <span class="c1">// true</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">isDone</span> <span class="c1">// true</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -115,17 +115,17 @@ as one function calling another.</p>
|
|||||||
<em>back</em> to the fiber that ran it, but <em>remembers where it is</em>. The next time the
|
<em>back</em> to the fiber that ran it, but <em>remembers where it is</em>. The next time the
|
||||||
fiber is called, it picks up right where it left off and keeps going.</p>
|
fiber is called, it picks up right where it left off and keeps going.</p>
|
||||||
<p>You can make a fiber yield by calling the static <code>yield()</code> method on <code>Fiber</code>:</p>
|
<p>You can make a fiber yield by calling the static <code>yield()</code> method on <code>Fiber</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"fiber 1"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"fiber 1"</span><span class="p">)</span>
|
||||||
<span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">()</span>
|
<span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"fiber 2"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"fiber 2"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"main 1"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"main 1"</span><span class="p">)</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"main 2"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"main 2"</span><span class="p">)</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">()</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"main 3"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"main 3"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -146,13 +146,13 @@ the mercy of a thread scheduler playing Russian roulette with your code.</p>
|
|||||||
<em>data</em>. When you call a fiber, you can optionally pass a value to it. If the
|
<em>data</em>. When you call a fiber, you can optionally pass a value to it. If the
|
||||||
fiber has yielded and is waiting to resume, the value becomes the return value
|
fiber has yielded and is waiting to resume, the value becomes the return value
|
||||||
of the <code>yield()</code> call:</p>
|
of the <code>yield()</code> call:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="kd">var</span> <span class="n">result</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">()</span>
|
<span class="k">var</span> <span class="n">result</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">result</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">(</span><span class="s2">"discarded"</span><span class="p">)</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s">"discarded"</span><span class="p">)</span>
|
||||||
<span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">(</span><span class="s2">"sent"</span><span class="p">)</span>
|
<span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s">"sent"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -162,11 +162,11 @@ nowhere for the sent value to go.</p>
|
|||||||
<p>Fibers can also pass values <em>back</em> when they yield. If you pass an argument to
|
<p>Fibers can also pass values <em>back</em> when they yield. If you pass an argument to
|
||||||
<code>yield()</code>, that will become the return value of the <code>call</code> that was used to
|
<code>yield()</code>, that will become the return value of the <code>call</code> that was used to
|
||||||
invoke the fiber:</p>
|
invoke the fiber:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">(</span><span class="s2">"sent"</span><span class="p">)</span>
|
<span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">(</span><span class="s">"sent"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">fiber</span><span class="p">.</span><span class="n">call</span><span class="p">())</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">fiber</span><span class="o">.</span><span class="n">call</span><span class="p">())</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -179,9 +179,9 @@ you can iterate over.</p>
|
|||||||
<p>Wren's fibers can do that, but they can do much more. Like Lua, they are full
|
<p>Wren's fibers can do that, but they can do much more. Like Lua, they are full
|
||||||
<em>coroutines</em>—they can suspend from anywhere in the callstack. For
|
<em>coroutines</em>—they can suspend from anywhere in the callstack. For
|
||||||
example:</p>
|
example:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">fiber</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="p">(</span><span class="m">1.</span><span class="p">.</span><span class="m">10</span><span class="p">).</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="n">i</span><span class="o">|</span>
|
<span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">10</span><span class="p">)</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="err">i</span><span class="o">|</span>
|
||||||
<span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
|
<span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">(</span><span class="err">i</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|||||||
@ -73,8 +73,8 @@ you're filtering on.</p>
|
|||||||
<p>Since that's the most common usage pattern, Wren's syntax optimizes for that.
|
<p>Since that's the most common usage pattern, Wren's syntax optimizes for that.
|
||||||
Taking a page from Ruby, a function is created by passing a <em>block argument</em> to
|
Taking a page from Ruby, a function is created by passing a <em>block argument</em> to
|
||||||
a method. At its simplest, it looks like this:</p>
|
a method. At its simplest, it looks like this:</p>
|
||||||
<div class="codehilite"><pre><span class="n">blondie</span><span class="p">.</span><span class="n">callMe</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="n">blondie</span><span class="o">.</span><span class="n">callMe</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"This is the body!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"This is the body!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -84,7 +84,7 @@ argument, a function whose body is the following
|
|||||||
<a href="syntax.html#blocks">block</a>—everything between that pair of curly braces.</p>
|
<a href="syntax.html#blocks">block</a>—everything between that pair of curly braces.</p>
|
||||||
<p>Methods that take a block argument receive it as a normal parameter. <code>callMe</code>
|
<p>Methods that take a block argument receive it as a normal parameter. <code>callMe</code>
|
||||||
could be defined like so:</p>
|
could be defined like so:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Blondie</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Blondie</span> <span class="p">{</span>
|
||||||
<span class="n">callMe</span><span class="p">(</span><span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">callMe</span><span class="p">(</span><span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="c1">// Call it...</span>
|
<span class="c1">// Call it...</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
@ -94,8 +94,8 @@ could be defined like so:</p>
|
|||||||
|
|
||||||
<p>A method can take other arguments in addition to the block. They appear before
|
<p>A method can take other arguments in addition to the block. They appear before
|
||||||
the block just like a regular argument list. For example:</p>
|
the block just like a regular argument list. For example:</p>
|
||||||
<div class="codehilite"><pre><span class="n">blondie</span><span class="p">.</span><span class="n">callMeAt</span><span class="p">(</span><span class="m">867</span><span class="p">,</span> <span class="m">5309</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="n">blondie</span><span class="o">.</span><span class="n">callMeAt</span><span class="p">(</span><span class="mi">867</span><span class="p">,</span> <span class="mi">5309</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"This is the body!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"This is the body!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -103,8 +103,8 @@ the block just like a regular argument list. For example:</p>
|
|||||||
<p>Of course, you don't <em>have</em> to use a block argument to pass a function to a
|
<p>Of course, you don't <em>have</em> to use a block argument to pass a function to a
|
||||||
method. If you already have a function object, you can pass it like a regular
|
method. If you already have a function object, you can pass it like a regular
|
||||||
argument:</p>
|
argument:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">someFn</span> <span class="o">=</span> <span class="c1">// Get a function...</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">someFn</span> <span class="o">=</span> <span class="c1">// Get a function...</span>
|
||||||
<span class="n">blondie</span><span class="p">.</span><span class="n">callMe</span><span class="p">(</span><span class="n">someFn</span><span class="p">)</span>
|
<span class="n">blondie</span><span class="o">.</span><span class="n">callMe</span><span class="p">(</span><span class="n">someFn</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -112,8 +112,8 @@ argument:</p>
|
|||||||
little blob of syntax. There are some times when you want to create a function
|
little blob of syntax. There are some times when you want to create a function
|
||||||
but <em>don't</em> need to pass it to a method. For that, you can call the <code>Fn</code>
|
but <em>don't</em> need to pass it to a method. For that, you can call the <code>Fn</code>
|
||||||
class's constructor:</p>
|
class's constructor:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">someFn</span> <span class="o">=</span> <span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">someFn</span> <span class="o">=</span> <span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Hi!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Hi!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -123,9 +123,9 @@ return that, so this exists purely as a convenience method for you.</p>
|
|||||||
<h2>Calling functions <a href="#calling-functions" name="calling-functions" class="header-anchor">#</a></h2>
|
<h2>Calling functions <a href="#calling-functions" name="calling-functions" class="header-anchor">#</a></h2>
|
||||||
<p>Once you have a function, how do you invoke it? Like everything in Wren, you do
|
<p>Once you have a function, how do you invoke it? Like everything in Wren, you do
|
||||||
so by calling a method on it:</p>
|
so by calling a method on it:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Blondie</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Blondie</span> <span class="p">{</span>
|
||||||
<span class="n">callMe</span><span class="p">(</span><span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">callMe</span><span class="p">(</span><span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">fn</span><span class="p">.</span><span class="n">call</span><span class="p">()</span>
|
<span class="n">fn</span><span class="o">.</span><span class="n">call</span><span class="p">()</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -134,13 +134,13 @@ so by calling a method on it:</p>
|
|||||||
<p>Functions expose a <code>call()</code> method that executes the body of the function. This
|
<p>Functions expose a <code>call()</code> method that executes the body of the function. This
|
||||||
method is dynamically-dispatched like any other, so you can define your own
|
method is dynamically-dispatched like any other, so you can define your own
|
||||||
"function-like" classes and pass them to methods that expect "real" functions.</p>
|
"function-like" classes and pass them to methods that expect "real" functions.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">FakeFn</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">FakeFn</span> <span class="p">{</span>
|
||||||
<span class="n">call</span><span class="p">()</span> <span class="p">{</span>
|
<span class="n">call</span><span class="p">()</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"I'm feeling functional!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"I'm feeling functional!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">blondie</span><span class="p">.</span><span class="n">callMe</span><span class="p">(</span><span class="n">FakeFn</span><span class="p">.</span><span class="k">new</span><span class="p">())</span>
|
<span class="n">blondie</span><span class="o">.</span><span class="n">callMe</span><span class="p">(</span><span class="vg">FakeFn</span><span class="o">.</span><span class="n">new</span><span class="p">())</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -149,17 +149,17 @@ method is dynamically-dispatched like any other, so you can define your own
|
|||||||
functions that we've seen so far take no arguments. To change that, you can
|
functions that we've seen so far take no arguments. To change that, you can
|
||||||
provide a parameter list surrounded by <code>|</code> immediately after the opening brace
|
provide a parameter list surrounded by <code>|</code> immediately after the opening brace
|
||||||
of the body, like so:</p>
|
of the body, like so:</p>
|
||||||
<div class="codehilite"><pre><span class="n">blondie</span><span class="p">.</span><span class="n">callMe</span> <span class="p">{</span><span class="o">|</span><span class="n">first</span><span class="p">,</span> <span class="n">last</span><span class="o">|</span>
|
<div class="codehilite"><pre><span class="n">blondie</span><span class="o">.</span><span class="n">callMe</span> <span class="p">{</span><span class="o">|</span><span class="n">first</span><span class="p">,</span> <span class="n">last</span><span class="o">|</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Hi, "</span> <span class="o">+</span> <span class="n">first</span> <span class="o">+</span> <span class="s2">" "</span> <span class="o">+</span> <span class="n">last</span> <span class="o">+</span> <span class="s2">"!"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Hi, "</span> <span class="o">+</span> <span class="n">first</span> <span class="o">+</span> <span class="s">" "</span> <span class="o">+</span> <span class="n">last</span> <span class="o">+</span> <span class="s">"!"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Here we're passing a function to <code>greet</code> that takes two parameters, <code>first</code> and
|
<p>Here we're passing a function to <code>greet</code> that takes two parameters, <code>first</code> and
|
||||||
<code>last</code>. They are passed to the function when it's called:</p>
|
<code>last</code>. They are passed to the function when it's called:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Blondie</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Blondie</span> <span class="p">{</span>
|
||||||
<span class="n">callMe</span><span class="p">(</span><span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">callMe</span><span class="p">(</span><span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">fn</span><span class="p">.</span><span class="n">call</span><span class="p">(</span><span class="s2">"Debbie"</span><span class="p">,</span> <span class="s2">"Harry"</span><span class="p">)</span>
|
<span class="n">fn</span><span class="o">.</span><span class="n">call</span><span class="p">(</span><span class="s">"Debbie"</span><span class="p">,</span> <span class="s">"Harry"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -175,10 +175,10 @@ expression.</p>
|
|||||||
<p>Otherwise, the body returns <code>null</code> by default. You can explicitly return a
|
<p>Otherwise, the body returns <code>null</code> by default. You can explicitly return a
|
||||||
value using a <code>return</code> statement. In other words, these two functions do the
|
value using a <code>return</code> statement. In other words, these two functions do the
|
||||||
same thing:</p>
|
same thing:</p>
|
||||||
<div class="codehilite"><pre><span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span> <span class="s2">"return value"</span> <span class="p">}</span>
|
<div class="codehilite"><pre><span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span> <span class="s">"return value"</span> <span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="k">return</span> <span class="s2">"return value"</span>
|
<span class="k">return</span> <span class="s">"return value"</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -187,10 +187,10 @@ same thing:</p>
|
|||||||
<p>As you expect, functions are closures—they can access variables defined
|
<p>As you expect, functions are closures—they can access variables defined
|
||||||
outside of their scope. They will hold onto closed-over variables even after
|
outside of their scope. They will hold onto closed-over variables even after
|
||||||
leaving the scope where the function is defined:</p>
|
leaving the scope where the function is defined:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Counter</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Counter</span> <span class="p">{</span>
|
||||||
<span class="kd">static</span> <span class="n">create</span> <span class="p">{</span>
|
<span class="k">static</span> <span class="n">create</span> <span class="p">{</span>
|
||||||
<span class="kd">var</span> <span class="n">i</span> <span class="o">=</span> <span class="m">0</span>
|
<span class="k">var</span> <span class="err">i</span> <span class="o">=</span> <span class="mi">0</span>
|
||||||
<span class="k">return</span> <span class="n">Fn</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span> <span class="n">i</span> <span class="o">=</span> <span class="n">i</span> <span class="o">+</span> <span class="m">1</span> <span class="p">}</span>
|
<span class="k">return</span> <span class="vg">Fn</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span> <span class="err">i</span> <span class="o">=</span> <span class="err">i</span> <span class="o">+</span> <span class="mi">1</span> <span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
@ -200,10 +200,10 @@ leaving the scope where the function is defined:</p>
|
|||||||
function references a variable <code>i</code> declared outside of the function. Even after
|
function references a variable <code>i</code> declared outside of the function. Even after
|
||||||
the function is returned from <code>create</code>, it is still able to read and assign
|
the function is returned from <code>create</code>, it is still able to read and assign
|
||||||
to<code>i</code>:</p>
|
to<code>i</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">counter</span> <span class="o">=</span> <span class="n">Counter</span><span class="p">.</span><span class="n">create</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">counter</span> <span class="o">=</span> <span class="vg">Counter</span><span class="o">.</span><span class="n">create</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">counter</span><span class="p">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// Prints "1".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">counter</span><span class="o">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// Prints "1".</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">counter</span><span class="p">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// Prints "2".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">counter</span><span class="o">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// Prints "2".</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">counter</span><span class="p">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// Prints "3".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">counter</span><span class="o">.</span><span class="n">call</span><span class="p">())</span> <span class="c1">// Prints "3".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
@ -102,12 +102,12 @@ download libuv since it isn't needed.</p>
|
|||||||
<p>The above instructions will drop you into Wren's standalone interpreter in
|
<p>The above instructions will drop you into Wren's standalone interpreter in
|
||||||
interactive mode. You can type in a line of code, and it will immediately
|
interactive mode. You can type in a line of code, and it will immediately
|
||||||
execute it. Here's something to try:</p>
|
execute it. Here's something to try:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Hello, world!"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Hello, world!"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Or a little more exciting:</p>
|
<p>Or a little more exciting:</p>
|
||||||
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">i</span> <span class="k">in</span> <span class="m">1.</span><span class="p">.</span><span class="m">10</span><span class="p">)</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Counting up "</span><span class="p">,</span> <span class="n">i</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="err">i</span> <span class="k">in</span> <span class="mi">1</span><span class="o">..</span><span class="mi">10</span><span class="p">)</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Counting up "</span> <span class="o">+</span> <span class="err">i</span><span class="o">.</span><span class="n">toString</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -117,24 +117,24 @@ your computer to the ground and storm off.</p>
|
|||||||
<p>The standalone interpreter can also load scripts from files and run them. Just
|
<p>The standalone interpreter can also load scripts from files and run them. Just
|
||||||
pass the name of the script to wren. Create a file named "my_script.wren" in
|
pass the name of the script to wren. Create a file named "my_script.wren" in
|
||||||
your favorite text editor and paste this into it:</p>
|
your favorite text editor and paste this into it:</p>
|
||||||
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">yPixel</span> <span class="k">in</span> <span class="m">0.</span><span class="p">..</span><span class="m">24</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">for</span> <span class="p">(</span><span class="n">yPixel</span> <span class="k">in</span> <span class="mi">0</span><span class="o">...</span><span class="mi">24</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="kd">var</span> <span class="n">y</span> <span class="o">=</span> <span class="n">yPixel</span> <span class="o">/</span> <span class="m">12</span> <span class="o">-</span> <span class="m">1</span>
|
<span class="k">var</span> <span class="err">y</span> <span class="o">=</span> <span class="n">yPixel</span> <span class="o">/</span> <span class="mi">12</span> <span class="o">-</span> <span class="mi">1</span>
|
||||||
<span class="k">for</span> <span class="p">(</span><span class="n">xPixel</span> <span class="k">in</span> <span class="m">0.</span><span class="p">..</span><span class="m">80</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">for</span> <span class="p">(</span><span class="n">xPixel</span> <span class="k">in</span> <span class="mi">0</span><span class="o">...</span><span class="mi">80</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="kd">var</span> <span class="n">x</span> <span class="o">=</span> <span class="n">xPixel</span> <span class="o">/</span> <span class="m">30</span> <span class="o">-</span> <span class="m">2</span>
|
<span class="k">var</span> <span class="err">x</span> <span class="o">=</span> <span class="n">xPixel</span> <span class="o">/</span> <span class="mi">30</span> <span class="o">-</span> <span class="mi">2</span>
|
||||||
<span class="kd">var</span> <span class="n">x0</span> <span class="o">=</span> <span class="n">x</span>
|
<span class="k">var</span> <span class="n">x0</span> <span class="o">=</span> <span class="err">x</span>
|
||||||
<span class="kd">var</span> <span class="n">y0</span> <span class="o">=</span> <span class="n">y</span>
|
<span class="k">var</span> <span class="n">y0</span> <span class="o">=</span> <span class="err">y</span>
|
||||||
<span class="kd">var</span> <span class="n">iter</span> <span class="o">=</span> <span class="m">0</span>
|
<span class="k">var</span> <span class="n">iter</span> <span class="o">=</span> <span class="mi">0</span>
|
||||||
<span class="k">while</span> <span class="p">(</span><span class="n">iter</span> <span class="o"><</span> <span class="m">11</span> <span class="o">&&</span> <span class="n">x0</span> <span class="o">*</span> <span class="n">x0</span> <span class="o">+</span> <span class="n">y0</span> <span class="o">*</span> <span class="n">y0</span> <span class="o"><=</span> <span class="m">4</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">while</span> <span class="p">(</span><span class="n">iter</span> <span class="o"><</span> <span class="mi">11</span> <span class="o">&&</span> <span class="n">x0</span> <span class="o">*</span> <span class="n">x0</span> <span class="o">+</span> <span class="n">y0</span> <span class="o">*</span> <span class="n">y0</span> <span class="o"><=</span> <span class="mi">4</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="kd">var</span> <span class="n">x1</span> <span class="o">=</span> <span class="p">(</span><span class="n">x0</span> <span class="o">*</span> <span class="n">x0</span><span class="p">)</span> <span class="o">-</span> <span class="p">(</span><span class="n">y0</span> <span class="o">*</span> <span class="n">y0</span><span class="p">)</span> <span class="o">+</span> <span class="n">x</span>
|
<span class="k">var</span> <span class="n">x1</span> <span class="o">=</span> <span class="p">(</span><span class="n">x0</span> <span class="o">*</span> <span class="n">x0</span><span class="p">)</span> <span class="o">-</span> <span class="p">(</span><span class="n">y0</span> <span class="o">*</span> <span class="n">y0</span><span class="p">)</span> <span class="o">+</span> <span class="err">x</span>
|
||||||
<span class="kd">var</span> <span class="n">y1</span> <span class="o">=</span> <span class="m">2</span> <span class="o">*</span> <span class="n">x0</span> <span class="o">*</span> <span class="n">y0</span> <span class="o">+</span> <span class="n">y</span>
|
<span class="k">var</span> <span class="n">y1</span> <span class="o">=</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">x0</span> <span class="o">*</span> <span class="n">y0</span> <span class="o">+</span> <span class="err">y</span>
|
||||||
<span class="n">x0</span> <span class="o">=</span> <span class="n">x1</span>
|
<span class="n">x0</span> <span class="o">=</span> <span class="n">x1</span>
|
||||||
<span class="n">y0</span> <span class="o">=</span> <span class="n">y1</span>
|
<span class="n">y0</span> <span class="o">=</span> <span class="n">y1</span>
|
||||||
<span class="n">iter</span> <span class="o">=</span> <span class="n">iter</span> <span class="o">+</span> <span class="m">1</span>
|
<span class="n">iter</span> <span class="o">=</span> <span class="n">iter</span> <span class="o">+</span> <span class="mi">1</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">write</span><span class="p">(</span><span class="s2">" .-:;+=xX$& "</span><span class="p">[</span><span class="n">iter</span><span class="p">])</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">" .-:;+=xX$& "</span><span class="p">[</span><span class="n">iter</span><span class="p">])</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">""</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">""</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|||||||
12
index.html
12
index.html
@ -62,19 +62,19 @@
|
|||||||
<h2>Wren is a small, fast, class-based concurrent scripting language <a href="#wren-is-a-small,-fast,-class-based-concurrent-scripting-language" name="wren-is-a-small,-fast,-class-based-concurrent-scripting-language" class="header-anchor">#</a></h2>
|
<h2>Wren is a small, fast, class-based concurrent scripting language <a href="#wren-is-a-small,-fast,-class-based-concurrent-scripting-language" name="wren-is-a-small,-fast,-class-based-concurrent-scripting-language" class="header-anchor">#</a></h2>
|
||||||
<p>Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in
|
<p>Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in
|
||||||
a familiar, modern <a href="syntax.html">syntax</a>.</p>
|
a familiar, modern <a href="syntax.html">syntax</a>.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Hello, world!"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Hello, world!"</span><span class="p">)</span>
|
||||||
|
|
||||||
<span class="kd">class</span> <span class="nc">Wren</span> <span class="p">{</span>
|
<span class="k">class</span> <span class="vg">Wren</span> <span class="p">{</span>
|
||||||
<span class="n">flyTo</span><span class="p">(</span><span class="n">city</span><span class="p">)</span> <span class="p">{</span>
|
<span class="n">flyTo</span><span class="p">(</span><span class="n">city</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"Flying to "</span><span class="p">,</span> <span class="n">city</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Flying to "</span> <span class="o">+</span> <span class="n">city</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="kd">var</span> <span class="n">adjectives</span> <span class="o">=</span> <span class="n">Fiber</span><span class="p">.</span><span class="k">new</span> <span class="p">{</span>
|
<span class="k">var</span> <span class="n">adjectives</span> <span class="o">=</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">new</span> <span class="p">{</span>
|
||||||
<span class="p">[</span><span class="s2">"small"</span><span class="p">,</span> <span class="s2">"clean"</span><span class="p">,</span> <span class="s2">"fast"</span><span class="p">].</span><span class="n">each</span> <span class="p">{</span><span class="o">|</span><span class="n">word</span><span class="o">|</span> <span class="n">Fiber</span><span class="p">.</span><span class="n">yield</span><span class="p">(</span><span class="n">word</span><span class="p">)</span> <span class="p">}</span>
|
<span class="p">[</span><span class="s">"small"</span><span class="p">,</span> <span class="s">"clean"</span><span class="p">,</span> <span class="s">"fast"</span><span class="p">]</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span><span class="o">|</span><span class="n">word</span><span class="o">|</span> <span class="vg">Fiber</span><span class="o">.</span><span class="n">yield</span><span class="p">(</span><span class="n">word</span><span class="p">)</span> <span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="k">while</span> <span class="p">(</span><span class="o">!</span><span class="n">adjectives</span><span class="p">.</span><span class="n">isDone</span><span class="p">)</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">adjectives</span><span class="p">.</span><span class="n">call</span><span class="p">())</span>
|
<span class="k">while</span> <span class="p">(</span><span class="o">!</span><span class="n">adjectives</span><span class="o">.</span><span class="n">isDone</span><span class="p">)</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">adjectives</span><span class="o">.</span><span class="n">call</span><span class="p">())</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
50
lists.html
50
lists.html
@ -62,7 +62,7 @@
|
|||||||
<p>A list is a compound object that holds a collection of elements identified by
|
<p>A list is a compound object that holds a collection of elements identified by
|
||||||
integer index. You can create a list by placing a sequence of comma-separated
|
integer index. You can create a list by placing a sequence of comma-separated
|
||||||
expressions inside square brackets:</p>
|
expressions inside square brackets:</p>
|
||||||
<div class="codehilite"><pre><span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="s2">"banana"</span><span class="p">,</span> <span class="kc">true</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="s">"banana"</span><span class="p">,</span> <span class="kc">true</span><span class="p">]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -72,28 +72,28 @@ have to be the same type.</p>
|
|||||||
<p>You can access an element from a list by calling the <a href="expressions.html#subscript-operators">subscript
|
<p>You can access an element from a list by calling the <a href="expressions.html#subscript-operators">subscript
|
||||||
operator</a> on it with the index of the
|
operator</a> on it with the index of the
|
||||||
element you want. Like most languages, indexes start at zero:</p>
|
element you want. Like most languages, indexes start at zero:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">hirsute</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"sideburns"</span><span class="p">,</span> <span class="s2">"porkchops"</span><span class="p">,</span> <span class="s2">"'stache"</span><span class="p">,</span> <span class="s2">"goatee"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">hirsute</span> <span class="o">=</span> <span class="p">[</span><span class="s">"sideburns"</span><span class="p">,</span> <span class="s">"porkchops"</span><span class="p">,</span> <span class="s">"'stache"</span><span class="p">,</span> <span class="s">"goatee"</span><span class="p">]</span>
|
||||||
<span class="n">hirsute</span><span class="p">[</span><span class="m">0</span><span class="p">]</span> <span class="c1">// "sideburns".</span>
|
<span class="n">hirsute</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="c1">// "sideburns".</span>
|
||||||
<span class="n">hirsute</span><span class="p">[</span><span class="m">1</span><span class="p">]</span> <span class="c1">// "porkchops".</span>
|
<span class="n">hirsute</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="c1">// "porkchops".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Negative indices counts backwards from the end:</p>
|
<p>Negative indices counts backwards from the end:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="o">-</span><span class="m">1</span><span class="p">]</span> <span class="c1">// "goatee".</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="c1">// "goatee".</span>
|
||||||
<span class="n">hirsute</span><span class="p">[</span><span class="o">-</span><span class="m">2</span><span class="p">]</span> <span class="c1">// "'stache".</span>
|
<span class="n">hirsute</span><span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">]</span> <span class="c1">// "'stache".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>It's a runtime error to pass an index outside of the bounds of the list. If you
|
<p>It's a runtime error to pass an index outside of the bounds of the list. If you
|
||||||
don't know what those bounds are, you can find out using count:</p>
|
don't know what those bounds are, you can find out using count:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">.</span><span class="n">count</span> <span class="c1">// 4.</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="o">.</span><span class="n">count</span> <span class="c1">// 4.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h2>Slices and ranges <a href="#slices-and-ranges" name="slices-and-ranges" class="header-anchor">#</a></h2>
|
<h2>Slices and ranges <a href="#slices-and-ranges" name="slices-and-ranges" class="header-anchor">#</a></h2>
|
||||||
<p>Sometimes you want to copy a chunk of elements from a list. You can do that by
|
<p>Sometimes you want to copy a chunk of elements from a list. You can do that by
|
||||||
passing a <a href="values.html#ranges">range</a> to the subscript operator, like so:</p>
|
passing a <a href="values.html#ranges">range</a> to the subscript operator, like so:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="m">1.</span><span class="p">.</span><span class="m">2</span><span class="p">]</span> <span class="c1">// ["porkchops", "'stache"].</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="mi">1</span><span class="o">..</span><span class="mi">2</span><span class="p">]</span> <span class="c1">// ["porkchops", "'stache"].</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -102,27 +102,27 @@ indices are within the given range. Both inclusive and exclusive ranges work
|
|||||||
and do what you expect.</p>
|
and do what you expect.</p>
|
||||||
<p>Negative bounds also work like they do when passing a single number, so to copy
|
<p>Negative bounds also work like they do when passing a single number, so to copy
|
||||||
a list, you can just do:</p>
|
a list, you can just do:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="m">0.</span><span class="p">.</span><span class="o">-</span><span class="m">1</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="mi">0</span><span class="o">..-</span><span class="mi">1</span><span class="p">]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h2>Adding elements <a href="#adding-elements" name="adding-elements" class="header-anchor">#</a></h2>
|
<h2>Adding elements <a href="#adding-elements" name="adding-elements" class="header-anchor">#</a></h2>
|
||||||
<p>Lists are <em>mutable</em>, meaning their contents can be changed. You can swap out an
|
<p>Lists are <em>mutable</em>, meaning their contents can be changed. You can swap out an
|
||||||
existing element in the list using the subscript setter:</p>
|
existing element in the list using the subscript setter:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="m">1</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"muttonchops"</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="s">"muttonchops"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">hirsute</span><span class="p">[</span><span class="m">1</span><span class="p">])</span> <span class="c1">// muttonchops.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">hirsute</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span> <span class="c1">// muttonchops.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>It's an error to set an element that's out of bounds. To grow a list, you can
|
<p>It's an error to set an element that's out of bounds. To grow a list, you can
|
||||||
use <code>add</code> to append a single item to the end:</p>
|
use <code>add</code> to append a single item to the end:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">.</span><span class="n">add</span><span class="p">(</span><span class="s2">"goatee"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="s">"goatee"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">hirsute</span><span class="p">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// 4.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">hirsute</span><span class="o">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// 4.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>You can insert a new element at a specific position using <code>insert</code>:</p>
|
<p>You can insert a new element at a specific position using <code>insert</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="m">2</span><span class="p">,</span> <span class="s2">"soul patch"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="s">"soul patch"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -132,11 +132,11 @@ make room for it.</p>
|
|||||||
<p>It's valid to "insert" after the last element in the list, but only <em>right</em>
|
<p>It's valid to "insert" after the last element in the list, but only <em>right</em>
|
||||||
after it. Like other methods, you can use a negative index to count from the
|
after it. Like other methods, you can use a negative index to count from the
|
||||||
back. Doing so counts back from the size of the list <em>after</em> it's grown by one:</p>
|
back. Doing so counts back from the size of the list <em>after</em> it's grown by one:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">letters</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">letters</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">]</span>
|
||||||
<span class="n">letters</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="m">3</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">)</span> <span class="c1">// OK: inserts at end.</span>
|
<span class="n">letters</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="s">"d"</span><span class="p">)</span> <span class="c1">// OK: inserts at end.</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="p">)</span> <span class="c1">// ["a", "b", "c", "d"]</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="p">)</span> <span class="c1">// ["a", "b", "c", "d"]</span>
|
||||||
<span class="n">letters</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="o">-</span><span class="m">2</span><span class="p">,</span> <span class="s2">"e"</span><span class="p">)</span> <span class="c1">// Counts back from size after insert.</span>
|
<span class="n">letters</span><span class="o">.</span><span class="n">insert</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="s">"e"</span><span class="p">)</span> <span class="c1">// Counts back from size after insert.</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="p">)</span> <span class="c1">// ["a", "b", "c", "e", "d"]</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="p">)</span> <span class="c1">// ["a", "b", "c", "e", "d"]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -144,20 +144,20 @@ back. Doing so counts back from the size of the list <em>after</em> it's grown b
|
|||||||
<p>The opposite of <code>insert</code> is <code>removeAt</code>. It removes a single element from a
|
<p>The opposite of <code>insert</code> is <code>removeAt</code>. It removes a single element from a
|
||||||
given position in the list. All following items are shifted up to fill in the
|
given position in the list. All following items are shifted up to fill in the
|
||||||
gap:</p>
|
gap:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">letters</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">letters</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">,</span> <span class="s">"d"</span><span class="p">]</span>
|
||||||
<span class="n">letters</span><span class="p">.</span><span class="n">removeAt</span><span class="p">(</span><span class="m">1</span><span class="p">)</span>
|
<span class="n">letters</span><span class="o">.</span><span class="n">removeAt</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="p">)</span> <span class="c1">// ["a", "c", "d"]</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="p">)</span> <span class="c1">// ["a", "c", "d"]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>The <code>removeAt</code> method returns the removed item:</p>
|
<p>The <code>removeAt</code> method returns the removed item:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="p">.</span><span class="n">removeAt</span><span class="p">(</span><span class="m">1</span><span class="p">))</span> <span class="c1">// "c"</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">letters</span><span class="o">.</span><span class="n">removeAt</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span> <span class="c1">// "c"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>If you want to remove everything from the list, you can clear it:</p>
|
<p>If you want to remove everything from the list, you can clear it:</p>
|
||||||
<div class="codehilite"><pre><span class="n">hirsute</span><span class="p">.</span><span class="n">clear</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="n">hirsute</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">hirsute</span><span class="p">)</span> <span class="c1">// []</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">hirsute</span><span class="p">)</span> <span class="c1">// []</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
</div>
|
</div>
|
||||||
|
|||||||
52
maps.html
52
maps.html
@ -65,10 +65,10 @@ other languages: hash table, dictionary, association, table, etc.</p>
|
|||||||
<p>You can create a map by placing a series of comma-separated entries inside
|
<p>You can create a map by placing a series of comma-separated entries inside
|
||||||
curly braces. Each entry is a key and a value separated by a colon:</p>
|
curly braces. Each entry is a key and a value separated by a colon:</p>
|
||||||
<div class="codehilite"><pre><span class="p">{</span>
|
<div class="codehilite"><pre><span class="p">{</span>
|
||||||
<span class="s2">"George"</span><span class="o">:</span> <span class="s2">"Harrison"</span><span class="p">,</span>
|
<span class="s">"George"</span><span class="o">:</span> <span class="s">"Harrison"</span><span class="p">,</span>
|
||||||
<span class="s2">"John"</span><span class="o">:</span> <span class="s2">"Lennon"</span><span class="p">,</span>
|
<span class="s">"John"</span><span class="o">:</span> <span class="s">"Lennon"</span><span class="p">,</span>
|
||||||
<span class="s2">"Paul"</span><span class="o">:</span> <span class="s2">"McCartney"</span><span class="p">,</span>
|
<span class="s">"Paul"</span><span class="o">:</span> <span class="s">"McCartney"</span><span class="p">,</span>
|
||||||
<span class="s2">"Ringo"</span><span class="o">:</span> <span class="s2">"Starr"</span>
|
<span class="s">"Ringo"</span><span class="o">:</span> <span class="s">"Starr"</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -92,10 +92,10 @@ time, even in very large maps. Since Wren only knows how to hash certain
|
|||||||
built-in types, only those can be used as keys.</p>
|
built-in types, only those can be used as keys.</p>
|
||||||
<h2>Adding entries <a href="#adding-entries" name="adding-entries" class="header-anchor">#</a></h2>
|
<h2>Adding entries <a href="#adding-entries" name="adding-entries" class="header-anchor">#</a></h2>
|
||||||
<p>You add new key-value pairs to the map by using the <a href="expressions.html#subscript-operators">subscript operator</a>:</p>
|
<p>You add new key-value pairs to the map by using the <a href="expressions.html#subscript-operators">subscript operator</a>:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">capitals</span> <span class="o">=</span> <span class="p">{}</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">capitals</span> <span class="o">=</span> <span class="p">{}</span>
|
||||||
<span class="n">capitals</span><span class="p">[</span><span class="s2">"Georgia"</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"Atlanta"</span>
|
<span class="n">capitals</span><span class="p">[</span><span class="s">"Georgia"</span><span class="p">]</span> <span class="o">=</span> <span class="s">"Atlanta"</span>
|
||||||
<span class="n">capitals</span><span class="p">[</span><span class="s2">"Idaho"</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"Boise"</span>
|
<span class="n">capitals</span><span class="p">[</span><span class="s">"Idaho"</span><span class="p">]</span> <span class="o">=</span> <span class="s">"Boise"</span>
|
||||||
<span class="n">capitals</span><span class="p">[</span><span class="s2">"Maine"</span><span class="p">]</span> <span class="o">=</span> <span class="s2">"Augusta"</span>
|
<span class="n">capitals</span><span class="p">[</span><span class="s">"Maine"</span><span class="p">]</span> <span class="o">=</span> <span class="s">"Augusta"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -104,7 +104,7 @@ value. If the key is already there, this just replaces its value.</p>
|
|||||||
<h2>Looking up values <a href="#looking-up-values" name="looking-up-values" class="header-anchor">#</a></h2>
|
<h2>Looking up values <a href="#looking-up-values" name="looking-up-values" class="header-anchor">#</a></h2>
|
||||||
<p>To find the value associated with some key, again you use your friend the
|
<p>To find the value associated with some key, again you use your friend the
|
||||||
subscript operator:</p>
|
subscript operator:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="p">[</span><span class="s2">"Idaho"</span><span class="p">])</span> <span class="c1">// "Boise".</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="p">[</span><span class="s">"Idaho"</span><span class="p">])</span> <span class="c1">// "Boise".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -112,38 +112,38 @@ subscript operator:</p>
|
|||||||
course, <code>null</code> itself can also be used as a value, so seeing <code>null</code> here
|
course, <code>null</code> itself can also be used as a value, so seeing <code>null</code> here
|
||||||
doesn't necessarily mean the key wasn't found.</p>
|
doesn't necessarily mean the key wasn't found.</p>
|
||||||
<p>To tell definitively if a key exists, you can call <code>containsKey()</code>:</p>
|
<p>To tell definitively if a key exists, you can call <code>containsKey()</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">belief</span> <span class="o">=</span> <span class="p">{</span><span class="s2">"nihilism"</span><span class="o">:</span> <span class="kc">null</span><span class="p">}</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">belief</span> <span class="o">=</span> <span class="p">{</span><span class="s">"nihilism"</span><span class="o">:</span> <span class="kc">null</span><span class="p">}</span>
|
||||||
|
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="p">[</span><span class="s2">"nihilism"</span><span class="p">])</span> <span class="c1">// "null" though key exists.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="p">[</span><span class="s">"nihilism"</span><span class="p">])</span> <span class="c1">// "null" though key exists.</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="p">[</span><span class="s2">"solipsism"</span><span class="p">])</span> <span class="c1">// Also "null".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="p">[</span><span class="s">"solipsism"</span><span class="p">])</span> <span class="c1">// Also "null".</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="p">.</span><span class="n">containsKey</span><span class="p">(</span><span class="s2">"nihilism"</span><span class="p">))</span> <span class="c1">// "true".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="o">.</span><span class="n">containsKey</span><span class="p">(</span><span class="s">"nihilism"</span><span class="p">))</span> <span class="c1">// "true".</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="p">.</span><span class="n">containsKey</span><span class="p">(</span><span class="s2">"solipsism"</span><span class="p">))</span> <span class="c1">// "false".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">belief</span><span class="o">.</span><span class="n">containsKey</span><span class="p">(</span><span class="s">"solipsism"</span><span class="p">))</span> <span class="c1">// "false".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>You can see how many entries a map contains using <code>count</code>:</p>
|
<p>You can see how many entries a map contains using <code>count</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="p">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// "3".</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="o">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// "3".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h2>Removing entries <a href="#removing-entries" name="removing-entries" class="header-anchor">#</a></h2>
|
<h2>Removing entries <a href="#removing-entries" name="removing-entries" class="header-anchor">#</a></h2>
|
||||||
<p>To remove an entry from a map, call <code>remove()</code> and pass in the key for the
|
<p>To remove an entry from a map, call <code>remove()</code> and pass in the key for the
|
||||||
entry you want to delete:</p>
|
entry you want to delete:</p>
|
||||||
<div class="codehilite"><pre><span class="n">capitals</span><span class="p">.</span><span class="n">remove</span><span class="p">(</span><span class="s2">"Maine"</span><span class="p">)</span>
|
<div class="codehilite"><pre><span class="n">capitals</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="s">"Maine"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="p">.</span><span class="n">containsKey</span><span class="p">(</span><span class="s2">"Maine"</span><span class="p">))</span> <span class="c1">// "false".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="o">.</span><span class="n">containsKey</span><span class="p">(</span><span class="s">"Maine"</span><span class="p">))</span> <span class="c1">// "false".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>If the key was found, this returns the value that was associated with it:</p>
|
<p>If the key was found, this returns the value that was associated with it:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="p">.</span><span class="n">remove</span><span class="p">(</span><span class="s2">"Georgia"</span><span class="p">))</span> <span class="c1">// "Atlanta".</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="s">"Georgia"</span><span class="p">))</span> <span class="c1">// "Atlanta".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>If the key wasn't in the map to begin with, <code>remove()</code> just returns <code>null</code>.</p>
|
<p>If the key wasn't in the map to begin with, <code>remove()</code> just returns <code>null</code>.</p>
|
||||||
<p>If you want to remove <em>everything</em> from the map, just like with <a href="lists.html">lists</a>, you
|
<p>If you want to remove <em>everything</em> from the map, just like with <a href="lists.html">lists</a>, you
|
||||||
can just call <code>clear()</code>:</p>
|
can just call <code>clear()</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="n">capitals</span><span class="p">.</span><span class="n">clear</span><span class="p">()</span>
|
<div class="codehilite"><pre><span class="n">capitals</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="p">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// "0".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">capitals</span><span class="o">.</span><span class="n">count</span><span class="p">)</span> <span class="c1">// "0".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -155,14 +155,14 @@ For that, map exposes two methods: <code>keys</code> and <code>values</code>.</p
|
|||||||
map, and the second returns one that iterates over the values.</p>
|
map, and the second returns one that iterates over the values.</p>
|
||||||
<p>If you want to see all of the key-value pairs in a map, the easiest way is to
|
<p>If you want to see all of the key-value pairs in a map, the easiest way is to
|
||||||
iterate over the keys and use each to look up its value:</p>
|
iterate over the keys and use each to look up its value:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">stateBirds</span> <span class="o">=</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">birds</span> <span class="o">=</span> <span class="p">{</span>
|
||||||
<span class="s2">"Arizona"</span><span class="o">:</span> <span class="s2">"Cactus wren"</span><span class="p">,</span>
|
<span class="s">"Arizona"</span><span class="o">:</span> <span class="s">"Cactus wren"</span><span class="p">,</span>
|
||||||
<span class="s2">"Hawaii"</span><span class="o">:</span> <span class="s2">"Nēnē"</span><span class="p">,</span>
|
<span class="s">"Hawaii"</span><span class="o">:</span> <span class="s">"Nēnē"</span><span class="p">,</span>
|
||||||
<span class="s2">"Ohio"</span><span class="o">:</span> <span class="s2">"Northern Cardinal"</span>
|
<span class="s">"Ohio"</span><span class="o">:</span> <span class="s">"Northern Cardinal"</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="k">for</span> <span class="p">(</span><span class="n">state</span> <span class="k">in</span> <span class="n">stateBirds</span><span class="p">.</span><span class="n">keys</span><span class="p">)</span> <span class="p">{</span>
|
<span class="k">for</span> <span class="p">(</span><span class="n">state</span> <span class="k">in</span> <span class="n">birds</span><span class="o">.</span><span class="n">keys</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"The state bird of "</span><span class="p">,</span> <span class="n">state</span><span class="p">,</span> <span class="s2">" is "</span><span class="p">,</span> <span class="n">stateBirds</span><span class="p">[</span><span class="n">state</span><span class="p">])</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"The state bird of "</span> <span class="o">+</span> <span class="n">state</span> <span class="o">+</span> <span class="s">" is "</span> <span class="o">+</span> <span class="n">birds</span><span class="p">[</span><span class="n">state</span><span class="p">])</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|||||||
74
modules.html
74
modules.html
@ -83,7 +83,7 @@ a name collision. Each module is, well, modular.</p>
|
|||||||
<p>When you run Wren and give it a file name to execute, the contents of that file
|
<p>When you run Wren and give it a file name to execute, the contents of that file
|
||||||
define the "main" module that execution starts at. To load and execute other
|
define the "main" module that execution starts at. To load and execute other
|
||||||
modules, you use an import statement:</p>
|
modules, you use an import statement:</p>
|
||||||
<div class="codehilite"><pre><span class="k">import</span> <span class="s2">"beverages"</span> <span class="n">for</span> <span class="n">Coffee</span><span class="p">,</span> <span class="n">Tea</span>
|
<div class="codehilite"><pre><span class="k">import</span> <span class="s">"beverages"</span> <span class="k">for</span> <span class="vg">Coffee</span><span class="p">,</span> <span class="vg">Tea</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -93,14 +93,14 @@ creates new variables in <em>this</em> module with their values.</p>
|
|||||||
<p>This statement can appear anywhere a variable declaration is allowed, even
|
<p>This statement can appear anywhere a variable declaration is allowed, even
|
||||||
inside blocks:</p>
|
inside blocks:</p>
|
||||||
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">thirsty</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">thirsty</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="k">import</span> <span class="s2">"beverages"</span> <span class="n">for</span> <span class="n">Coffee</span><span class="p">,</span> <span class="n">Tea</span>
|
<span class="k">import</span> <span class="s">"beverages"</span> <span class="k">for</span> <span class="vg">Coffee</span><span class="p">,</span> <span class="vg">Tea</span>
|
||||||
<span class="err">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>If you want to load a module, but not bind any variables from it, you can omit
|
<p>If you want to load a module, but not bind any variables from it, you can omit
|
||||||
the <code>for</code> clause:</p>
|
the <code>for</code> clause:</p>
|
||||||
<div class="codehilite"><pre><span class="k">import</span> <span class="s2">"some_imperative_code"</span>
|
<div class="codehilite"><pre><span class="k">import</span> <span class="s">"some_imperative_code"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -149,7 +149,7 @@ the main module was loaded and looks for that file. So, let's say you run:</p>
|
|||||||
|
|
||||||
|
|
||||||
<p>And that main module has:</p>
|
<p>And that main module has:</p>
|
||||||
<div class="codehilite"><pre><span class="k">import</span> <span class="s2">"some/module"</span>
|
<div class="codehilite"><pre><span class="k">import</span> <span class="s">"some/module"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -179,7 +179,7 @@ These are simply variables declared outside of any
|
|||||||
<a href="classes.html#methods">method</a> or <a href="functions.html">function</a>.</p>
|
<a href="classes.html#methods">method</a> or <a href="functions.html">function</a>.</p>
|
||||||
<p>These are visible to anything inside the module, but they can also be
|
<p>These are visible to anything inside the module, but they can also be
|
||||||
<em>exported</em> and used by other modules. When Wren executes an import like:</p>
|
<em>exported</em> and used by other modules. When Wren executes an import like:</p>
|
||||||
<div class="codehilite"><pre><span class="k">import</span> <span class="s2">"beverages"</span> <span class="n">for</span> <span class="n">Coffee</span><span class="p">,</span> <span class="n">Tea</span>
|
<div class="codehilite"><pre><span class="k">import</span> <span class="s">"beverages"</span> <span class="k">for</span> <span class="vg">Coffee</span><span class="p">,</span> <span class="vg">Tea</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -200,17 +200,17 @@ rarely makes a difference.</p>
|
|||||||
a <em>tree</em> of modules if there are no <em>shared imports</em>. But consider a program
|
a <em>tree</em> of modules if there are no <em>shared imports</em>. But consider a program
|
||||||
like:</p>
|
like:</p>
|
||||||
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
||||||
<span class="k">import</span> <span class="s2">"a"</span>
|
<span class="k">import</span> <span class="s">"a"</span>
|
||||||
<span class="n">import</span> <span class="s2">"b"</span>
|
<span class="k">import</span> <span class="s">"b"</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">a</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// a.wren</span>
|
||||||
<span class="n">import</span> <span class="s2">"shared"</span>
|
<span class="k">import</span> <span class="s">"shared"</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">b</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// b.wren</span>
|
||||||
<span class="n">import</span> <span class="s2">"shared"</span>
|
<span class="k">import</span> <span class="s">"shared"</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">shared</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// shared.wren</span>
|
||||||
<span class="n">IO</span><span class="err">.</span><span class="n">print</span><span class="err">(</span><span class="s2">"Shared!"</span><span class="err">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"Shared!"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -240,17 +240,17 @@ module is reached while the module itself or one of its imports is executing,
|
|||||||
it will be found in the registry and the cycle is short-circuited.</p>
|
it will be found in the registry and the cycle is short-circuited.</p>
|
||||||
<p>For example:</p>
|
<p>For example:</p>
|
||||||
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
||||||
<span class="k">import</span> <span class="s2">"a"</span>
|
<span class="k">import</span> <span class="s">"a"</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">a</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// a.wren</span>
|
||||||
<span class="n">IO</span><span class="err">.</span><span class="n">print</span><span class="err">(</span><span class="s2">"start a"</span><span class="err">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"start a"</span><span class="p">)</span>
|
||||||
<span class="n">import</span> <span class="s2">"b"</span>
|
<span class="k">import</span> <span class="s">"b"</span>
|
||||||
<span class="n">IO</span><span class="err">.</span><span class="n">print</span><span class="err">(</span><span class="s2">"end a"</span><span class="err">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"end a"</span><span class="p">)</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">b</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// b.wren</span>
|
||||||
<span class="n">IO</span><span class="err">.</span><span class="n">print</span><span class="err">(</span><span class="s2">"start b"</span><span class="err">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"start b"</span><span class="p">)</span>
|
||||||
<span class="n">import</span> <span class="s2">"a"</span>
|
<span class="k">import</span> <span class="s">"a"</span>
|
||||||
<span class="n">IO</span><span class="err">.</span><span class="n">print</span><span class="err">(</span><span class="s2">"end b"</span><span class="err">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"end b"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -264,15 +264,15 @@ end a
|
|||||||
|
|
||||||
<p>Where you have to be careful is binding variables. Consider:</p>
|
<p>Where you have to be careful is binding variables. Consider:</p>
|
||||||
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
||||||
<span class="k">import</span> <span class="s2">"a"</span>
|
<span class="k">import</span> <span class="s">"a"</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">a</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// a.wren</span>
|
||||||
<span class="n">import</span> <span class="s2">"b"</span> <span class="n">for</span> <span class="n">B</span>
|
<span class="k">import</span> <span class="s">"b"</span> <span class="k">for</span> <span class="err">B</span>
|
||||||
<span class="n">var</span> <span class="n">A</span> <span class="err">=</span> <span class="s2">"a variable"</span>
|
<span class="k">var</span> <span class="err">A</span> <span class="o">=</span> <span class="s">"a variable"</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">b</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// b.wren</span>
|
||||||
<span class="n">import</span> <span class="s2">"a"</span> <span class="n">for</span> <span class="n">A</span>
|
<span class="k">import</span> <span class="s">"a"</span> <span class="k">for</span> <span class="err">A</span>
|
||||||
<span class="n">var</span> <span class="n">B</span> <span class="err">=</span> <span class="s2">"b variable"</span>
|
<span class="k">var</span> <span class="err">B</span> <span class="o">=</span> <span class="s">"b variable"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -289,15 +289,15 @@ defined yet since "a.wren" is still sitting on the <code>import "b" for B</code>
|
|||||||
before the declaration. To get this to work, you would need to move the
|
before the declaration. To get this to work, you would need to move the
|
||||||
variable declaration above the import:</p>
|
variable declaration above the import:</p>
|
||||||
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
<div class="codehilite"><pre><span class="c1">// main.wren</span>
|
||||||
<span class="k">import</span> <span class="s2">"a"</span>
|
<span class="k">import</span> <span class="s">"a"</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">a</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// a.wren</span>
|
||||||
<span class="n">var</span> <span class="n">A</span> <span class="err">=</span> <span class="s2">"a variable"</span>
|
<span class="k">var</span> <span class="err">A</span> <span class="o">=</span> <span class="s">"a variable"</span>
|
||||||
<span class="n">import</span> <span class="s2">"b"</span> <span class="n">for</span> <span class="n">B</span>
|
<span class="k">import</span> <span class="s">"b"</span> <span class="k">for</span> <span class="err">B</span>
|
||||||
|
|
||||||
<span class="err">//</span> <span class="n">b</span><span class="err">.</span><span class="n">wren</span>
|
<span class="c1">// b.wren</span>
|
||||||
<span class="n">import</span> <span class="s2">"a"</span> <span class="n">for</span> <span class="n">A</span>
|
<span class="k">import</span> <span class="s">"a"</span> <span class="k">for</span> <span class="err">A</span>
|
||||||
<span class="n">var</span> <span class="n">B</span> <span class="err">=</span> <span class="s2">"b variable"</span>
|
<span class="k">var</span> <span class="err">B</span> <span class="o">=</span> <span class="s">"b variable"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
10
qa.html
10
qa.html
@ -102,14 +102,14 @@ prototypes) that classes are more usable.</p>
|
|||||||
|
|
||||||
|
|
||||||
<p>Here's the same example in Wren:</p>
|
<p>Here's the same example in Wren:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">class</span> <span class="nc">Account</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">class</span> <span class="vg">Account</span> <span class="p">{</span>
|
||||||
<span class="k">this</span> <span class="k">new</span><span class="p">(</span><span class="n">balance</span><span class="p">)</span> <span class="p">{</span> <span class="n">_balance</span> <span class="o">=</span> <span class="n">balance</span> <span class="p">}</span>
|
<span class="nb">this</span> <span class="n">new</span><span class="p">(</span><span class="n">balance</span><span class="p">)</span> <span class="p">{</span> <span class="vi">_balance</span> <span class="o">=</span> <span class="n">balance</span> <span class="p">}</span>
|
||||||
<span class="n">withdraw</span><span class="p">(</span><span class="n">amount</span><span class="p">)</span> <span class="p">{</span> <span class="n">_balance</span> <span class="o">=</span> <span class="n">_balance</span> <span class="o">-</span> <span class="n">amount</span> <span class="p">}</span>
|
<span class="n">withdraw</span><span class="p">(</span><span class="n">amount</span><span class="p">)</span> <span class="p">{</span> <span class="vi">_balance</span> <span class="o">=</span> <span class="vi">_balance</span> <span class="o">-</span> <span class="n">amount</span> <span class="p">}</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
|
|
||||||
<span class="c1">// create and use an Account</span>
|
<span class="c1">// create and use an Account</span>
|
||||||
<span class="kd">var</span> <span class="n">acc</span> <span class="o">=</span> <span class="n">Account</span><span class="p">.</span><span class="k">new</span><span class="p">(</span><span class="m">1000</span><span class="p">)</span>
|
<span class="k">var</span> <span class="n">acc</span> <span class="o">=</span> <span class="vg">Account</span><span class="o">.</span><span class="n">new</span><span class="p">(</span><span class="mi">1000</span><span class="p">)</span>
|
||||||
<span class="n">acc</span><span class="p">.</span><span class="n">withdraw</span><span class="p">(</span><span class="m">100</span><span class="p">)</span>
|
<span class="n">acc</span><span class="o">.</span><span class="n">withdraw</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
20
style.css
20
style.css
@ -149,14 +149,24 @@ footer {
|
|||||||
|
|
||||||
.codehilite pre span.c1, .codehilite pre span.cm {
|
.codehilite pre span.c1, .codehilite pre span.cm {
|
||||||
color: #95a1ae; }
|
color: #95a1ae; }
|
||||||
.codehilite pre span.k, .codehilite pre span.kd, .codehilite pre span.kc {
|
.codehilite pre span.k, .codehilite pre span.kd, .codehilite pre span.kc, .codehilite pre span.nb {
|
||||||
color: #4799eb; }
|
color: #3399cc; }
|
||||||
.codehilite pre span.m, .codehilite pre span.mi {
|
.codehilite pre span.vg {
|
||||||
|
color: #1b9898; }
|
||||||
|
.codehilite pre span.vi {
|
||||||
color: #59a112; }
|
color: #59a112; }
|
||||||
|
.codehilite pre span.vc {
|
||||||
|
color: #29a33d; }
|
||||||
|
.codehilite pre span.m, .codehilite pre span.mi, .codehilite pre span.mf {
|
||||||
|
color: #cf7317; }
|
||||||
.codehilite pre span.s, .codehilite pre span.s2 {
|
.codehilite pre span.s, .codehilite pre span.s2 {
|
||||||
color: #e6a21a; }
|
color: #cf9117; }
|
||||||
.codehilite pre span.se {
|
.codehilite pre span.se {
|
||||||
color: #e6801a; }
|
color: #e6b31a; }
|
||||||
|
.codehilite pre span.o {
|
||||||
|
color: #4d91b3; }
|
||||||
|
.codehilite pre span.p {
|
||||||
|
color: #738494; }
|
||||||
.codehilite pre span.cp {
|
.codehilite pre span.cp {
|
||||||
color: #9970c2; }
|
color: #9970c2; }
|
||||||
|
|
||||||
|
|||||||
@ -1,6 +1,6 @@
|
|||||||
{
|
{
|
||||||
"version": 3,
|
"version": 3,
|
||||||
"mappings": "AA+BA,CAAE;EACA,eAAe,EAAE,UAAU;EAC3B,UAAU,EAAE,UAAU;;AAGxB,8BAA+B;EAC7B,MAAM,EAAE,CAAC;EACT,OAAO,EAAE,CAAC;;AAGZ,IAAK;EACH,UAAU,EAnCJ,KAAgB;EAoCtB,KAAK,EA3BA,OAAsB;EA4B3B,IAAI,EAAE,2CAAe;;AAGvB,KAAM;EACJ,MAAM,EAAE,MAAM;EACd,KAAK,EAAE,KAAK;EAGZ,WAAQ;IACN,OAAO,EAAE,EAAE;IACX,OAAO,EAAE,KAAK;IACd,KAAK,EAAE,IAAI;;AAIf,kBAAa;EACX,QAAQ,EAAE,QAAQ;EAClB,KAAK,EAAE,KAAK;;AAGd,MAAO;EACL,WAAW,EAAE,iBAAiB;EAM9B,UAAU,EAlEL,OAAkB;EAmEvB,aAAa,EAAE,iBAAiB;EALhC,YAAM;IACJ,MAAM,EAAE,KAAK;EAMf,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,IAAI;IACT,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,gDAAgB;IACtB,cAAc,EAAE,GAAG;EAGrB,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,KAAK,EAAE,CAAC;IACR,GAAG,EAAE,IAAI;IACT,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,6CAAmB;IACzB,cAAc,EAAE,SAAS;IACzB,cAAc,EAAE,GAAG;IACnB,KAAK,EA/EC,OAAuB;EAkF/B,QAAE;IACA,KAAK,EAtFC,OAAuB;EAyF/B,cAAQ;IACN,KAAK,EA7EK,OAAmB;IA8E7B,WAAW,EAAE,8BAAkB;;AAInC,GAAI;EACF,KAAK,EAAE,KAAK;EACZ,KAAK,EAAE,KAAK;EACZ,WAAW,EAAE,KAAK;EAElB,MAAG;IACD,KAAK,EApGC,OAAuB;IAqG7B,IAAI,EAAE,6CAAmB;IACzB,cAAc,EAAE,SAAS;IACzB,cAAc,EAAE,GAAG;IACnB,MAAM,EAAE,CAAC;EAGX,MAAG;IACD,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,YAAY;EAGtB,MAAG;IACD,IAAI,EAAE,sCAAU;IAChB,KAAK,EAlHC,OAAuB;IAmH7B,eAAe,EAAE,IAAI;IACrB,MAAM,EAAE,SAAS;;AAIrB,EAAG;EACD,WAAW,EAAE,IAAI;EACjB,IAAI,EAAE,qDAAqB;EAC3B,KAAK,EAhHO,OAAkB;;AAmHhC,EAAG;EACD,IAAI,EAAE,gDAAgB;EACtB,MAAM,EAAE,UAAU;EAClB,KAAK,EAtHO,OAAkB;;AAyHhC,EAAG;EACD,IAAI,EAAE,sCAAU;EAChB,MAAM,EAAE,UAAU;EAClB,KAAK,EA5HO,OAAkB;;AA+HhC,CAAE;EACA,KAAK,EAhIO,OAAkB;EAiI9B,eAAe,EAAE,IAAI;EACrB,UAAU,EAAE,4BAA4B;EACxC,OAAO,EAAE,IAAI;;AAGf,IAAK;EAEH,WAAW,EAAE,IAAI;EACjB,KAAK,EAAC,IAAI;;AAGZ,OAAQ;EACN,KAAK,EA3IO,OAAkB;;AA8IhC,cAAe;EACb,KAAK,EA/JC,KAAgB;;AAkKxB;yBAC0B;EACxB,KAAK,EAnKG,OAAuB;;AAsKjC;+BACgC;EAC9B,KAAK,EAzJO,OAAkB;;AA4JhC,KAAM;EACJ,MAAM,EAAE,MAAM;;AAGhB,KAAM;EACJ,UAAU,EAAE,IAAI;;AAGlB,SAAU;EACR,KAAK,EA1KM,OAAkB;EA2K7B,IAAI,EAAE,0DAAU;EAChB,UAAU,EA3KC,OAAkB;EA4K7B,aAAa,EAAE,GAAG;EAClB,MAAM,EAAE,iBAA4B;EACpC,aAAa,EAAE,iBAA4B;;AAG7C,IAAK;EACH,OAAO,EAAE,OAAO;EAChB,WAAW,EAAE,MAAM;;AAGrB,GAAI;EACF,MAAM,EAAE,MAAM;EACd,WAAW,EAAE,IAAI;EACjB,OAAO,EAAE,IAAI;EAGb,QAAQ,EAAE,IAAI;;AAGhB,MAAO;EACL,UAAU,EAAE,IAAI;EAChB,OAAO,EAAE,aAAa;EACtB,IAAI,EAAE,sCAAU;EAChB,UAAU,EAjNL,OAAkB;EAkNvB,KAAK,EA9MG,OAAuB;EA+M/B,UAAU,EAAE,iBAAiB;EAC7B,UAAU,EAAE,MAAM;EAElB,WAAW,EAAE,iBAAiB;EAE9B,QAAE;IACA,KAAK,EAxMK,OAAmB;EA2M/B,cAAQ;IACN,KAAK,EA7MK,OAAkB;;AAoN9B,gDAAiB;EAAE,KAAK,EAAE,OAA+B;AAGzD,wEAA0B;EAAE,KAAK,EAAE,OAAkB;AAGrD,+CAAgB;EAAE,KAAK,EAAE,OAAiB;AAG1C,+CAAiB;EAAE,KAAK,EAAE,OAAiB;AAC3C,uBAAiB;EAAE,KAAK,EAAE,OAAiB;AAG3C,uBAAiB;EAAE,KAAK,EAAE,OAAkB;;AAM1C,kBAAE;EACA,KAAK,EApPD,OAAuB;AAuP7B,wBAAQ;EACN,KAAK,EAtOQ,OAAkB;EAuO/B,WAAW,EAAE,8BAAuB;AAIxC,WAAE;EACA,KAAK,EA7OU,OAAkB;AAgPnC,iBAAQ;EACN,KAAK,EA/OU,OAAkB;AAkPnC,wBAAe;EACb,KAAK,EAxQD,KAAgB;AA4QpB,uDAAW;EACT,KAAK,EA1PQ,OAAkB;AA6PjC;8CACgC;EAC9B,KAAK,EA7PQ,OAAkB;AAkQjC,kBAAE;EACA,KAAK,EApQQ,OAAkB;AAuQjC,wBAAQ;EACN,KAAK,EAzQQ,OAAkB;;AA8QrC,KAAM;EACJ,KAAK,EAAE,IAAI;EACX,eAAe,EAAE,QAAQ;EAEzB,QAAG;IACD,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,CAAC;IACV,cAAc,EAAE,GAAG;EAGrB,kBAAO;IACL,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,IAAI;;AAKpB,WAAY;EACV,OAAO,EAAE,cAAc;EAEvB,8BAAO;IACL,WAAW,EAAE,IAAI;IACjB,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,CAAC;EAGZ,cAAG;IACD,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,KAAK;EAGd,sBAAW;IACT,OAAO,EAAE,YAAY;IACrB,IAAI,EAAE,sCAAU;IAChB,KAAK,EApUD,KAAgB;IAqUpB,UAAU,EAvTA,OAAkB;IAwT5B,aAAa,EAAE,iBAAoB;IACnC,UAAU,EAAE,KAAK;IACjB,aAAa,EAAE,GAAG;EAGpB,2BAAgB;IACd,UAAU,EAAE,OAA2B;IACvC,aAAa,EAAE,iBAAoB;;AAMrC,mBAAG;EACD,IAAI,EAAE,6CAAmB;EACzB,cAAc,EAAE,SAAS;EACzB,cAAc,EAAE,GAAG;EACnB,KAAK,EAjVC,OAAuB;EAmV7B,OAAO,EAAE,KAAK;EACd,aAAa,EAAE,iBAAkB;AAGnC,mBAAG;EACD,OAAO,EAAE,KAAK;EACd,aAAa,EAAE,iBAAkB;;AAIrC,yCAA0C;EAExC,KAAM;IAAE,KAAK,EAAE,KAAK;;EACpB,GAAI;IAAE,KAAK,EAAE,KAAK;;EAClB,kBAAa;IAAE,KAAK,EAAE,KAAK;AAG7B,yCAA0C;EAExC,KAAM;IAAE,KAAK,EAAE,KAAK;;EACpB,GAAI;IAAE,KAAK,EAAE,KAAK;;EAClB,kBAAa;IAAE,KAAK,EAAE,KAAK;AAG7B,yCAA0C;EAExC,KAAM;IAAE,KAAK,EAAE,KAAK;;EACpB,GAAI;IAAE,KAAK,EAAE,KAAK;;EAClB,kBAAa;IAAE,KAAK,EAAE,KAAK;;EAE3B,SAAU;IACR,SAAS,EAAE,IAAI;IACf,cAAc,EAAE,GAAG;AAIvB,yCAA0C;EACxC,KAAM;IAAE,KAAK,EAAE,IAAI;;EAEnB,GAAI;IACF,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;IACX,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,CAAC;IACT,UAAU,EApYJ,OAAuB;IAqY7B,UAAU,EAAE,MAAM;IAElB,WAAQ;MACN,OAAO,EAAE,YAAY;MACrB,cAAc,EAAE,GAAG;MACnB,UAAU,EAAE,IAAI;MAChB,KAAK,EAAE,GAAG;;EAId,kBAAa;IACX,OAAO,EAAE,MAAM;IACf,KAAK,EAAE,IAAI;;EAIX,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,CAAC;IACP,UAAU,EAAE,MAAM;EAGpB,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,GAAG,EAAE,CAAC;IACN,KAAK,EAAE,CAAC;IACR,UAAU,EAAE,MAAM;IAClB,SAAS,EAAE,IAAI;IACf,cAAc,EAAE,GAAG;;EAIvB,IAAK;IACH,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;;EAGb,GAAI;IACF,SAAS,EAAE,IAAI;;EAGjB,MAAO;IACL,OAAO,EAAE,mBAAmB",
|
"mappings": "AA+BA,CAAE;EACA,eAAe,EAAE,UAAU;EAC3B,UAAU,EAAE,UAAU;;AAGxB,8BAA+B;EAC7B,MAAM,EAAE,CAAC;EACT,OAAO,EAAE,CAAC;;AAGZ,IAAK;EACH,UAAU,EAnCJ,KAAgB;EAoCtB,KAAK,EA3BA,OAAsB;EA4B3B,IAAI,EAAE,2CAAe;;AAGvB,KAAM;EACJ,MAAM,EAAE,MAAM;EACd,KAAK,EAAE,KAAK;EAGZ,WAAQ;IACN,OAAO,EAAE,EAAE;IACX,OAAO,EAAE,KAAK;IACd,KAAK,EAAE,IAAI;;AAIf,kBAAa;EACX,QAAQ,EAAE,QAAQ;EAClB,KAAK,EAAE,KAAK;;AAGd,MAAO;EACL,WAAW,EAAE,iBAAiB;EAM9B,UAAU,EAlEL,OAAkB;EAmEvB,aAAa,EAAE,iBAAiB;EALhC,YAAM;IACJ,MAAM,EAAE,KAAK;EAMf,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,IAAI,EAAE,CAAC;IACP,GAAG,EAAE,IAAI;IACT,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,gDAAgB;IACtB,cAAc,EAAE,GAAG;EAGrB,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,KAAK,EAAE,CAAC;IACR,GAAG,EAAE,IAAI;IACT,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,6CAAmB;IACzB,cAAc,EAAE,SAAS;IACzB,cAAc,EAAE,GAAG;IACnB,KAAK,EA/EC,OAAuB;EAkF/B,QAAE;IACA,KAAK,EAtFC,OAAuB;EAyF/B,cAAQ;IACN,KAAK,EA7EK,OAAmB;IA8E7B,WAAW,EAAE,8BAAkB;;AAInC,GAAI;EACF,KAAK,EAAE,KAAK;EACZ,KAAK,EAAE,KAAK;EACZ,WAAW,EAAE,KAAK;EAElB,MAAG;IACD,KAAK,EApGC,OAAuB;IAqG7B,IAAI,EAAE,6CAAmB;IACzB,cAAc,EAAE,SAAS;IACzB,cAAc,EAAE,GAAG;IACnB,MAAM,EAAE,CAAC;EAGX,MAAG;IACD,OAAO,EAAE,CAAC;IACV,MAAM,EAAE,YAAY;EAGtB,MAAG;IACD,IAAI,EAAE,sCAAU;IAChB,KAAK,EAlHC,OAAuB;IAmH7B,eAAe,EAAE,IAAI;IACrB,MAAM,EAAE,SAAS;;AAIrB,EAAG;EACD,WAAW,EAAE,IAAI;EACjB,IAAI,EAAE,qDAAqB;EAC3B,KAAK,EAhHO,OAAkB;;AAmHhC,EAAG;EACD,IAAI,EAAE,gDAAgB;EACtB,MAAM,EAAE,UAAU;EAClB,KAAK,EAtHO,OAAkB;;AAyHhC,EAAG;EACD,IAAI,EAAE,sCAAU;EAChB,MAAM,EAAE,UAAU;EAClB,KAAK,EA5HO,OAAkB;;AA+HhC,CAAE;EACA,KAAK,EAhIO,OAAkB;EAiI9B,eAAe,EAAE,IAAI;EACrB,UAAU,EAAE,4BAA4B;EACxC,OAAO,EAAE,IAAI;;AAGf,IAAK;EAEH,WAAW,EAAE,IAAI;EACjB,KAAK,EAAC,IAAI;;AAGZ,OAAQ;EACN,KAAK,EA3IO,OAAkB;;AA8IhC,cAAe;EACb,KAAK,EA/JC,KAAgB;;AAkKxB;yBAC0B;EACxB,KAAK,EAnKG,OAAuB;;AAsKjC;+BACgC;EAC9B,KAAK,EAzJO,OAAkB;;AA4JhC,KAAM;EACJ,MAAM,EAAE,MAAM;;AAGhB,KAAM;EACJ,UAAU,EAAE,IAAI;;AAGlB,SAAU;EACR,KAAK,EA1KM,OAAkB;EA2K7B,IAAI,EAAE,0DAAU;EAChB,UAAU,EA3KC,OAAkB;EA4K7B,aAAa,EAAE,GAAG;EAClB,MAAM,EAAE,iBAA4B;EACpC,aAAa,EAAE,iBAA4B;;AAG7C,IAAK;EACH,OAAO,EAAE,OAAO;EAChB,WAAW,EAAE,MAAM;;AAGrB,GAAI;EACF,MAAM,EAAE,MAAM;EACd,WAAW,EAAE,IAAI;EACjB,OAAO,EAAE,IAAI;EAGb,QAAQ,EAAE,IAAI;;AAGhB,MAAO;EACL,UAAU,EAAE,IAAI;EAChB,OAAO,EAAE,aAAa;EACtB,IAAI,EAAE,sCAAU;EAChB,UAAU,EAjNL,OAAkB;EAkNvB,KAAK,EA9MG,OAAuB;EA+M/B,UAAU,EAAE,iBAAiB;EAC7B,UAAU,EAAE,MAAM;EAElB,WAAW,EAAE,iBAAiB;EAE9B,QAAE;IACA,KAAK,EAxMK,OAAmB;EA2M/B,cAAQ;IACN,KAAK,EA7MK,OAAkB;;AAuN9B,gDAAiB;EAAE,KAAK,EAAE,OAA+B;AAGzD,iGAAmC;EAAE,KAAK,EAAE,OAAkB;AAG9D,uBAAQ;EAAE,KAAK,EAAE,OAAkB;AACnC,uBAAQ;EAAE,KAAK,EAAE,OAAiB;AAClC,uBAAQ;EAAE,KAAK,EAAE,OAAkB;AAGnC,wEAAyB;EAAE,KAAK,EAAE,OAAiB;AAGnD,+CAAiB;EAAE,KAAK,EAAE,OAAiB;AAC3C,uBAAiB;EAAE,KAAK,EAAE,OAAiB;AAG3C,sBAAiB;EAAE,KAAK,EAAE,OAAkB;AAC5C,sBAAiB;EAAE,KAAK,EAAE,OAA+B;AAGzD,uBAAiB;EAAE,KAAK,EAAE,OAAkB;;AAM1C,kBAAE;EACA,KAAK,EAhQD,OAAuB;AAmQ7B,wBAAQ;EACN,KAAK,EAlPQ,OAAkB;EAmP/B,WAAW,EAAE,8BAAuB;AAIxC,WAAE;EACA,KAAK,EAzPU,OAAkB;AA4PnC,iBAAQ;EACN,KAAK,EA3PU,OAAkB;AA8PnC,wBAAe;EACb,KAAK,EApRD,KAAgB;AAwRpB,uDAAW;EACT,KAAK,EAtQQ,OAAkB;AAyQjC;8CACgC;EAC9B,KAAK,EAzQQ,OAAkB;AA8QjC,kBAAE;EACA,KAAK,EAhRQ,OAAkB;AAmRjC,wBAAQ;EACN,KAAK,EArRQ,OAAkB;;AA0RrC,KAAM;EACJ,KAAK,EAAE,IAAI;EACX,eAAe,EAAE,QAAQ;EAEzB,QAAG;IACD,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,CAAC;IACV,cAAc,EAAE,GAAG;EAGrB,kBAAO;IACL,SAAS,EAAE,IAAI;IACf,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,IAAI;;AAKpB,WAAY;EACV,OAAO,EAAE,cAAc;EAEvB,8BAAO;IACL,WAAW,EAAE,IAAI;IACjB,MAAM,EAAE,CAAC;IACT,OAAO,EAAE,CAAC;EAGZ,cAAG;IACD,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,KAAK;EAGd,sBAAW;IACT,OAAO,EAAE,YAAY;IACrB,IAAI,EAAE,sCAAU;IAChB,KAAK,EAhVD,KAAgB;IAiVpB,UAAU,EAnUA,OAAkB;IAoU5B,aAAa,EAAE,iBAAoB;IACnC,UAAU,EAAE,KAAK;IACjB,aAAa,EAAE,GAAG;EAGpB,2BAAgB;IACd,UAAU,EAAE,OAA2B;IACvC,aAAa,EAAE,iBAAoB;;AAMrC,mBAAG;EACD,IAAI,EAAE,6CAAmB;EACzB,cAAc,EAAE,SAAS;EACzB,cAAc,EAAE,GAAG;EACnB,KAAK,EA7VC,OAAuB;EA+V7B,OAAO,EAAE,KAAK;EACd,aAAa,EAAE,iBAAkB;AAGnC,mBAAG;EACD,OAAO,EAAE,KAAK;EACd,aAAa,EAAE,iBAAkB;;AAIrC,yCAA0C;EAExC,KAAM;IAAE,KAAK,EAAE,KAAK;;EACpB,GAAI;IAAE,KAAK,EAAE,KAAK;;EAClB,kBAAa;IAAE,KAAK,EAAE,KAAK;AAG7B,yCAA0C;EAExC,KAAM;IAAE,KAAK,EAAE,KAAK;;EACpB,GAAI;IAAE,KAAK,EAAE,KAAK;;EAClB,kBAAa;IAAE,KAAK,EAAE,KAAK;AAG7B,yCAA0C;EAExC,KAAM;IAAE,KAAK,EAAE,KAAK;;EACpB,GAAI;IAAE,KAAK,EAAE,KAAK;;EAClB,kBAAa;IAAE,KAAK,EAAE,KAAK;;EAE3B,SAAU;IACR,SAAS,EAAE,IAAI;IACf,cAAc,EAAE,GAAG;AAIvB,yCAA0C;EACxC,KAAM;IAAE,KAAK,EAAE,IAAI;;EAEnB,GAAI;IACF,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;IACX,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,CAAC;IACT,UAAU,EAhZJ,OAAuB;IAiZ7B,UAAU,EAAE,MAAM;IAElB,WAAQ;MACN,OAAO,EAAE,YAAY;MACrB,cAAc,EAAE,GAAG;MACnB,UAAU,EAAE,IAAI;MAChB,KAAK,EAAE,GAAG;;EAId,kBAAa;IACX,OAAO,EAAE,MAAM;IACf,KAAK,EAAE,IAAI;;EAIX,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,GAAG,EAAE,IAAI;IACT,IAAI,EAAE,CAAC;IACP,UAAU,EAAE,MAAM;EAGpB,SAAG;IACD,QAAQ,EAAE,QAAQ;IAClB,GAAG,EAAE,CAAC;IACN,KAAK,EAAE,CAAC;IACR,UAAU,EAAE,MAAM;IAClB,SAAS,EAAE,IAAI;IACf,cAAc,EAAE,GAAG;;EAIvB,IAAK;IACH,KAAK,EAAE,IAAI;IACX,KAAK,EAAE,IAAI;;EAGb,GAAI;IACF,SAAS,EAAE,IAAI;;EAGjB,MAAO;IACL,OAAO,EAAE,mBAAmB",
|
||||||
"sources": ["../../doc/site/style.scss"],
|
"sources": ["../../doc/site/style.scss"],
|
||||||
"names": [],
|
"names": [],
|
||||||
"file": "style.css"
|
"file": "style.css"
|
||||||
|
|||||||
34
syntax.html
34
syntax.html
@ -73,15 +73,15 @@ bytecode for efficiency, but that's an implementation detail.)</p>
|
|||||||
|
|
||||||
<p>Block comments start with <code>/*</code> and end with <code>*/</code>. They can span multiple lines
|
<p>Block comments start with <code>/*</code> and end with <code>*/</code>. They can span multiple lines
|
||||||
or be within a single one. Unlike C, block comments can nest in Wren:</p>
|
or be within a single one. Unlike C, block comments can nest in Wren:</p>
|
||||||
<div class="codehilite"><pre><span class="cm">/* This is /* a nested */</span> <span class="n">comment</span><span class="p">.</span> <span class="o">*/</span>
|
<div class="codehilite"><pre><span class="cm">/* This is /* a nested */ comment. */</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h2>Reserved words <a href="#reserved-words" name="reserved-words" class="header-anchor">#</a></h2>
|
<h2>Reserved words <a href="#reserved-words" name="reserved-words" class="header-anchor">#</a></h2>
|
||||||
<p>Some people like to see all of the reserved words in a programming language in
|
<p>Some people like to see all of the reserved words in a programming language in
|
||||||
one lump. If you're one of those folks, here you go:</p>
|
one lump. If you're one of those folks, here you go:</p>
|
||||||
<div class="codehilite"><pre><span class="k">break</span> <span class="kd">class</span> <span class="nc">construct</span> <span class="k">else</span> <span class="kc">false</span> <span class="k">for</span> <span class="n">foreign</span> <span class="k">if</span> <span class="k">import</span>
|
<div class="codehilite"><pre><span class="k">break</span> <span class="k">class</span> <span class="k">construct</span> <span class="k">else</span> <span class="kc">false</span> <span class="k">for</span> <span class="k">foreign</span> <span class="k">if</span> <span class="k">import</span>
|
||||||
<span class="n">in</span> <span class="n">is</span> <span class="n">null</span> <span class="n">return</span> <span class="n">static</span> <span class="n">super</span> <span class="n">this</span> <span class="n">true</span> <span class="n">var</span> <span class="n">while</span>
|
<span class="k">in</span> <span class="k">is</span> <span class="kc">null</span> <span class="k">return</span> <span class="k">static</span> <span class="k">super</span> <span class="nb">this</span> <span class="kc">true</span> <span class="k">var</span> <span class="k">while</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -91,10 +91,10 @@ a letter or underscore and may contain letters, digits, and underscores. Case
|
|||||||
is sensitive.</p>
|
is sensitive.</p>
|
||||||
<div class="codehilite"><pre><span class="n">hi</span>
|
<div class="codehilite"><pre><span class="n">hi</span>
|
||||||
<span class="n">camelCase</span>
|
<span class="n">camelCase</span>
|
||||||
<span class="n">PascalCase</span>
|
<span class="vg">PascalCase</span>
|
||||||
<span class="n">_under_score</span>
|
<span class="vi">_under_score</span>
|
||||||
<span class="n">abc123</span>
|
<span class="n">abc123</span>
|
||||||
<span class="n">ALL_CAPS</span>
|
<span class="vg">ALL_CAPS</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -103,16 +103,16 @@ to indicate <a href="classes.html#fields">fields</a> in classes.</p>
|
|||||||
<h2>Newlines <a href="#newlines" name="newlines" class="header-anchor">#</a></h2>
|
<h2>Newlines <a href="#newlines" name="newlines" class="header-anchor">#</a></h2>
|
||||||
<p>Newlines (<code>\n</code>) are meaningful in Wren. They are used to separate statements:</p>
|
<p>Newlines (<code>\n</code>) are meaningful in Wren. They are used to separate statements:</p>
|
||||||
<div class="codehilite"><pre><span class="c1">// Two statements:</span>
|
<div class="codehilite"><pre><span class="c1">// Two statements:</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"hi"</span><span class="p">)</span> <span class="c1">// Newline.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"hi"</span><span class="p">)</span> <span class="c1">// Newline.</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"bye"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"bye"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Sometimes, though, a statement doesn't fit on a single line and jamming a
|
<p>Sometimes, though, a statement doesn't fit on a single line and jamming a
|
||||||
newline in the middle would trip it up. To handle that, Wren has a very simple
|
newline in the middle would trip it up. To handle that, Wren has a very simple
|
||||||
rule: It ignores a newline following any token that can't end a statement.</p>
|
rule: It ignores a newline following any token that can't end a statement.</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span> <span class="c1">// Newline here is ignored.</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span> <span class="c1">// Newline here is ignored.</span>
|
||||||
<span class="s2">"hi"</span><span class="p">)</span>
|
<span class="s">"hi"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -125,17 +125,17 @@ statement is allowed, like in <a href="control-flow.html">control flow</a> state
|
|||||||
blocks. For example, here we have a block for the then case, and a single
|
blocks. For example, here we have a block for the then case, and a single
|
||||||
statement for the else:</p>
|
statement for the else:</p>
|
||||||
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">happy</span> <span class="o">&&</span> <span class="n">knowIt</span><span class="p">)</span> <span class="p">{</span>
|
<div class="codehilite"><pre><span class="k">if</span> <span class="p">(</span><span class="n">happy</span> <span class="o">&&</span> <span class="n">knowIt</span><span class="p">)</span> <span class="p">{</span>
|
||||||
<span class="n">hands</span><span class="p">.</span><span class="n">clap</span>
|
<span class="n">hands</span><span class="o">.</span><span class="n">clap</span>
|
||||||
<span class="p">}</span> <span class="k">else</span> <span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"sad"</span><span class="p">)</span>
|
<span class="p">}</span> <span class="k">else</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"sad"</span><span class="p">)</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Blocks have two similar but not identical forms. Typically, blocks contain a
|
<p>Blocks have two similar but not identical forms. Typically, blocks contain a
|
||||||
series of statements like:</p>
|
series of statements like:</p>
|
||||||
<div class="codehilite"><pre><span class="p">{</span>
|
<div class="codehilite"><pre><span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"one"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"one"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"two"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"two"</span><span class="p">)</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"three"</span><span class="p">)</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"three"</span><span class="p">)</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
@ -146,7 +146,7 @@ value, you need an explicit <code>return</code> statement.</p>
|
|||||||
<p>However, it's pretty common to have a method or function that just evaluates
|
<p>However, it's pretty common to have a method or function that just evaluates
|
||||||
and returns the result of a single expression. For that, Wren has a more
|
and returns the result of a single expression. For that, Wren has a more
|
||||||
compact notation:</p>
|
compact notation:</p>
|
||||||
<div class="codehilite"><pre><span class="p">{</span> <span class="s2">"single expression"</span> <span class="p">}</span>
|
<div class="codehilite"><pre><span class="p">{</span> <span class="s">"single expression"</span> <span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -155,7 +155,7 @@ compact notation:</p>
|
|||||||
expression, and it automatically returns the result of it. It's exactly the
|
expression, and it automatically returns the result of it. It's exactly the
|
||||||
same as doing:</p>
|
same as doing:</p>
|
||||||
<div class="codehilite"><pre><span class="p">{</span>
|
<div class="codehilite"><pre><span class="p">{</span>
|
||||||
<span class="k">return</span> <span class="s2">"single expression"</span>
|
<span class="k">return</span> <span class="s">"single expression"</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
</main>
|
</main>
|
||||||
|
|||||||
48
values.html
48
values.html
@ -71,12 +71,12 @@ character array modified in place.</p>
|
|||||||
<p>Like other scripting languages, Wren has a single numeric type:
|
<p>Like other scripting languages, Wren has a single numeric type:
|
||||||
double-precision floating point. Number literals look like you expect coming
|
double-precision floating point. Number literals look like you expect coming
|
||||||
from other languages:</p>
|
from other languages:</p>
|
||||||
<div class="codehilite"><pre><span class="m">0</span>
|
<div class="codehilite"><pre><span class="mi">0</span>
|
||||||
<span class="m">1234</span>
|
<span class="mi">1234</span>
|
||||||
<span class="o">-</span><span class="m">5678</span>
|
<span class="o">-</span><span class="mi">5678</span>
|
||||||
<span class="m">3.14159</span>
|
<span class="mf">3.14159</span>
|
||||||
<span class="m">1.0</span>
|
<span class="mf">1.0</span>
|
||||||
<span class="o">-</span><span class="m">12.34</span>
|
<span class="o">-</span><span class="mf">12.34</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -87,31 +87,31 @@ UTF-8, but you can put any byte values in there, even zero or invalid UTF-8
|
|||||||
sequences. (You might have some trouble <em>printing</em> the latter to your terminal,
|
sequences. (You might have some trouble <em>printing</em> the latter to your terminal,
|
||||||
though.)</p>
|
though.)</p>
|
||||||
<p>String literals are surrounded in double quotes:</p>
|
<p>String literals are surrounded in double quotes:</p>
|
||||||
<div class="codehilite"><pre><span class="s2">"hi there"</span>
|
<div class="codehilite"><pre><span class="s">"hi there"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>A handful of escape characters are supported:</p>
|
<p>A handful of escape characters are supported:</p>
|
||||||
<div class="codehilite"><pre><span class="s2">"</span><span class="err">\</span><span class="s2">0"</span> <span class="c1">// The NUL byte: 0.</span>
|
<div class="codehilite"><pre><span class="s">"</span><span class="se">\0</span><span class="s">"</span> <span class="c1">// The NUL byte: 0.</span>
|
||||||
<span class="s2">"</span><span class="se">\"</span><span class="s2">"</span> <span class="c1">// A double quote character.</span>
|
<span class="s">"</span><span class="se">\"</span><span class="s">"</span> <span class="c1">// A double quote character.</span>
|
||||||
<span class="s2">"</span><span class="se">\\</span><span class="s2">"</span> <span class="c1">// A backslash.</span>
|
<span class="s">"</span><span class="se">\\</span><span class="s">"</span> <span class="c1">// A backslash.</span>
|
||||||
<span class="s2">"</span><span class="se">\a</span><span class="s2">"</span> <span class="c1">// Alarm beep. (Who uses this?)</span>
|
<span class="s">"</span><span class="se">\a</span><span class="s">"</span> <span class="c1">// Alarm beep. (Who uses this?)</span>
|
||||||
<span class="s2">"</span><span class="se">\b</span><span class="s2">"</span> <span class="c1">// Backspace.</span>
|
<span class="s">"</span><span class="se">\b</span><span class="s">"</span> <span class="c1">// Backspace.</span>
|
||||||
<span class="s2">"</span><span class="se">\f</span><span class="s2">"</span> <span class="c1">// Formfeed.</span>
|
<span class="s">"</span><span class="se">\f</span><span class="s">"</span> <span class="c1">// Formfeed.</span>
|
||||||
<span class="s2">"</span><span class="se">\n</span><span class="s2">"</span> <span class="c1">// Newline.</span>
|
<span class="s">"</span><span class="se">\n</span><span class="s">"</span> <span class="c1">// Newline.</span>
|
||||||
<span class="s2">"</span><span class="se">\r</span><span class="s2">"</span> <span class="c1">// Carriage return.</span>
|
<span class="s">"</span><span class="se">\r</span><span class="s">"</span> <span class="c1">// Carriage return.</span>
|
||||||
<span class="s2">"</span><span class="se">\t</span><span class="s2">"</span> <span class="c1">// Tab.</span>
|
<span class="s">"</span><span class="se">\t</span><span class="s">"</span> <span class="c1">// Tab.</span>
|
||||||
<span class="s2">"</span><span class="se">\v</span><span class="s2">"</span> <span class="c1">// Vertical tab.</span>
|
<span class="s">"</span><span class="se">\v</span><span class="s">"</span> <span class="c1">// Vertical tab.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>A <code>\u</code> followed by four hex digits can be used to specify a Unicode code point:</p>
|
<p>A <code>\u</code> followed by four hex digits can be used to specify a Unicode code point:</p>
|
||||||
<div class="codehilite"><pre><span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="s2">"</span><span class="se">\u0041\u0b83\u00DE</span><span class="s2">"</span><span class="p">)</span> <span class="c1">// "AஃÞ"</span>
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"</span><span class="se">\u0041\u0b83\u00DE</span><span class="s">"</span><span class="p">)</span> <span class="c1">// "AஃÞ"</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>A <code>\x</code> followed by two hex digits specifies a single unencoded byte:</p>
|
<p>A <code>\x</code> followed by two hex digits specifies a single unencoded byte:</p>
|
||||||
<div class="codehilite"><pre>IO.print("\x48\x69\x2e") // "Hi."
|
<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="s">"</span><span class="se">\x48\x69\x2e</span><span class="s">"</span><span class="p">)</span> <span class="c1">// "Hi."</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -121,13 +121,13 @@ though.)</p>
|
|||||||
They don't have their own dedicated literal syntax. Instead, the number class
|
They don't have their own dedicated literal syntax. Instead, the number class
|
||||||
implements the <code>..</code> and <code>...</code> <a href="expressions.html#operators">operators</a> to create
|
implements the <code>..</code> and <code>...</code> <a href="expressions.html#operators">operators</a> to create
|
||||||
them:</p>
|
them:</p>
|
||||||
<div class="codehilite"><pre><span class="m">3.</span><span class="p">.</span><span class="m">8</span>
|
<div class="codehilite"><pre><span class="mi">3</span><span class="o">..</span><span class="mi">8</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>This creates a range from three to eight, including eight itself. If you want a
|
<p>This creates a range from three to eight, including eight itself. If you want a
|
||||||
half-inclusive range, use <code>...</code>:</p>
|
half-inclusive range, use <code>...</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="m">4.</span><span class="p">..</span><span class="m">6</span>
|
<div class="codehilite"><pre><span class="mi">4</span><span class="o">...</span><span class="mi">6</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -136,9 +136,9 @@ commonly used for <a href="control-flow.html#for-statements">iterating</a> over
|
|||||||
sequences of numbers, but are useful in other places too. You can pass them to
|
sequences of numbers, but are useful in other places too. You can pass them to
|
||||||
a <a href="lists.html">list</a>'s subscript operator to return a subset of the list, for
|
a <a href="lists.html">list</a>'s subscript operator to return a subset of the list, for
|
||||||
example:</p>
|
example:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"a"</span><span class="p">,</span> <span class="s2">"b"</span><span class="p">,</span> <span class="s2">"c"</span><span class="p">,</span> <span class="s2">"d"</span><span class="p">,</span> <span class="s2">"e"</span><span class="p">]</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">list</span> <span class="o">=</span> <span class="p">[</span><span class="s">"a"</span><span class="p">,</span> <span class="s">"b"</span><span class="p">,</span> <span class="s">"c"</span><span class="p">,</span> <span class="s">"d"</span><span class="p">,</span> <span class="s">"e"</span><span class="p">]</span>
|
||||||
<span class="kd">var</span> <span class="n">slice</span> <span class="o">=</span> <span class="n">list</span><span class="p">[</span><span class="m">1.</span><span class="p">.</span><span class="m">3</span><span class="p">]</span>
|
<span class="k">var</span> <span class="n">slice</span> <span class="o">=</span> <span class="n">list</span><span class="p">[</span><span class="mi">1</span><span class="o">..</span><span class="mi">3</span><span class="p">]</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">slice</span><span class="p">)</span> <span class="c1">// ["b", "c", "d"]</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">slice</span><span class="p">)</span> <span class="c1">// ["b", "c", "d"]</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@ -61,15 +61,15 @@
|
|||||||
<h1>Variables</h1>
|
<h1>Variables</h1>
|
||||||
<p>Variables are named slots for storing values. You can define a new variable in
|
<p>Variables are named slots for storing values. You can define a new variable in
|
||||||
Wren using a <code>var</code> statement, like so:</p>
|
Wren using a <code>var</code> statement, like so:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="m">1</span> <span class="o">+</span> <span class="m">2</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="mi">1</span> <span class="o">+</span> <span class="mi">2</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>This creates a new variable <code>a</code> in the current scope and initializes it with
|
<p>This creates a new variable <code>a</code> in the current scope and initializes it with
|
||||||
the result of the expression following the <code>=</code>. Once a variable has been
|
the result of the expression following the <code>=</code>. Once a variable has been
|
||||||
defined, it can be accessed by name as you would expect.</p>
|
defined, it can be accessed by name as you would expect.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">animal</span> <span class="o">=</span> <span class="s2">"Slow Loris"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="n">animal</span> <span class="o">=</span> <span class="s">"Slow Loris"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">animal</span><span class="p">)</span> <span class="c1">// Prints "Slow Loris".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">animal</span><span class="p">)</span> <span class="c1">// Prints "Slow Loris".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -77,11 +77,11 @@ defined, it can be accessed by name as you would expect.</p>
|
|||||||
<p>Wren has true block scope: a variable exists from the point where it is defined
|
<p>Wren has true block scope: a variable exists from the point where it is defined
|
||||||
until the end of the <a href="syntax.html#blocks">block</a> where that definition appears.</p>
|
until the end of the <a href="syntax.html#blocks">block</a> where that definition appears.</p>
|
||||||
<div class="codehilite"><pre><span class="p">{</span>
|
<div class="codehilite"><pre><span class="p">{</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="c1">// ERROR! a doesn't exist yet.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">a</span><span class="p">)</span> <span class="c1">// ERROR! a doesn't exist yet.</span>
|
||||||
<span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="m">123</span>
|
<span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="mi">123</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="c1">// "123"</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">a</span><span class="p">)</span> <span class="c1">// "123"</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="c1">// ERROR! a doesn't exist anymore.</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">a</span><span class="p">)</span> <span class="c1">// ERROR! a doesn't exist anymore.</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -90,25 +90,25 @@ to the <a href="modules.html">module</a> system. All other variables are <em>loc
|
|||||||
Declaring a variable in an inner scope with the same name as an outer one is
|
Declaring a variable in an inner scope with the same name as an outer one is
|
||||||
called <em>shadowing</em> and is not an error (although it's not something you likely
|
called <em>shadowing</em> and is not an error (although it's not something you likely
|
||||||
intend to do much).</p>
|
intend to do much).</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="s2">"outer"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="s">"outer"</span>
|
||||||
<span class="p">{</span>
|
<span class="p">{</span>
|
||||||
<span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="s2">"inner"</span>
|
<span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="s">"inner"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="c1">// Prints "inner".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">a</span><span class="p">)</span> <span class="c1">// Prints "inner".</span>
|
||||||
<span class="p">}</span>
|
<span class="p">}</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="c1">// Prints "outer".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">a</span><span class="p">)</span> <span class="c1">// Prints "outer".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<p>Declaring a variable with the same name in the <em>same</em> scope <em>is</em> an error.</p>
|
<p>Declaring a variable with the same name in the <em>same</em> scope <em>is</em> an error.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="s2">"hi"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="s">"hi"</span>
|
||||||
<span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="s2">"again"</span> <span class="c1">// ERROR!</span>
|
<span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="s">"again"</span> <span class="c1">// ERROR!</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
<h2>Assignment <a href="#assignment" name="assignment" class="header-anchor">#</a></h2>
|
<h2>Assignment <a href="#assignment" name="assignment" class="header-anchor">#</a></h2>
|
||||||
<p>After a variable has been declared, you can assign to it using <code>=</code>:</p>
|
<p>After a variable has been declared, you can assign to it using <code>=</code>:</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="m">123</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="mi">123</span>
|
||||||
<span class="n">a</span> <span class="o">=</span> <span class="m">234</span>
|
<span class="err">a</span> <span class="o">=</span> <span class="mi">234</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
@ -117,8 +117,8 @@ declared. It's an error to assign to a variable that isn't defined. Wren
|
|||||||
doesn't roll with implicit variable definition.</p>
|
doesn't roll with implicit variable definition.</p>
|
||||||
<p>When used in a larger expression, an assignment expression evaluates to the
|
<p>When used in a larger expression, an assignment expression evaluates to the
|
||||||
assigned value.</p>
|
assigned value.</p>
|
||||||
<div class="codehilite"><pre><span class="kd">var</span> <span class="n">a</span> <span class="o">=</span> <span class="s2">"before"</span>
|
<div class="codehilite"><pre><span class="k">var</span> <span class="err">a</span> <span class="o">=</span> <span class="s">"before"</span>
|
||||||
<span class="n">IO</span><span class="p">.</span><span class="n">print</span><span class="p">(</span><span class="n">a</span> <span class="o">=</span> <span class="s2">"after"</span><span class="p">)</span> <span class="c1">// Prints "after".</span>
|
<span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">a</span> <span class="o">=</span> <span class="s">"after"</span><span class="p">)</span> <span class="c1">// Prints "after".</span>
|
||||||
</pre></div>
|
</pre></div>
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
Reference in New Issue
Block a user