update docu
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6a5c8a7
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except the gitignore
+!.gitignore
\ No newline at end of file
diff --git a/concepts/index.html b/concepts/index.html
index a8aa999..bf62c4b 100644
--- a/concepts/index.html
+++ b/concepts/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/download/index.html b/download/index.html
index 4fe57e8..e461e20 100644
--- a/download/index.html
+++ b/download/index.html
@@ -329,6 +329,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/faq/index.html b/faq/index.html
index 1659d87..93fa79a 100644
--- a/faq/index.html
+++ b/faq/index.html
@@ -329,6 +329,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/index.html b/index.html
index ad332d9..6b49b78 100644
--- a/index.html
+++ b/index.html
@@ -331,6 +331,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="./language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/index.xml b/index.xml
index bcb572d..4d4dcf2 100644
--- a/index.xml
+++ b/index.xml
@@ -46,7 +46,7 @@
<guid>/language/packages/</guid>
<description>In Mita code is organized in packages, which serve multiple purposes:
- Divide the namespace: Mita programs have one global namespace per .x file. Unlike Java for example, there are no means to qualify the name of an element. Packages are used to keep this namespace clean. Only things which are explicitly imported from other packages are visible in that namespace. See Importing Packages for more details. Group code: packages are a formidable way to group code which conceptually belongs together.</description>
+ Divide the namespace: Mita programs have one global namespace per .mita file. Unlike Java for example, there are no means to qualify the name of an element. Packages are used to keep this namespace clean. Only things which are explicitly imported from other packages are visible in that namespace. See Importing Packages for more details. Group code: packages are a formidable way to group code which conceptually belongs together.</description>
</item>
<item>
@@ -85,8 +85,8 @@
<guid>/language/arrays/</guid>
<description>Arrays are a fixed-size sequence of objects. In Mita, arrays can hold any type:
-var array1 : array&lt;int32&gt;; struct vec2d { var x : int32; var y : int32; } let array2 : array&lt;vec2d&gt;; Initialization There are multiple ways to initialize and fill arrays:
-let array1 : array&lt;int32&gt; = new array&lt;int32&gt;(size = 10); let array2 : array&lt;int32&gt; = [1,2,3,4]; Length Mita arrays know how long arrays are, unlike C arrays.</description>
+var array1 : array&lt;int32, _&gt;; struct vec2d { var x : int32; var y : int32; } let array2 : array&lt;vec2d, _&gt;; Initialization There are multiple ways to initialize and fill arrays:
+let array1 : array&lt;int32, 10&gt;; // filled with 0s let array2 : array&lt;int32, _&gt; = [1,2,3,4]; Length Mita arrays know how long they are, unlike C arrays.</description>
</item>
<item>
@@ -146,7 +146,7 @@
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>/platforms/cgw/</guid>
- <description>Overview: The CGW The Common GateWay is a Bosch internal development platform, equipped with BMA280, BME280, BLE, CAT-M1/NB-IoT and GPS.
+ <description>Overview: The CGW The Common GateWay (CGW) is a Bosch internal development platform, equipped with BMA280, BME280, BLE, CAT-M1/NB-IoT and GPS.
Implemented System Resources Currently implemented sensors, connectivities and buses of the CGW platform:
Sensors Connectivities Buses IO Accelerometer LED Environment REST over HTTP Configuration Startup Delay To debug the startup process you can configure a startup delay so the CGW can connect via USB before setting up devices, connectivity, etc.</description>
</item>
@@ -173,6 +173,16 @@
</item>
<item>
+ <title>Generated Types and Functions</title>
+ <link>/language/generatedthings/</link>
+ <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
+
+ <guid>/language/generatedthings/</guid>
+ <description>Introduction Mita compiles to C with static memory management without large state machines or spaghetti code (unless you write that yourself). This is great for understanding how Mita code executes and runtime behaviour, however it imposes some serious limitations on what you can reasonably express in the language itself.
+To extend this there are generated types and functions. They can be used by users very easily and are more flexible than core types and functions, but need to be compiled by a small compiler fragment or generator.</description>
+ </item>
+
+ <item>
<title>Download</title>
<link>/download/</link>
<pubDate>Tue, 18 Jul 2017 14:18:49 +0200</pubDate>
diff --git a/language/arrays/index.html b/language/arrays/index.html
index 07b2bf1..569453d 100644
--- a/language/arrays/index.html
+++ b/language/arrays/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
@@ -429,33 +442,41 @@
<p>Arrays are a fixed-size sequence of objects. In Mita, arrays can hold any type:</p>
-<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kd">var</span> <span class="nx">array1</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="o">></span><span class="p">;</span>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kd">var</span> <span class="nx">array1</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="p">,</span> <span class="nx">_</span><span class="o">></span><span class="p">;</span>
<span class="nx">struct</span> <span class="nx">vec2d</span> <span class="p">{</span>
<span class="kd">var</span> <span class="nx">x</span> : <span class="kt">int32</span><span class="p">;</span>
<span class="kd">var</span> <span class="nx">y</span> : <span class="kt">int32</span><span class="p">;</span>
<span class="p">}</span>
-<span class="kd">let</span> <span class="nx">array2</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">vec2d</span><span class="o">></span><span class="p">;</span></code></pre></div>
+<span class="kd">let</span> <span class="nx">array2</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">vec2d</span><span class="p">,</span> <span class="nx">_</span><span class="o">></span><span class="p">;</span></code></pre></div>
<h2 id="initialization">Initialization</h2>
<p>There are multiple ways to initialize and fill arrays:</p>
-<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kd">let</span> <span class="nx">array1</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="o">></span> <span class="o">=</span> <span class="k">new</span> <span class="nx">array</span><span class="o"><</span><span class="nx">int32</span><span class="o">></span><span class="p">(</span><span class="nx">size</span> <span class="o">=</span> <span class="mi">10</span><span class="p">);</span>
-<span class="kd">let</span> <span class="nx">array2</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="o">></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></code></pre></div>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kd">let</span> <span class="nx">array1</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="p">,</span> <span class="mi">10</span><span class="o">></span><span class="p">;</span> <span class="c1">// filled with 0s
+</span><span class="c1"></span><span class="kd">let</span> <span class="nx">array2</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="p">,</span> <span class="nx">_</span><span class="o">></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></code></pre></div>
<h2 id="length">Length</h2>
-<p>Mita arrays know how long arrays are, unlike C arrays. This allows you to do a lot of things with arrays without knowing their size.</p>
-<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">fn</span> <span class="nx">sum</span><span class="p">(</span><span class="nx">a</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="o">></span><span class="p">)</span> <span class="p">{</span>
+<p>Mita arrays know how long they are, unlike C arrays. This allows you to do a lot of things with arrays without knowing their size.</p>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">fn</span> <span class="nx">sum</span><span class="p">(</span><span class="nx">a</span> : <span class="kt">array</span><span class="o"><</span><span class="nx">int32</span><span class="p">,</span> <span class="nx">_</span><span class="o">></span><span class="p">)</span> <span class="p">{</span>
<span class="kd">var</span> <span class="nx">result</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o"><</span> <span class="nx">a</span><span class="p">.</span><span class="nx">length</span><span class="p">();</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">result</span> <span class="o">+=</span> <span class="nx">a</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
<span class="p">}</span>
<span class="k">return</span> <span class="nx">result</span><span class="p">;</span>
<span class="p">}</span></code></pre></div>
-<p>The only exception to that is returning arrays. While we try hard to do <a href="../../concepts/#element-size-inference">element size inference</a>, in some cases we fail to correctly infer the size of your array and inform you about it. In that case you need to manually specify the array length:</p>
-<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">fn</span> <span class="nx">returnsArray</span><span class="p">()</span><span class="o">:</span> <span class="nx">array</span><span class="o"><</span><span class="nx">int32</span><span class="o">></span> <span class="p">{</span>
- <span class="kd">let</span> <span class="nx">array1</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">array</span><span class="o"><</span><span class="nx">int32</span><span class="o">></span><span class="p">(</span><span class="nx">size</span> <span class="o">=</span> <span class="mi">10</span><span class="p">);</span>
+<p>The only exception to that is returning arrays. While we try hard to do <a href="../../concepts/#element-size-inference">element size inference</a>, in some cases we fail to correctly infer the size of your array and inform you about it. In that case you need to manually specify the array length in the type:</p>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">fn</span> <span class="nx">returnsArray() {</span>
+ <span class="kd">let</span> <span class="nx">array1</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">array</span><span class="o"><</span><span class="nx">int32</span><span class="p">,</span> <span class="mi">10</span><span class="o">></span><span class="p">;</span>
<span class="k">return</span> <span class="nx">array1</span><span class="p">;</span>
<span class="p">}</span></code></pre></div>
+<p>If you only want to specify the size you can leave out the type, too:</p>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">fn</span> <span class="nx">returnsArray() {</span>
+ <span class="kd">var</span> <span class="nx">a</span>: <span class="kt">array</span><span class="o"><</span><span class="nx">_</span><span class="p">,</span> <span class="mi">10</span><span class="o">></span><span class="p">;</span>
+ <span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o"><</span> <span class="mi">10</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">a</span> <span class="o">+=</span> <span class="nx">i</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nx">a</span><span class="p">;</span>
+<span class="p">}</span></code></pre></div>
<h2 id="access">Access</h2>
<p>You access arrays using the familiar square brackets <code>[]</code>:</p>
diff --git a/language/basics/index.html b/language/basics/index.html
index 1cc3849..c225abb 100644
--- a/language/basics/index.html
+++ b/language/basics/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/language/events/index.html b/language/events/index.html
index 35b2283..2c27040 100644
--- a/language/events/index.html
+++ b/language/events/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/language/exceptions/index.html b/language/exceptions/index.html
index 54a6287..a1f8252 100644
--- a/language/exceptions/index.html
+++ b/language/exceptions/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/language/foreignfunctioninterface/index.html b/language/foreignfunctioninterface/index.html
index cb23f0a..59c1cb7 100644
--- a/language/foreignfunctioninterface/index.html
+++ b/language/foreignfunctioninterface/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/language/functions/index.html b/language/functions/index.html
index 54a19cf..86e8dce 100644
--- a/language/functions/index.html
+++ b/language/functions/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/language/index.xml b/language/index.xml
index f6c6b10..c69971d 100644
--- a/language/index.xml
+++ b/language/index.xml
@@ -36,7 +36,7 @@
<guid>/language/packages/</guid>
<description>In Mita code is organized in packages, which serve multiple purposes:
- Divide the namespace: Mita programs have one global namespace per .x file. Unlike Java for example, there are no means to qualify the name of an element. Packages are used to keep this namespace clean. Only things which are explicitly imported from other packages are visible in that namespace. See Importing Packages for more details. Group code: packages are a formidable way to group code which conceptually belongs together.</description>
+ Divide the namespace: Mita programs have one global namespace per .mita file. Unlike Java for example, there are no means to qualify the name of an element. Packages are used to keep this namespace clean. Only things which are explicitly imported from other packages are visible in that namespace. See Importing Packages for more details. Group code: packages are a formidable way to group code which conceptually belongs together.</description>
</item>
<item>
@@ -65,8 +65,8 @@
<guid>/language/arrays/</guid>
<description>Arrays are a fixed-size sequence of objects. In Mita, arrays can hold any type:
-var array1 : array&lt;int32&gt;; struct vec2d { var x : int32; var y : int32; } let array2 : array&lt;vec2d&gt;; Initialization There are multiple ways to initialize and fill arrays:
-let array1 : array&lt;int32&gt; = new array&lt;int32&gt;(size = 10); let array2 : array&lt;int32&gt; = [1,2,3,4]; Length Mita arrays know how long arrays are, unlike C arrays.</description>
+var array1 : array&lt;int32, _&gt;; struct vec2d { var x : int32; var y : int32; } let array2 : array&lt;vec2d, _&gt;; Initialization There are multiple ways to initialize and fill arrays:
+let array1 : array&lt;int32, 10&gt;; // filled with 0s let array2 : array&lt;int32, _&gt; = [1,2,3,4]; Length Mita arrays know how long they are, unlike C arrays.</description>
</item>
<item>
@@ -111,5 +111,15 @@
try { throw FooException; } catch(FooException) { println(&#34;Caught FooException&#34;); } Exceptions are implicit, meaning that functions do not have to (and cannot) declare the exceptions they might throw.</description>
</item>
+ <item>
+ <title>Generated Types and Functions</title>
+ <link>/language/generatedthings/</link>
+ <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
+
+ <guid>/language/generatedthings/</guid>
+ <description>Introduction Mita compiles to C with static memory management without large state machines or spaghetti code (unless you write that yourself). This is great for understanding how Mita code executes and runtime behaviour, however it imposes some serious limitations on what you can reasonably express in the language itself.
+To extend this there are generated types and functions. They can be used by users very easily and are more flexible than core types and functions, but need to be compiled by a small compiler fragment or generator.</description>
+ </item>
+
</channel>
</rss>
\ No newline at end of file
diff --git a/language/introduction/index.html b/language/introduction/index.html
index 79ce8d5..f75af39 100644
--- a/language/introduction/index.html
+++ b/language/introduction/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
@@ -440,7 +453,7 @@
<h2 id="anatomy-of-an-mita-program">Anatomy of an Mita program</h2>
-<p>Mita programs live in files ending with <code>.x</code>, for example <code>application.x</code>. Let’s have a look at an example which implements a simple Bluetooth enabled shock detector:</p>
+<p>Mita programs live in files ending with <code>.mita</code>, for example <code>application.mita</code>. Let’s have a look at an example which implements a simple Bluetooth enabled shock detector:</p>
<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kr">package</span> <span class="nx">main</span><span class="p">;</span>
<span class="kr">import</span> <span class="nx">platforms</span><span class="p">.</span><span class="nx">xdk110</span><span class="p">;</span>
diff --git a/language/packages/index.html b/language/packages/index.html
index 53c2e17..85f4b57 100644
--- a/language/packages/index.html
+++ b/language/packages/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
@@ -431,12 +444,12 @@
<p>In Mita code is organized in packages, which serve multiple purposes:</p>
<ul>
-<li><strong>Divide the namespace</strong>: Mita programs have one global namespace per <code>.x</code> file. Unlike Java for example, there are no means to qualify the name of an element. Packages are used to keep this namespace clean. Only things which are explicitly imported from other packages are visible in that namespace. See <a href="#importing-packages">Importing Packages</a> for more details.</li>
+<li><strong>Divide the namespace</strong>: Mita programs have one global namespace per <code>.mita</code> file. Unlike Java for example, there are no means to qualify the name of an element. Packages are used to keep this namespace clean. Only things which are explicitly imported from other packages are visible in that namespace. See <a href="#importing-packages">Importing Packages</a> for more details.</li>
<li><strong>Group code</strong>: packages are a formidable way to group code which conceptually belongs together. Where other languages have modules or classes, Mita uses packages.</li>
<li><strong>Hide information</strong>: in Mita visibility of functions, types and the likes is decided on a package level. There are only two levels of visibility: things are either visible outside a package or they are not. This is very similar to how NodeJS manages visibility (think <code>module.export</code>) or how Go does it (uppercase functions/structure members/types get exported). See <a href="#hiding-information-visibility">Hiding Information</a> for more details.</li>
</ul>
-<p>All Mita code belongs to a particular package. Thus, the first line in every <code>.x</code> file is the <code>package</code> statement. The main application logic, for example, by convention is in the <code>main</code> package:</p>
+<p>All Mita code belongs to a particular package. Thus, the first line in every <code>.mita</code> file is the <code>package</code> statement. The main application logic, for example, by convention is in the <code>main</code> package:</p>
<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kr">package</span> <span class="nx">main</span><span class="p">;</span>
<span class="p">...</span></code></pre></div>
@@ -448,10 +461,10 @@
<p>All in all you are free to name your packages however you like. The files which constitute your package content can be located wherever in the project. However, it is a good idea to replicate the logical package structure in folders. For example:</p>
<div class="highlight"><pre class="chroma"><code class="language-Pre" data-lang="Pre"><span class="nx">algorithm</span><span class="o">/</span>
- <span class="p">|</span><span class="o">-</span> <span class="nx">api</span><span class="p">.</span><span class="nx">x</span> <span class="kn">package</span> <span class="nx">algorithm</span>
- <span class="p">|</span><span class="o">-</span> <span class="nx">statistics</span><span class="p">.</span><span class="nx">x</span> <span class="kn">package</span> <span class="nx">algorithm</span><span class="p">.</span><span class="nx">statistics</span>
- <span class="err">\</span><span class="o">-</span> <span class="nx">structures</span><span class="p">.</span><span class="nx">x</span> <span class="kn">package</span> <span class="nx">algorithm</span><span class="p">.</span><span class="nx">structures</span>
-<span class="nx">main</span><span class="p">.</span><span class="nx">x</span> <span class="kn">package</span> <span class="nx">main</span></code></pre></div>
+ <span class="p">|</span><span class="o">-</span> <span class="nx">api</span><span class="p">.</span><span class="nx">mita</span> <span class="kn">package</span> <span class="nx">algorithm</span>
+ <span class="p">|</span><span class="o">-</span> <span class="nx">statistics</span><span class="p">.</span><span class="nx">mita</span> <span class="kn">package</span> <span class="nx">algorithm</span><span class="p">.</span><span class="nx">statistics</span>
+ <span class="err">\</span><span class="o">-</span> <span class="nx">structures</span><span class="p">.</span><span class="nx">mita</span> <span class="kn">package</span> <span class="nx">algorithm</span><span class="p">.</span><span class="nx">structures</span>
+<span class="nx">main</span><span class="p">.</span><span class="nx">mita</span> <span class="kn">package</span> <span class="nx">main</span></code></pre></div>
<p>Notice how we use a dot <code>.</code> to indicate a sub-package relationship.
This is merely a convention and has no influence on visibility or any other implication.</p>
@@ -460,7 +473,7 @@
<p>Packages divide the namespace, which is the space in which the names of functions and types have to be unique.
Within a package all type names and functions (save for <a href="{{ < ref "/platforms/xdk110.md" > }}">polymorphism</a>) have to be unique.
When we import a package, we import all names from that namespace into our local program. Consider the following example:</p>
-<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="c1">// file: mypackage.x
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="c1">// file: mypackage.mita
</span><span class="c1"></span><span class="kr">package</span> <span class="nx">mypackage</span><span class="p">;</span>
<span class="p">...</span>
@@ -468,14 +481,14 @@
<span class="k">return</span> <span class="mi">42</span><span class="p">;</span>
<span class="p">}</span>
-<span class="c1">// file: application.x
+<span class="c1">// file: application.mita
</span><span class="c1"></span><span class="kr">package</span> <span class="nx">main</span><span class="p">;</span>
<span class="kr">import</span> <span class="nx">mypackage</span><span class="p">;</span>
<span class="nx">every</span> <span class="nx">XDK110</span><span class="p">.</span><span class="nx">startup</span> <span class="p">{</span>
<span class="nx">println</span><span class="p">(</span><span class="sb">`The answer: </span><span class="si">${</span><span class="nx">answerTheQuestion</span><span class="p">()</span><span class="si">}</span><span class="sb">`</span><span class="p">);</span>
<span class="p">}</span></code></pre></div>
-<p>If it were not for the <code>import mypackage</code> statement, the <code>answerTheQuestion</code> function would not be visible in <code>application.x</code>.</p>
+<p>If it were not for the <code>import mypackage</code> statement, the <code>answerTheQuestion</code> function would not be visible in <code>application.mita</code>.</p>
<p>To import a package use the <code>import</code> statement. We have seen those in previous examples when we imported the platform, which is mandatory. Thus, every Mita program file must have at least one import: the platform import.
For example:</p>
@@ -483,7 +496,7 @@
<span class="kr">import</span> <span class="nx">platforms</span><span class="p">.</span><span class="nx">xdk110</span><span class="p">;</span>
<span class="p">...</span></code></pre></div>
-<p>You can shadow imported names within the current file. If in the example above <code>application.x</code> defined its own <code>answerTheQuestion()</code> function, all code within <code>application.x</code> would refer to that one instead of the imported function.</p>
+<p>You can shadow imported names within the current file. If in the example above <code>application.mita</code> defined its own <code>answerTheQuestion()</code> function, all code within <code>application.mita</code> would refer to that one instead of the imported function.</p>
<h2 id="hiding-information-visibility">Hiding Information (Visibility)</h2>
diff --git a/language/setup/index.html b/language/setup/index.html
index db2c958..4de3cb5 100644
--- a/language/setup/index.html
+++ b/language/setup/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
@@ -496,7 +509,7 @@
<span class="kr">import</span> <span class="nx">platforms</span><span class="p">.</span><span class="nx">xdk110</span><span class="p">;</span>
<span class="nx">setup</span> <span class="nx">light</span> <span class="p">{</span>
- <span class="nx">integration_time</span> <span class="o">=</span> <span class="nx">MS_12_5</span><span class="p">;</span>
+ <span class="nx">integration_time</span> <span class="o">=</span> <span class="p">.</span><span class="nx">MS_12_5</span><span class="p">;</span>
<span class="p">}</span></code></pre></div>
<div class="admonition note">
<p class="admonition-title">Use content assist to explore your options</p>
diff --git a/language/types/index.html b/language/types/index.html
index 8b3f68f..5071712 100644
--- a/language/types/index.html
+++ b/language/types/index.html
@@ -332,6 +332,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
@@ -452,12 +465,15 @@
<span class="nx">println</span><span class="p">(</span><span class="nx">msg</span><span class="p">);</span>
<span class="p">}</span></code></pre></div>
<p>There are cases where we cannot infer the length of a string, for example when it’s modified within a loop.
-In such cases you will have to explicitly tell us how long your string can be in the worst-case:</p>
-<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kd">var</span> <span class="nx">msg</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">string</span><span class="p">(</span><span class="mi">100</span><span class="p">);</span>
+In such cases you will have to explicitly tell us how long your string can be in the worst-case by specifying its size in the type of the variable:</p>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kd">var</span> <span class="nx">msg</span>: <span class="kt">string</span><span class="o"><</span><span class="mi">100</span><span class="o">></span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kd">var</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o"><</span> <span class="mi">5</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">msg</span> <span class="o">+=</span> <span class="sb">`</span><span class="si">${</span><span class="nx">i</span><span class="si">}</span><span class="sb"> `</span><span class="p">;</span>
<span class="p">}</span>
<span class="nx">println</span><span class="p">(</span><span class="nx">msg</span><span class="p">);</span></code></pre></div>
+<p>If you just want to specify that a variable holds a string and let the compiler infer its size, you can put an underscore in the place of the size argument:</p>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="kd">var</span> <span class="nx">msg</span>: <span class="kt">string</span><span class="o"><</span><span class="nx">_</span><span class="o">></span> <span class="o">=</span> <span class="s2">"foobar"</span><span class="p">;</span> <span class="c1">// msg is inferred as string<6>
+</span><span class="c1"></span><span class="nx">println</span><span class="p">(</span><span class="nx">msg</span><span class="p">);</span></code></pre></div>
<h2 id="enumerations">Enumerations</h2>
<p>Enumerations are categorical values that we as programmers can define.
@@ -593,30 +609,27 @@
<span class="o">|</span> <span class="nx">Movement</span>: <span class="kt">vec3d_t</span>
<span class="o">|</span> <span class="nx">Shock</span>: <span class="kt">uint32</span>
<span class="p">}</span></code></pre></div>
-<p>The code for <code>deviceState</code> changes slightly, since <code>vec3d_t</code>’s members have different names now. Constructing a <code>DeviceState.Movement</code> therefore looks like this:</p>
-<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">state</span> <span class="o">=</span> <span class="nx">DeviceState</span><span class="p">.</span><span class="nx">Movement</span><span class="p">(</span>
+<p>The code for <code>deviceState</code> changes slightly, since <code>vec3d_t</code>’s members have different names. Constructing a <code>DeviceState.Movement</code> therefore looks like this:</p>
+<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">state</span> <span class="o">=</span> <span class="nx">DeviceState</span><span class="p">.</span><span class="nx">Movement</span><span class="p">(</span><span class="nx">vec3d_t</span><span class="p">(</span>
<span class="nx">x</span> <span class="o">=</span> <span class="nx">accelerometer</span><span class="p">.</span><span class="nx">x_axis</span><span class="p">.</span><span class="nx">read</span><span class="p">(),</span>
<span class="nx">y</span> <span class="o">=</span> <span class="nx">accelerometer</span><span class="p">.</span><span class="nx">y_axis</span><span class="p">.</span><span class="nx">read</span><span class="p">(),</span>
- <span class="nx">z</span> <span class="o">=</span> <span class="nx">accelerometer</span><span class="p">.</span><span class="nx">z_axis</span><span class="p">.</span><span class="nx">read</span><span class="p">());</span></code></pre></div>
-<p>However you don’t need to pass in a member of the struct at all; it is “imported” to
-<code>DeviceState.Movement</code>. Binding data contained in the alternative works just as before as well.</p>
-
+ <span class="nx">z</span> <span class="o">=</span> <span class="nx">accelerometer</span><span class="p">.</span><span class="nx">z_axis</span><span class="p">.</span><span class="nx">read</span><span class="p">()));</span></code></pre></div>
<p>Some more things you can do are:</p>
<ul>
-<li>You can directly bind the whole element that was matched. This is especially useful for embedded types, since you get a variable of the embedded type instead of the sum type. The syntax for this is:</li>
+<li>You can directly bind the whole element that was matched. The resulting variable will have the type of just that constructor. The syntax for this is:</li>
</ul>
<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">is</span><span class="p">(</span><span class="nx">v</span> : <span class="kt">DeviceState.Movement</span><span class="p">)</span> <span class="p">{</span>
- <span class="cm">/* v has type vec3d_t here */</span>
+ <span class="cm">/* v has type DeviceState.Movement here */</span>
<span class="p">}</span></code></pre></div>
<ul>
-<li>You can bind using named parameters, e.g. the <code>DeviceState.Movement</code> above has the named parameters <code>accelerationX</code>, <code>accelerationY</code> and <code>accelerationZ</code>. This looks like this:</li>
+<li>You can bind using named parameters, e.g. the first <code>DeviceState.Movement</code> declaration above has the named parameters <code>accelerationX</code>, <code>accelerationY</code> and <code>accelerationZ</code>. This looks like this:</li>
</ul>
<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">is</span><span class="p">(</span><span class="nx">DeviceState</span><span class="p">.</span><span class="nx">Movement</span> <span class="o">-></span>
<span class="nx">x</span> <span class="o">=</span> <span class="nx">vec3d</span><span class="p">.</span><span class="nx">accelerationX</span><span class="p">,</span>
<span class="nx">z</span> <span class="o">=</span> <span class="nx">vec3d</span><span class="p">.</span><span class="nx">accelerationZ</span><span class="p">,</span>
<span class="nx">y</span> <span class="o">=</span> <span class="nx">vec3d</span><span class="p">.</span><span class="nx">accelerationY</span><span class="p">)</span> <span class="p">{</span>
- <span class="cm">/* Use a, b and c here */</span>
+ <span class="cm">/* Use x, y and z here */</span>
<span class="p">}</span></code></pre></div>
<ul>
<li>You can supply a default case with <code>isother { ... }</code>.</li>
@@ -649,12 +662,13 @@
<span class="nx">is</span><span class="p">(</span><span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec1d</span> <span class="o">-></span> <span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">b</span> <span class="o">=</span> <span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec1d</span><span class="p">(</span><span class="nx">x</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
<span class="p">}</span>
- <span class="nx">is</span><span class="p">(</span><span class="nx">v</span>: <span class="kt">anyVec.vec2d</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">is</span><span class="p">(</span><span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec2d</span> <span class="o">-></span> <span class="nx">v</span><span class="p">)</span> <span class="p">{</span>
<span class="cm">/* v is of type vec2d_t */</span>
- <span class="nx">b</span> <span class="o">=</span> <span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec2d</span><span class="p">(</span><span class="nx">v</span><span class="p">.</span><span class="nx">x</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">v</span><span class="p">.</span><span class="nx">y</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
+ <span class="nx">b</span> <span class="o">=</span> <span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec2d</span><span class="p">(</span><span class="nx">vec2d_t</span><span class="p">(</span><span class="nx">v</span><span class="p">.</span><span class="nx">x</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">v</span><span class="p">.</span><span class="nx">y</span> <span class="o">+</span> <span class="mi">1</span><span class="p">));</span>
<span class="p">}</span>
- <span class="nx">is</span><span class="p">(</span><span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec3d</span> <span class="o">-></span> <span class="nx">x</span> <span class="o">=</span> <span class="nx">vec3d</span><span class="p">.</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span> <span class="o">=</span> <span class="nx">vec3d</span><span class="p">.</span><span class="nx">y</span><span class="p">,</span> <span class="nx">z</span> <span class="o">=</span> <span class="nx">vec3d</span><span class="p">.</span><span class="nx">z</span><span class="p">)</span> <span class="p">{</span>
- <span class="nx">b</span> <span class="o">=</span> <span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec3d</span><span class="p">(</span><span class="nx">x</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">y</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">z</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
+ <span class="nx">is</span><span class="p">(</span><span class="nx">v</span>: <span class="kt">anyVec.vec3d</span><span class="p">)</span> <span class="p">{</span>
+ <span class="cm">/* v is of type anyVec.vec3d */</span>
+ <span class="nx">b</span> <span class="o">=</span> <span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec3d</span><span class="p">(</span><span class="nx">v</span><span class="p">.</span><span class="nx">x</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">v</span><span class="p">.</span><span class="nx">y</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">v</span><span class="p">.</span><span class="nx">z</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
<span class="p">}</span>
<span class="nx">is</span><span class="p">(</span><span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec4d</span> <span class="o">-></span> <span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">,</span> <span class="nx">z</span><span class="p">,</span> <span class="nx">w</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">b</span> <span class="o">=</span> <span class="nx">anyVec</span><span class="p">.</span><span class="nx">vec4d</span><span class="p">(</span><span class="nx">x</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">y</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">z</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">w</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
diff --git a/platforms/arduinouno/index.html b/platforms/arduinouno/index.html
index d3dd2b3..e98fdbd 100644
--- a/platforms/arduinouno/index.html
+++ b/platforms/arduinouno/index.html
@@ -329,6 +329,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/platforms/cgw/index.html b/platforms/cgw/index.html
index 6569b29..53c7651 100644
--- a/platforms/cgw/index.html
+++ b/platforms/cgw/index.html
@@ -329,6 +329,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
@@ -430,7 +443,7 @@
<h2 id="overview-the-cgw">Overview: The CGW</h2>
-<p>The Common GateWay is a Bosch internal development platform, equipped with BMA280, BME280, BLE, CAT-M1/NB-IoT and GPS.</p>
+<p>The Common GateWay (CGW) is a Bosch internal development platform, equipped with BMA280, BME280, BLE, CAT-M1/NB-IoT and GPS.</p>
<h3 id="implemented-system-resources">Implemented System Resources</h3>
@@ -542,7 +555,7 @@
<p>Using REST you can easily talk to servers over HTTP. REST defines a stateless interface with a simple URL scheme. Normally a REST server consists of a versioned endpoint like <code>http://api.github.com/v3</code> which then provides different resources, for example <code>api.github.com/v3/repos/eclipse/mita/branches</code> and <code>/repos/eclipse/mita/issues</code>.</p>
-<p>Currently only writing some content types and POST method is supported. There is a special resource available for BCX for talking to the Bosch IoT Cloud, <code>BcxHttpRestClient</code>.</p>
+<p>Currently, only writing, some content types and POST method is supported.</p>
<h4 id="example">Example</h4>
<div class="highlight"><pre class="chroma"><code class="language-TypeScript" data-lang="TypeScript"><span class="nx">setup</span> <span class="nx">net</span>: <span class="kt">Radio</span> <span class="p">{</span> <span class="cm">/* ... */</span> <span class="p">}</span>
diff --git a/platforms/index.xml b/platforms/index.xml
index 647e179..2b74bf6 100644
--- a/platforms/index.xml
+++ b/platforms/index.xml
@@ -46,7 +46,7 @@
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>/platforms/cgw/</guid>
- <description>Overview: The CGW The Common GateWay is a Bosch internal development platform, equipped with BMA280, BME280, BLE, CAT-M1/NB-IoT and GPS.
+ <description>Overview: The CGW The Common GateWay (CGW) is a Bosch internal development platform, equipped with BMA280, BME280, BLE, CAT-M1/NB-IoT and GPS.
Implemented System Resources Currently implemented sensors, connectivities and buses of the CGW platform:
Sensors Connectivities Buses IO Accelerometer LED Environment REST over HTTP Configuration Startup Delay To debug the startup process you can configure a startup delay so the CGW can connect via USB before setting up devices, connectivity, etc.</description>
</item>
diff --git a/platforms/integratorsguide/index.html b/platforms/integratorsguide/index.html
index 40f1879..4f049f3 100644
--- a/platforms/integratorsguide/index.html
+++ b/platforms/integratorsguide/index.html
@@ -329,6 +329,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/platforms/x86/index.html b/platforms/x86/index.html
index 05464fb..0127ffb 100644
--- a/platforms/x86/index.html
+++ b/platforms/x86/index.html
@@ -329,6 +329,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
diff --git a/platforms/xdk110/index.html b/platforms/xdk110/index.html
index 4fcf420..9417999 100644
--- a/platforms/xdk110/index.html
+++ b/platforms/xdk110/index.html
@@ -329,6 +329,19 @@
+
+
+
+
+
+<a title="Generated Types and Functions" href="../../language/generatedthings/">
+
+ Generated Types and Functions
+</a>
+
+
+
+
</ul>
</li>
@@ -1490,7 +1503,7 @@
<tr>
<td></td>
<td><code>keepAliveInterval: uint32</code></td>
-<td>The keep alive interval (in seconds) is the time the client commits to for when sending regular pings to the broker. The broker responds to the pings enabling both sides to determine if the other one is still alive and reachable. Default: <code>60</code>.</td>
+<td>The keep alive interval (in seconds) is the time the client commits to for when sending regular pings to the broker. The broker responds to the pings enabling both sides to determine if the other one is still alive and reachable. Creates an automatic ping task that pings twice in this interval. Default: <code>60</code>.</td>
</tr>
<tr>
@@ -1739,7 +1752,7 @@
<span class="p">}</span>
<span class="nx">every</span> <span class="mi">1</span> <span class="nx">hour</span> <span class="p">{</span>
- <span class="kd">let</span> <span class="nx">data</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">array</span><span class="o"><</span><span class="nx">CayennePayload</span><span class="o">></span><span class="p">(</span><span class="mi">1</span><span class="p">);</span>
+ <span class="kd">let</span> <span class="nx">data</span>: <span class="kt">array</span><span class="o"><</span><span class="nx">CayennePayload</span><span class="p">,</span> <span class="mi">1</span><span class="o">></span><span class="p">;</span>
<span class="nx">data</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="nx">CayennePayload</span><span class="p">.</span><span class="nx">Accelerometer</span><span class="p">(</span>
<span class="nx">accelerometer</span><span class="p">.</span><span class="nx">x_axis</span><span class="p">.</span><span class="nx">read</span><span class="p">()</span> <span class="kr">as</span> <span class="nx">int16</span><span class="p">,</span>
<span class="nx">accelerometer</span><span class="p">.</span><span class="nx">y_axis</span><span class="p">.</span><span class="nx">read</span><span class="p">()</span> <span class="kr">as</span> <span class="nx">int16</span><span class="p">,</span>
@@ -1749,7 +1762,7 @@
<span class="p">}</span>
<span class="nx">every</span> <span class="mi">10</span> <span class="nx">minutes</span> <span class="p">{</span>
- <span class="kd">let</span> <span class="nx">data</span>: <span class="kt">array</span><span class="o"><</span><span class="nx">uint8</span><span class="o">></span> <span class="o">=</span> <span class="p">[</span><span class="mh">0xCA</span><span class="p">,</span> <span class="mh">0xFE</span><span class="p">];</span>
+ <span class="kd">let</span> <span class="nx">data</span>: <span class="kt">array</span><span class="o"><</span><span class="nx">uint8</span><span class="p">,</span> <span class="nx">_</span><span class="o">></span> <span class="o">=</span> <span class="p">[</span><span class="mh">0xCA</span><span class="p">,</span> <span class="mh">0xFE</span><span class="p">];</span>
<span class="nx">lora</span><span class="p">.</span><span class="nx">r</span><span class="p">.</span><span class="nx">write</span><span class="p">(</span><span class="nx">data</span><span class="p">);</span>
<span class="p">}</span></code></pre></div>
<h4 id="configuration-14">Configuration</h4>
diff --git a/sitemap.xml b/sitemap.xml
index 853b077..b8b68b7 100644
--- a/sitemap.xml
+++ b/sitemap.xml
@@ -71,6 +71,10 @@
</url>
<url>
+ <loc>/language/generatedthings/</loc>
+ </url>
+
+ <url>
<loc>/download/</loc>
<lastmod>2017-07-18T14:18:49+02:00</lastmod>
</url>
