Deployed 4dd247b to master with MkDocs 1.2.4 and mike 1.1.2

2022-07-06 11:16:24 +00:00
parent 4478a9306b
commit 0f96020f0d
26 changed files with 1534 additions and 1041 deletions
@@ -10,7 +10,7 @@
      
      
      <link rel="icon" href="../favicon.png">
-      <meta name="generator" content="mkdocs-1.2.4, mkdocs-material-7.1.9">
+      <meta name="generator" content="mkdocs-1.2.4, mkdocs-material-7.3.6">
    
    
      
@@ -18,10 +18,10 @@
      
    
    
-      <link rel="stylesheet" href="../assets/stylesheets/main.ca7ac06f.min.css">
+      <link rel="stylesheet" href="../assets/stylesheets/main.a57b2b03.min.css">
      
        
-        <link rel="stylesheet" href="../assets/stylesheets/palette.f1a3b89f.min.css">
+        <link rel="stylesheet" href="../assets/stylesheets/palette.3f5d1f46.min.css">
        
      
    
@@ -74,7 +74,9 @@
      
    </div>
    
-      <header class="md-header" data-md-component="header">
+      
+
+<header class="md-header" data-md-component="header">
  <nav class="md-header__inner md-grid" aria-label="Header">
    <a href=".." title="æternity Sophia Language" class="md-header__button md-logo" aria-label="æternity Sophia Language" data-md-component="logo">
      
@@ -134,14 +136,24 @@
  <label class="md-search__overlay" for="__search"></label>
  <div class="md-search__inner" role="search">
    <form class="md-search__form" name="search">
-      <input type="text" class="md-search__input" name="query" aria-label="Search" placeholder="Search" autocapitalize="off" autocorrect="off" autocomplete="off" spellcheck="false" data-md-component="search-query" data-md-state="active" required>
+      <input type="text" class="md-search__input" name="query" aria-label="Search" placeholder="Search" autocapitalize="off" autocorrect="off" autocomplete="off" spellcheck="false" data-md-component="search-query" required>
      <label class="md-search__icon md-icon" for="__search">
        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M9.5 3A6.5 6.5 0 0 1 16 9.5c0 1.61-.59 3.09-1.56 4.23l.27.27h.79l5 5-1.5 1.5-5-5v-.79l-.27-.27A6.516 6.516 0 0 1 9.5 16 6.5 6.5 0 0 1 3 9.5 6.5 6.5 0 0 1 9.5 3m0 2C7 5 5 7 5 9.5S7 14 9.5 14 14 12 14 9.5 12 5 9.5 5z"/></svg>
        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M20 11v2H8l5.5 5.5-1.42 1.42L4.16 12l7.92-7.92L13.5 5.5 8 11h12z"/></svg>
      </label>
-      <button type="reset" class="md-search__icon md-icon" aria-label="Clear" tabindex="-1">
-        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19 6.41 17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12 19 6.41z"/></svg>
-      </button>
+      <nav class="md-search__options" aria-label="Search">
+        
+          <a href="javascript:void(0)" class="md-search__icon md-icon" aria-label="Share" data-clipboard data-clipboard-text="" data-md-component="search-share" tabindex="-1">
+            <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M18 16.08c-.76 0-1.44.3-1.96.77L8.91 12.7c.05-.23.09-.46.09-.7 0-.24-.04-.47-.09-.7l7.05-4.11c.54.5 1.25.81 2.04.81a3 3 0 0 0 3-3 3 3 0 0 0-3-3 3 3 0 0 0-3 3c0 .24.04.47.09.7L8.04 9.81C7.5 9.31 6.79 9 6 9a3 3 0 0 0-3 3 3 3 0 0 0 3 3c.79 0 1.5-.31 2.04-.81l7.12 4.15c-.05.21-.08.43-.08.66 0 1.61 1.31 2.91 2.92 2.91 1.61 0 2.92-1.3 2.92-2.91A2.92 2.92 0 0 0 18 16.08z"/></svg>
+          </a>
+        
+        <button type="reset" class="md-search__icon md-icon" aria-label="Clear" tabindex="-1">
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19 6.41 17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12 19 6.41z"/></svg>
+        </button>
+      </nav>
+      
+        <div class="md-search__suggest" data-md-component="search-suggest"></div>
+      
    </form>
    <div class="md-search__output">
      <div class="md-search__scrollwrap" data-md-scrollfix>
@@ -171,12 +183,15 @@
      </div>
    
  </nav>
+  
 </header>
    
    <div class="md-container" data-md-component="container">
      
      
        
+          
+        
      
      <main class="md-main" data-md-component="main">
        <div class="md-main__inner md-grid">
@@ -272,6 +287,8 @@
      </a>
      
        
+
+
 <nav class="md-nav md-nav--secondary" aria-label="Table of contents">
  
  
@@ -665,6 +682,8 @@
                <div class="md-sidebar__scrollwrap">
                  <div class="md-sidebar__inner">
                    
+
+
 <nav class="md-nav md-nav--secondary" aria-label="Table of contents">
  
  
@@ -1027,24 +1046,24 @@ and the <a href="../sophia_stdlib/#call">Call</a> namespaces in the documentatio
 <p>To call a function in another contract you need the address to an instance of
 the contract. The type of the address must be a contract type, which consists
 of a number of type definitions and entrypoint declarations. For instance,</p>
-<p><code>sophia
-// A contract type
-contract interface VotingType =
-  entrypoint vote : string =&gt; unit</code></p>
+<div class="highlight"><pre><span></span><code><span class="c1">// A contract type</span>
+<span class="k">contract</span><span class="w"> </span><span class="k">interface</span><span class="w"> </span><span class="nf">VotingType</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">vote</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="kt">unit</span><span class="w"></span>
+</code></pre></div>
 <p>Now given contract address of type <code>VotingType</code> you can call the <code>vote</code>
 entrypoint of that contract:</p>
-<p><code>sophia
-contract VoteTwice =
-  entrypoint voteTwice(v : VotingType, alt : string) =
-    v.vote(alt)
-    v.vote(alt)</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">contract</span><span class="w"> </span><span class="nf">VoteTwice</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">voteTwice</span><span class="p">(</span><span class="n">v</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nf">VotingType</span><span class="p">,</span><span class="w"> </span><span class="n">alt</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="n">v</span><span class="p">.</span><span class="n">vote</span><span class="p">(</span><span class="n">alt</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="n">v</span><span class="p">.</span><span class="n">vote</span><span class="p">(</span><span class="n">alt</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <p>Contract calls take two optional named arguments <code>gas : int</code> and <code>value : int</code>
 that lets you set a gas limit and provide tokens to a contract call. If omitted
 the defaults are no gas limit and no tokens. Suppose there is a fee for voting:</p>
-<p><code>sophia
-  entrypoint voteTwice(v : VotingType, fee : int, alt : string) =
-    v.vote(value = fee, alt)
-    v.vote(value = fee, alt)</code></p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">voteTwice</span><span class="p">(</span><span class="n">v</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nf">VotingType</span><span class="p">,</span><span class="w"> </span><span class="n">fee</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">alt</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="n">v</span><span class="p">.</span><span class="n">vote</span><span class="p">(</span><span class="n">value</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">fee</span><span class="p">,</span><span class="w"> </span><span class="n">alt</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="n">v</span><span class="p">.</span><span class="n">vote</span><span class="p">(</span><span class="n">value</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">fee</span><span class="p">,</span><span class="w"> </span><span class="n">alt</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <p>Named arguments can be given in any order.</p>
 <p>Note that reentrant calls are not permitted. In other words, when calling
 another contract it cannot call you back (directly or indirectly).</p>
@@ -1057,9 +1076,9 @@ fails.</p>
 <p>To recover the underlying <code>address</code> of a contract instance there is a field
 <code>address : address</code>. For instance, to send tokens to the voting contract (given that it is payable)
 without calling it you can write</p>
-<p><code>sophia
-  entrypoint pay(v : VotingType, amount : int) =
-    Chain.spend(v.address, amount)</code></p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">pay</span><span class="p">(</span><span class="n">v</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nf">VotingType</span><span class="p">,</span><span class="w"> </span><span class="n">amount</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Chain</span><span class="p">.</span><span class="n">spend</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">amount</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <h3 id="protected-contract-calls">Protected contract calls</h3>
 <p>If a contract call fails for any reason (for instance, the remote contract
 crashes or runs out of gas, or the entrypoint doesn't exist or has the wrong
@@ -1069,15 +1088,15 @@ contract calls takes a named argument <code>protected : bool</code> (default <co
 changes the type of the contract call, wrapping the result in an <code>option</code> type.
 If the call fails the result is <code>None</code>, otherwise it's <code>Some(r)</code> where <code>r</code> is
 the return value of the call.</p>
-<p>```sophia
-contract interface VotingType =
-  entrypoint : vote : string =&gt; unit</p>
-<p>contract Voter =
-  entrypoint tryVote(v : VotingType, alt : string) =
-    switch(v.vote(alt, protected = true) : option(unit))
-      None    =&gt; "Voting failed"
-      Some(_) =&gt; "Voting successful"
-```</p>
+<div class="highlight"><pre><span></span><code><span class="k">contract</span><span class="w"> </span><span class="k">interface</span><span class="w"> </span><span class="nf">VotingType</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="n">vote</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="kt">unit</span><span class="w"></span>
+
+<span class="k">contract</span><span class="w"> </span><span class="nf">Voter</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">tryVote</span><span class="p">(</span><span class="n">v</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nf">VotingType</span><span class="p">,</span><span class="w"> </span><span class="n">alt</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="k">switch</span><span class="p">(</span><span class="n">v</span><span class="p">.</span><span class="n">vote</span><span class="p">(</span><span class="n">alt</span><span class="p">,</span><span class="w"> </span><span class="n">protected</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="kc">true</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">option</span><span class="p">(</span><span class="kt">unit</span><span class="p">))</span><span class="w"></span>
+<span class="w">      </span><span class="nf">None</span><span class="w">    </span><span class="ow">=&gt;</span><span class="w"> </span><span class="s2">&quot;Voting failed&quot;</span><span class="w"></span>
+<span class="w">      </span><span class="nf">Some</span><span class="p">(</span><span class="n">_</span><span class="p">)</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="s2">&quot;Voting successful&quot;</span><span class="w"></span>
+</code></pre></div>
 <p>Any gas that was consumed by the contract call before the failure stays
 consumed, which means that in order to protect against the remote contract
 running out of gas it is necessary to set a gas limit using the <code>gas</code> argument.
@@ -1098,16 +1117,16 @@ arguments – please refer to their documentation for the details.</p>
 <p>While <code>Chain.clone</code> requires only a <code>contract interface</code> and a living instance
 of a given contract on the chain, <code>Chain.create</code> needs a full definition of a
 to-create contract defined by the standard <code>contract</code> syntax, for example</p>
-<p>```sophia
-contract IntHolder =
-  type state = int
-  entrypoint init(x) = x
-  entrypoint get() = state</p>
-<p>main contract IntHolderFactory =
-  stateful entrypoint new(x : int) : IntHolder =
-    let ih = Chain.create(x) : IntHolder
-    ih
-```</p>
+<div class="highlight"><pre><span></span><code><span class="k">contract</span><span class="w"> </span><span class="nf">IntHolder</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">type</span><span class="w"> </span><span class="nb">state</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="kt">int</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">init</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">x</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">get</span><span class="p">()</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nb">state</span><span class="w"></span>
+
+<span class="k">main</span><span class="w"> </span><span class="k">contract</span><span class="w"> </span><span class="nf">IntHolderFactory</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">new</span><span class="p">(</span><span class="n">x</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nf">IntHolder</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="k">let</span><span class="w"> </span><span class="n">ih</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nc">Chain</span><span class="p">.</span><span class="n">create</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nf">IntHolder</span><span class="w"></span>
+<span class="w">    </span><span class="n">ih</span><span class="w"></span>
+</code></pre></div>
 <p>In case of a presence of child contracts (<code>IntHolder</code> in this case), the main
 contract must be pointed out with the <code>main</code> keyword as shown in the example.</p>
 <h2 id="mutable-state">Mutable state</h2>
@@ -1135,9 +1154,9 @@ provides special syntax for map/record updates.</p>
 <p>Top-level functions and entrypoints must be annotated with the
 <code>stateful</code> keyword to be allowed to affect the state of the running contract.
 For instance,</p>
-<p><code>sophia
-  stateful entrypoint set_state(s : state) =
-    put(s)</code></p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">set_state</span><span class="p">(</span><span class="n">s</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nb">state</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nb">put</span><span class="p">(</span><span class="n">s</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <p>Without the <code>stateful</code> annotation the compiler does not allow the call to
 <code>put</code>. A <code>stateful</code> annotation is required to</p>
 <ul>
@@ -1167,10 +1186,10 @@ For instance,</p>
 <p>A concrete contract is by default <em>not</em> payable. Any attempt at spending to such
 a contract (either a <code>Chain.spend</code> or a normal spend transaction) will fail. If a
 contract shall be able to receive funds in this way it has to be declared <code>payable</code>:</p>
-<p><code>sophia
-// A payable contract
-payable contract ExampleContract =
-  stateful entrypoint do_stuff() = ...</code></p>
+<div class="highlight"><pre><span></span><code><span class="c1">// A payable contract</span>
+<span class="k">payable</span><span class="w"> </span><span class="k">contract</span><span class="w"> </span><span class="nf">ExampleContract</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">do_stuff</span><span class="p">()</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="p">...</span><span class="w"></span>
+</code></pre></div>
 <p>If in doubt, it is possible to check if an address is payable using
 <code>Address.is_payable(addr)</code>.</p>
 <h3 id="payable-entrypoints">Payable entrypoints</h3>
@@ -1178,73 +1197,77 @@ payable contract ExampleContract =
 (either a <a href="#calling-other-contracts">Remote call</a> or a contract call transaction)
 that has a non-zero <code>value</code> will fail. Contract entrypoints that should be called
 with a non-zero value should be declared <code>payable</code>.</p>
-<p><code>sophia
-payable stateful entrypoint buy(to : address) =
-  if(Call.value &gt; 42)
-    transfer_item(to)
-  else
-    abort("Value too low")</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">payable</span><span class="w"> </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">buy</span><span class="p">(</span><span class="n">to</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">address</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">if</span><span class="p">(</span><span class="nc">Call</span><span class="p">.</span><span class="n">value</span><span class="w"> </span><span class="ow">&gt;</span><span class="w"> </span><span class="mi">42</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="n">transfer_item</span><span class="p">(</span><span class="n">to</span><span class="p">)</span><span class="w"></span>
+<span class="w">  </span><span class="k">else</span><span class="w"></span>
+<span class="w">    </span><span class="nb">abort</span><span class="p">(</span><span class="s2">&quot;Value too low&quot;</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <h2 id="namespaces">Namespaces</h2>
 <p>Code can be split into libraries using the <code>namespace</code> construct. Namespaces
 can appear at the top-level and can contain type and function definitions, but
 not entrypoints. Outside the namespace you can refer to the (non-private) names
 by qualifying them with the namespace (<code>Namespace.name</code>).
 For example,</p>
-<p>```sophia
-namespace Library =
-  type number = int
-  function inc(x : number) : number = x + 1</p>
-<p>contract MyContract =
-  entrypoint plus2(x) : Library.number =
-    Library.inc(Library.inc(x))
-```</p>
+<div class="highlight"><pre><span></span><code><span class="k">namespace</span><span class="w"> </span><span class="nf">Library</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">type</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="kt">int</span><span class="w"></span>
+<span class="w">  </span><span class="k">function</span><span class="w"> </span><span class="n">inc</span><span class="p">(</span><span class="n">x</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">+</span><span class="w"> </span><span class="mi">1</span><span class="w"></span>
+
+<span class="k">contract</span><span class="w"> </span><span class="nf">MyContract</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">plus2</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nc">Library</span><span class="p">.</span><span class="n">number</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Library</span><span class="p">.</span><span class="n">inc</span><span class="p">(</span><span class="nc">Library</span><span class="p">.</span><span class="n">inc</span><span class="p">(</span><span class="n">x</span><span class="p">))</span><span class="w"></span>
+</code></pre></div>
 <p>Functions in namespaces have access to the same environment (including the
 <code>Chain</code>, <code>Call</code>, and <code>Contract</code>, builtin namespaces) as function in a contract,
 with the exception of <code>state</code>, <code>put</code> and <code>Chain.event</code> since these are
 dependent on the specific state and event types of the contract.</p>
 <p>To avoid mentioning the namespace every time it is used, Sophia allows
 including the namespace in the current scope with the <code>using</code> keyword:
-<code>include "Pair.aes"
+<div class="highlight"><pre><span></span><code>include &quot;Pair.aes&quot;
 using Pair
 contract C =
  type state = int
  entrypoint init() =
    let p = (1, 2)
-    fst(p)  // this is the same as Pair.fst(p)</code></p>
+    fst(p)  // this is the same as Pair.fst(p)
+</code></pre></div></p>
 <p>It is also possible to make an alias for the namespace with the <code>as</code> keyword:
-<code>include "Pair.aes"
+<div class="highlight"><pre><span></span><code>include &quot;Pair.aes&quot;
 contract C =
  using Pair as P
  type state = int
  entrypoint init() =
    let p = (1, 2)
-    P.fst(p)  // this is the same as Pair.fst(p)</code></p>
+    P.fst(p)  // this is the same as Pair.fst(p)
+</code></pre></div></p>
 <p>Having the same alias for multiple namespaces is possible and it allows
 referening functions that are defined in different namespaces and have
 different names with the same alias:
-<code>namespace Xa = function f() = 1
+<div class="highlight"><pre><span></span><code>namespace Xa = function f() = 1
 namespace Xb = function g() = 2
 contract Cntr =
  using Xa as A
  using Xb as A
  type state = int
-  entrypoint init() = A.f() + A.g()</code></p>
+  entrypoint init() = A.f() + A.g()
+</code></pre></div></p>
 <p>Note that using functions with the same name would result in an ambiguous name
 error:
-```
-namespace Xa = function f() = 1
+<div class="highlight"><pre><span></span><code>namespace Xa = function f() = 1
 namespace Xb = function f() = 2
 contract Cntr =
  using Xa as A
  using Xb as A
-  type state = int</p>
-<p>// the next line has an error because f is defined in both Xa and Xb
+  type state = int
+
+  // the next line has an error because f is defined in both Xa and Xb
  entrypoint init() = A.f()
-```</p>
+</code></pre></div></p>
 <p>Importing specific parts of a namespace or hiding these parts can also be
 done like this:
-<code>using Pair for [fst, snd]       // this will only import fst and snd
-using Triple hiding [fst, snd]  // this will import everything except for fst and snd</code></p>
+<div class="highlight"><pre><span></span><code>using Pair for [fst, snd]       // this will only import fst and snd
+using Triple hiding [fst, snd]  // this will import everything except for fst and snd
+</code></pre></div></p>
 <p>Note that it is possible to use a namespace in the top level of the file, in the
 contract level, namespace level, or in the function level.</p>
 <h2 id="splitting-code-over-multiple-files">Splitting code over multiple files</h2>
@@ -1252,14 +1275,14 @@ contract level, namespace level, or in the function level.</p>
 statement. These must appear at the top-level (outside the main contract). The
 included file can contain one or more namespaces and abstract contracts. For
 example, if the file <code>library.aes</code> contains</p>
-<p><code>sophia
-namespace Library =
-  function inc(x) = x + 1</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">namespace</span><span class="w"> </span><span class="nf">Library</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">function</span><span class="w"> </span><span class="n">inc</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">+</span><span class="w"> </span><span class="mi">1</span><span class="w"></span>
+</code></pre></div>
 <p>you can use it from another file using an <code>include</code>:</p>
-<p><code>sophia
-include "library.aes"
-contract MyContract =
-  entrypoint plus2(x) = Library.inc(Library.inc(x))</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">include</span><span class="w"> </span><span class="s2">&quot;library.aes&quot;</span><span class="w"></span>
+<span class="k">contract</span><span class="w"> </span><span class="nf">MyContract</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">plus2</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nc">Library</span><span class="p">.</span><span class="n">inc</span><span class="p">(</span><span class="nc">Library</span><span class="p">.</span><span class="n">inc</span><span class="p">(</span><span class="n">x</span><span class="p">))</span><span class="w"></span>
+</code></pre></div>
 <p>This behaves as if the contents of <code>library.aes</code> was textually inserted into
 the file, except that error messages will refer to the original source
 locations. The language will try to include each file at most one time automatically,
@@ -1271,14 +1294,14 @@ namespaces like <code>Chain</code>, <code>Contract</code>, <code>Map</code>
 are included by default and are supported internally by the compiler.
 Others like <code>List</code>, <code>Frac</code>, <code>Option</code> need to be manually included using the
 <code>include</code> directive. For example
-```sophia
-include "List.aes"
-include "Pair.aes"
-- Map is already there!</p>
-<p>namespace C =
-  entrypoint keys(m : map('a, 'b)) : list('a) =
-    List.map(Pair.fst, (Map.to_list(m)))
-```</p>
+<div class="highlight"><pre><span></span><code><span class="k">include</span><span class="w"> </span><span class="s2">&quot;List.aes&quot;</span><span class="w"></span>
+<span class="k">include</span><span class="w"> </span><span class="s2">&quot;Pair.aes&quot;</span><span class="w"></span>
+<span class="ow">--</span><span class="w"> </span><span class="nf">Map</span><span class="w"> </span><span class="n">is</span><span class="w"> </span><span class="n">already</span><span class="w"> </span><span class="n">there</span><span class="ow">!</span><span class="w"></span>
+
+<span class="k">namespace</span><span class="w"> </span><span class="nf">C</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">keys</span><span class="p">(</span><span class="n">m</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">map</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;b</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">list</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">List</span><span class="p">.</span><span class="n">map</span><span class="p">(</span><span class="nc">Pair</span><span class="p">.</span><span class="n">fst</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="nc">Map</span><span class="p">.</span><span class="n">to_list</span><span class="p">(</span><span class="n">m</span><span class="p">)))</span><span class="w"></span>
+</code></pre></div></p>
 <h2 id="types">Types</h2>
 <p>Sophia has the following types:</p>
 <table>
@@ -1499,57 +1522,57 @@ corresponding integer, so setting very high bits can be expensive).</p>
 <h2 id="type-aliases">Type aliases</h2>
 <p>Type aliases can be introduced with the <code>type</code> keyword and can be
 parameterized. For instance</p>
-<p><code>sophia
-type number = int
-type string_map('a) = map(string, 'a)</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">type</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="kt">int</span><span class="w"></span>
+<span class="k">type</span><span class="w"> </span><span class="n">string_map</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="kt">map</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;a</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <p>A type alias and its definition can be used interchangeably. Sophia does not support
 higher-kinded types, meaning that following type alias is invalid: <code>type wrap('f, 'a) = 'f('a)</code></p>
 <h2 id="algebraic-data-types">Algebraic data types</h2>
 <p>Sophia supports algebraic data types (variant types) and pattern matching. Data
 types are declared by giving a list of constructors with
 their respective arguments. For instance,</p>
-<p><code>sophia
-datatype one_or_both('a, 'b) = Left('a) | Right('b) | Both('a, 'b)</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">datatype</span><span class="w"> </span><span class="n">one_or_both</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;b</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nf">Left</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">)</span><span class="w"> </span><span class="ow">|</span><span class="w"> </span><span class="nf">Right</span><span class="p">(</span><span class="nv">&#39;b</span><span class="p">)</span><span class="w"> </span><span class="ow">|</span><span class="w"> </span><span class="nf">Both</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;b</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <p>Elements of data types can be pattern matched against, using the <code>switch</code> construct:</p>
-<p><code>sophia
-function get_left(x : one_or_both('a, 'b)) : option('a) =
-  switch(x)
-    Left(x)    =&gt; Some(x)
-    Right(_)   =&gt; None
-    Both(x, _) =&gt; Some(x)</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">function</span><span class="w"> </span><span class="n">get_left</span><span class="p">(</span><span class="n">x</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="n">one_or_both</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;b</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">option</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">switch</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="nf">Left</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w">    </span><span class="ow">=&gt;</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="nf">Right</span><span class="p">(</span><span class="n">_</span><span class="p">)</span><span class="w">   </span><span class="ow">=&gt;</span><span class="w"> </span><span class="nf">None</span><span class="w"></span>
+<span class="w">    </span><span class="nf">Both</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">_</span><span class="p">)</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <p>or directly in the left-hand side:
-<code>sophia
-function
-  get_left : one_or_both('a, 'b) =&gt; option('a)
-  get_left(Left(x))    = Some(x)
-  get_left(Right(_))   = None
-  get_left(Both(x, _)) = Some(x)</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">function</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="n">one_or_both</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;b</span><span class="p">)</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="kt">option</span><span class="p">(</span><span class="nv">&#39;a</span><span class="p">)</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left</span><span class="p">(</span><span class="nf">Left</span><span class="p">(</span><span class="n">x</span><span class="p">))</span><span class="w">    </span><span class="ow">=</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left</span><span class="p">(</span><span class="nf">Right</span><span class="p">(</span><span class="n">_</span><span class="p">))</span><span class="w">   </span><span class="ow">=</span><span class="w"> </span><span class="nf">None</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left</span><span class="p">(</span><span class="nf">Both</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">_</span><span class="p">))</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+</code></pre></div></p>
 <p><em>NOTE: Data types cannot currently be recursive.</em></p>
 <p>Sophia also supports the assignment of patterns to variables:
-<code>``sophia
-function f(x) = switch(x)
-  h1::(t = h2::_) =&gt; (h1 + h2)::t  // same as</code>h1::h2::k =&gt; (h1 + h2)::h2::k`
-  _ =&gt; x</p>
-<p>function g(p : int * option(int)) : int =
-  let (a, (o = Some(b))) = p  // o is equal to Pair.snd(p)
-  b
-```</p>
+<div class="highlight"><pre><span></span><code><span class="k">function</span><span class="w"> </span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="k">switch</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">  </span><span class="n">h1</span><span class="ow">::</span><span class="p">(</span><span class="n">t</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">h2</span><span class="ow">::</span><span class="n">_</span><span class="p">)</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="p">(</span><span class="n">h1</span><span class="w"> </span><span class="ow">+</span><span class="w"> </span><span class="n">h2</span><span class="p">)</span><span class="ow">::</span><span class="n">t</span><span class="w">  </span><span class="c1">// same as `h1::h2::k =&gt; (h1 + h2)::h2::k`</span>
+<span class="w">  </span><span class="n">_</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="n">x</span><span class="w"></span>
+
+<span class="k">function</span><span class="w"> </span><span class="n">g</span><span class="p">(</span><span class="n">p</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="ow">*</span><span class="w"> </span><span class="kt">option</span><span class="p">(</span><span class="kt">int</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">let</span><span class="w"> </span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="n">o</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">b</span><span class="p">)))</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">p</span><span class="w">  </span><span class="c1">// o is equal to Pair.snd(p)</span>
+<span class="w">  </span><span class="n">b</span><span class="w"></span>
+</code></pre></div></p>
 <p>Guards are boolean expressions that can be used on patterns in both switch
 statements and functions definitions. If a guard expression evaluates to
 <code>true</code>, then the corresponding body will be used. Otherwise, the next pattern
 will be checked:</p>
-<p><code>sophia
-function get_left_if_positive(x : one_or_both(int, 'b)) : option(int) =
-  switch(x)
-    Left(x)    | x &gt; 0 =&gt; Some(x)
-    Both(x, _) | x &gt; 0 =&gt; Some(x)
-    _                  =&gt; None</code></p>
-<p><code>sophia
-function
-  get_left_if_positive : one_or_both(int, 'b) =&gt; option(int)
-  get_left_if_positive(Left(x))    | x &gt; 0 = Some(x)
-  get_left_if_positive(Both(x, _)) | x &gt; 0 = Some(x)
-  get_left_if_positive(_)                  = None</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">function</span><span class="w"> </span><span class="n">get_left_if_positive</span><span class="p">(</span><span class="n">x</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="n">one_or_both</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;b</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">option</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="k">switch</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="nf">Left</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w">    </span><span class="ow">|</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="nf">Both</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">_</span><span class="p">)</span><span class="w"> </span><span class="ow">|</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="n">_</span><span class="w">                  </span><span class="ow">=&gt;</span><span class="w"> </span><span class="nf">None</span><span class="w"></span>
+</code></pre></div>
+<div class="highlight"><pre><span></span><code><span class="k">function</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left_if_positive</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="n">one_or_both</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="nv">&#39;b</span><span class="p">)</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="kt">option</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left_if_positive</span><span class="p">(</span><span class="nf">Left</span><span class="p">(</span><span class="n">x</span><span class="p">))</span><span class="w">    </span><span class="ow">|</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left_if_positive</span><span class="p">(</span><span class="nf">Both</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">_</span><span class="p">))</span><span class="w"> </span><span class="ow">|</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="w"></span>
+<span class="w">  </span><span class="n">get_left_if_positive</span><span class="p">(</span><span class="n">_</span><span class="p">)</span><span class="w">                  </span><span class="ow">=</span><span class="w"> </span><span class="nf">None</span><span class="w"></span>
+</code></pre></div>
 <p>Guards cannot be stateful even when used inside a stateful function.</p>
 <h2 id="lists">Lists</h2>
 <p>A Sophia list is a dynamically sized, homogenous, immutable, singly
@@ -1557,10 +1580,10 @@ linked list. A list is constructed with the syntax <code>[1, 2, 3]</code>. The
 elements of a list can be any of datatype but they must have the same
 type. The type of lists with elements of type <code>'e</code> is written
 <code>list('e)</code>. For example we can have the following lists:</p>
-<p><code>sophia
-[1, 33, 2, 666]                                                   : list(int)
-[(1, "aaa"), (10, "jjj"), (666, "the beast")]                     : list(int * string)
-[{[1] = "aaa", [10] = "jjj"}, {[5] = "eee", [666] = "the beast"}] : list(map(int, string))</code></p>
+<div class="highlight"><pre><span></span><code><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mi">33</span><span class="p">,</span><span class="w"> </span><span class="mi">2</span><span class="p">,</span><span class="w"> </span><span class="mi">666</span><span class="p">]</span><span class="w">                                                   </span><span class="ow">:</span><span class="w"> </span><span class="kt">list</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="w"></span>
+<span class="p">[(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="s2">&quot;aaa&quot;</span><span class="p">),</span><span class="w"> </span><span class="p">(</span><span class="mi">10</span><span class="p">,</span><span class="w"> </span><span class="s2">&quot;jjj&quot;</span><span class="p">),</span><span class="w"> </span><span class="p">(</span><span class="mi">666</span><span class="p">,</span><span class="w"> </span><span class="s2">&quot;the beast&quot;</span><span class="p">)]</span><span class="w">                     </span><span class="ow">:</span><span class="w"> </span><span class="kt">list</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="ow">*</span><span class="w"> </span><span class="kt">string</span><span class="p">)</span><span class="w"></span>
+<span class="p">[{[</span><span class="mi">1</span><span class="p">]</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="s2">&quot;aaa&quot;</span><span class="p">,</span><span class="w"> </span><span class="p">[</span><span class="mi">10</span><span class="p">]</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="s2">&quot;jjj&quot;</span><span class="p">},</span><span class="w"> </span><span class="p">{[</span><span class="mi">5</span><span class="p">]</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="s2">&quot;eee&quot;</span><span class="p">,</span><span class="w"> </span><span class="p">[</span><span class="mi">666</span><span class="p">]</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="s2">&quot;the beast&quot;</span><span class="p">}]</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">list</span><span class="p">(</span><span class="kt">map</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="kt">string</span><span class="p">))</span><span class="w"></span>
+</code></pre></div>
 <p>New elements can be prepended to the front of a list with the <code>::</code>
 operator. So <code>42 :: [1, 2, 3]</code> returns the list <code>[42, 1, 2, 3]</code>. The
 concatenation operator <code>++</code> appends its second argument to its first
@@ -1568,21 +1591,21 @@ and returns the resulting list. So concatenating two lists
 <code>[1, 22, 33] ++ [10, 18, 55]</code> returns the list <code>[1, 22, 33, 10, 18, 55]</code>.</p>
 <p>Sophia supports list comprehensions known from languages like Python, Haskell or Erlang.
 Example syntax:
-<code>sophia
-[x + y | x &lt;- [1,2,3,4,5], let k = x*x, if (k &gt; 5), y &lt;- [k, k+1, k+2]]
-// yields [12,13,14,20,21,22,30,31,32]</code></p>
+<div class="highlight"><pre><span></span><code><span class="p">[</span><span class="n">x</span><span class="w"> </span><span class="ow">+</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="ow">|</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="ow">&lt;-</span><span class="w"> </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="w"> </span><span class="k">let</span><span class="w"> </span><span class="n">k</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">x</span><span class="ow">*</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">k</span><span class="w"> </span><span class="ow">&gt;</span><span class="w"> </span><span class="mi">5</span><span class="p">),</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="ow">&lt;-</span><span class="w"> </span><span class="p">[</span><span class="n">k</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="ow">+</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">k</span><span class="ow">+</span><span class="mi">2</span><span class="p">]]</span><span class="w"></span>
+<span class="c1">// yields [12,13,14,20,21,22,30,31,32]</span>
+</code></pre></div></p>
 <p>Lists can be constructed using the range syntax using special <code>..</code> operator:
-<code>sophia
-[1..4] == [1,2,3,4]</code>
+<div class="highlight"><pre><span></span><code><span class="p">[</span><span class="mi">1</span><span class="p">..</span><span class="mi">4</span><span class="p">]</span><span class="w"> </span><span class="ow">==</span><span class="w"> </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="w"></span>
+</code></pre></div>
 The ranges are always ascending and have step equal to 1.</p>
 <p>Please refer to the <a href="../sophia_stdlib/#list">standard library</a> for the predefined functionalities.</p>
 <h2 id="maps-and-records">Maps and records</h2>
 <p>A Sophia record type is given by a fixed set of fields with associated,
 possibly different, types. For instance
-<code>sophia
-  record account = { name    : string,
-                     balance : int,
-                     history : list(transaction) }</code></p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">record</span><span class="w"> </span><span class="n">account</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">name</span><span class="w">    </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">,</span><span class="w"></span>
+<span class="w">                     </span><span class="n">balance</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">,</span><span class="w"></span>
+<span class="w">                     </span><span class="n">history</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">list</span><span class="p">(</span><span class="n">transaction</span><span class="p">)</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
+</code></pre></div></p>
 <p>Maps, on the other hand, can contain an arbitrary number of key-value bindings,
 but of a fixed type. The type of maps with keys of type <code>'k</code> and values of type
 <code>'v</code> is written <code>map('k, 'v)</code>. The key type can be any type that does not
@@ -1591,19 +1614,19 @@ contain a map or a function type.</p>
 <h3 id="constructing-maps-and-records">Constructing maps and records</h3>
 <p>A value of record type is constructed by giving a value for each of the fields.
 For the example above,
-<code>sophia
-  function new_account(name) =
-    {name = name, balance = 0, history = []}</code>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">function</span><span class="w"> </span><span class="n">new_account</span><span class="p">(</span><span class="n">name</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="p">{</span><span class="n">name</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">balance</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">history</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="p">[]}</span><span class="w"></span>
+</code></pre></div>
 Maps are constructed similarly, with keys enclosed in square brackets
-<code>sophia
-  function example_map() : map(string, int) =
-    {["key1"] = 1, ["key2"] = 2}</code>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">function</span><span class="w"> </span><span class="n">example_map</span><span class="p">()</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">map</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="p">{[</span><span class="s2">&quot;key1&quot;</span><span class="p">]</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="p">[</span><span class="s2">&quot;key2&quot;</span><span class="p">]</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="mi">2</span><span class="p">}</span><span class="w"></span>
+</code></pre></div>
 The empty map is written <code>{}</code>.</p>
 <h3 id="accessing-values">Accessing values</h3>
 <p>Record fields access is written <code>r.f</code> and map lookup <code>m[k]</code>. For instance,
-<code>sophia
-  function get_balance(a : address, accounts : map(address, account)) =
-    accounts[a].balance</code>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">function</span><span class="w"> </span><span class="n">get_balance</span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">accounts</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">map</span><span class="p">(</span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">account</span><span class="p">))</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="n">accounts</span><span class="p">[</span><span class="n">a</span><span class="p">].</span><span class="n">balance</span><span class="w"></span>
+</code></pre></div>
 Looking up a non-existing key in a map results in contract execution failing. A
 default value to return for non-existing keys can be provided using the syntax
 <code>m[k = default]</code>. See also <code>Map.member</code> and <code>Map.lookup</code> below.</p>
@@ -1621,14 +1644,14 @@ in the map or execution fails, but a default value can be provided:
 <code>m{ [k = default] @ x = v }</code>. In this case <code>x</code> is bound to <code>default</code> if
 <code>k</code> is not in the map.</p>
 <p>Updates can be nested:
-<code>sophia
-function clear_history(a : address, accounts : map(address, account)) : map(address, account) =
-  accounts{ [a].history = [] }</code>
+<div class="highlight"><pre><span></span><code><span class="k">function</span><span class="w"> </span><span class="n">clear_history</span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">accounts</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">map</span><span class="p">(</span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">account</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">map</span><span class="p">(</span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">account</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">  </span><span class="n">accounts</span><span class="p">{</span><span class="w"> </span><span class="p">[</span><span class="n">a</span><span class="p">].</span><span class="n">history</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="p">[]</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
+</code></pre></div>
 This is equivalent to <code>accounts{ [a] @ acc = acc{ history = [] } }</code> and thus
 requires <code>a</code> to be present in the accounts map. To have <code>clear_history</code> create
 an account if <code>a</code> is not in the map you can write (given a function <code>empty_account</code>):
-<code>sophia
-  accounts{ [a = empty_account()].history = [] }</code></p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="n">accounts</span><span class="p">{</span><span class="w"> </span><span class="p">[</span><span class="n">a</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">empty_account</span><span class="p">()].</span><span class="n">history</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="p">[]</span><span class="w"> </span><span class="p">}</span><span class="w"></span>
+</code></pre></div></p>
 <h3 id="map-implementation">Map implementation</h3>
 <p>Internally in the VM maps are implemented as hash maps and support fast lookup
 and update. Large maps can be stored in the contract state and the size of the
@@ -1667,46 +1690,54 @@ through the Oracle interface.</p>
 For a functionality documentation refer to the <a href="../sophia_stdlib/#oracle">standard library</a>.</p>
 <h3 id="example">Example</h3>
 <p>Example for an oracle answering questions of type <code>string</code> with answers of type <code>int</code>:
-```sophia
-contract Oracles =</p>
-<p>stateful entrypoint registerOracle(acct : address,
-                                     sign : signature,   // Signed network id + oracle address + contract address
-                                     qfee : int,
-                                     ttl  : Chain.ttl) : oracle(string, int) =
-     Oracle.register(acct, signature = sign, qfee, ttl)</p>
-<p>entrypoint queryFee(o : oracle(string, int)) : int =
-    Oracle.query_fee(o)</p>
-<p>payable stateful entrypoint createQuery(o    : oracle_query(string, int),
-                                          q    : string,
-                                          qfee : int,
-                                          qttl : Chain.ttl,
-                                          rttl : int) : oracle_query(string, int) =
-    require(qfee =&lt; Call.value, "insufficient value for qfee")
-    Oracle.query(o, q, qfee, qttl, RelativeTTL(rttl))</p>
-<p>stateful entrypoint extendOracle(o   : oracle(string, int),
-                                   ttl : Chain.ttl) : unit =
-    Oracle.extend(o, ttl)</p>
-<p>stateful entrypoint signExtendOracle(o    : oracle(string, int),
-                                       sign : signature,   // Signed network id + oracle address + contract address
-                                       ttl  : Chain.ttl) : unit =
-    Oracle.extend(o, signature = sign, ttl)</p>
-<p>stateful entrypoint respond(o    : oracle(string, int),
-                              q    : oracle_query(string, int),
-                              sign : signature,        // Signed network id + oracle query id + contract address
-                              r    : int) =
-    Oracle.respond(o, q, signature = sign, r)</p>
-<p>entrypoint getQuestion(o : oracle(string, int),
-                         q : oracle_query(string, int)) : string =
-    Oracle.get_question(o, q)</p>
-<p>entrypoint hasAnswer(o : oracle(string, int),
-                       q : oracle_query(string, int)) =
-    switch(Oracle.get_answer(o, q))
-      None    =&gt; false
-      Some(_) =&gt; true</p>
-<p>entrypoint getAnswer(o : oracle(string, int),
-                       q : oracle_query(string, int)) : option(int) =
-    Oracle.get_answer(o, q)
-```</p>
+<div class="highlight"><pre><span></span><code><span class="k">contract</span><span class="w"> </span><span class="nf">Oracles</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">registerOracle</span><span class="p">(</span><span class="n">acct</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">address</span><span class="p">,</span><span class="w"></span>
+<span class="w">                                     </span><span class="n">sign</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">signature</span><span class="p">,</span><span class="w">   </span><span class="c1">// Signed network id + oracle address + contract address</span>
+<span class="w">                                     </span><span class="n">qfee</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">,</span><span class="w"></span>
+<span class="w">                                     </span><span class="n">ttl</span><span class="w">  </span><span class="ow">:</span><span class="w"> </span><span class="nc">Chain</span><span class="p">.</span><span class="n">ttl</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">     </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">register</span><span class="p">(</span><span class="n">acct</span><span class="p">,</span><span class="w"> </span><span class="kt">signature</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">sign</span><span class="p">,</span><span class="w"> </span><span class="n">qfee</span><span class="p">,</span><span class="w"> </span><span class="n">ttl</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">queryFee</span><span class="p">(</span><span class="n">o</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">query_fee</span><span class="p">(</span><span class="n">o</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">payable</span><span class="w"> </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">createQuery</span><span class="p">(</span><span class="n">o</span><span class="w">    </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle_query</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                                          </span><span class="n">q</span><span class="w">    </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">,</span><span class="w"></span>
+<span class="w">                                          </span><span class="n">qfee</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">,</span><span class="w"></span>
+<span class="w">                                          </span><span class="n">qttl</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nc">Chain</span><span class="p">.</span><span class="n">ttl</span><span class="p">,</span><span class="w"></span>
+<span class="w">                                          </span><span class="n">rttl</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle_query</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nb">require</span><span class="p">(</span><span class="n">qfee</span><span class="w"> </span><span class="ow">=&lt;</span><span class="w"> </span><span class="nc">Call</span><span class="p">.</span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="s2">&quot;insufficient value for qfee&quot;</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">query</span><span class="p">(</span><span class="n">o</span><span class="p">,</span><span class="w"> </span><span class="n">q</span><span class="p">,</span><span class="w"> </span><span class="n">qfee</span><span class="p">,</span><span class="w"> </span><span class="n">qttl</span><span class="p">,</span><span class="w"> </span><span class="nf">RelativeTTL</span><span class="p">(</span><span class="n">rttl</span><span class="p">))</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">extendOracle</span><span class="p">(</span><span class="n">o</span><span class="w">   </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                                   </span><span class="n">ttl</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nc">Chain</span><span class="p">.</span><span class="n">ttl</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">unit</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">extend</span><span class="p">(</span><span class="n">o</span><span class="p">,</span><span class="w"> </span><span class="n">ttl</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">signExtendOracle</span><span class="p">(</span><span class="n">o</span><span class="w">    </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                                       </span><span class="n">sign</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">signature</span><span class="p">,</span><span class="w">   </span><span class="c1">// Signed network id + oracle address + contract address</span>
+<span class="w">                                       </span><span class="n">ttl</span><span class="w">  </span><span class="ow">:</span><span class="w"> </span><span class="nc">Chain</span><span class="p">.</span><span class="n">ttl</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">unit</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">extend</span><span class="p">(</span><span class="n">o</span><span class="p">,</span><span class="w"> </span><span class="kt">signature</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">sign</span><span class="p">,</span><span class="w"> </span><span class="n">ttl</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">respond</span><span class="p">(</span><span class="n">o</span><span class="w">    </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                              </span><span class="n">q</span><span class="w">    </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle_query</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                              </span><span class="n">sign</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">signature</span><span class="p">,</span><span class="w">        </span><span class="c1">// Signed network id + oracle query id + contract address</span>
+<span class="w">                              </span><span class="n">r</span><span class="w">    </span><span class="ow">:</span><span class="w"> </span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">respond</span><span class="p">(</span><span class="n">o</span><span class="p">,</span><span class="w"> </span><span class="n">q</span><span class="p">,</span><span class="w"> </span><span class="kt">signature</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">sign</span><span class="p">,</span><span class="w"> </span><span class="n">r</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">getQuestion</span><span class="p">(</span><span class="n">o</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                         </span><span class="n">q</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle_query</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">get_question</span><span class="p">(</span><span class="n">o</span><span class="p">,</span><span class="w"> </span><span class="n">q</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">hasAnswer</span><span class="p">(</span><span class="n">o</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                       </span><span class="n">q</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle_query</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">))</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="k">switch</span><span class="p">(</span><span class="nc">Oracle</span><span class="p">.</span><span class="n">get_answer</span><span class="p">(</span><span class="n">o</span><span class="p">,</span><span class="w"> </span><span class="n">q</span><span class="p">))</span><span class="w"></span>
+<span class="w">      </span><span class="nf">None</span><span class="w">    </span><span class="ow">=&gt;</span><span class="w"> </span><span class="kc">false</span><span class="w"></span>
+<span class="w">      </span><span class="nf">Some</span><span class="p">(</span><span class="n">_</span><span class="p">)</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="kc">true</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">getAnswer</span><span class="p">(</span><span class="n">o</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">),</span><span class="w"></span>
+<span class="w">                       </span><span class="n">q</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">oracle_query</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">))</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">option</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Oracle</span><span class="p">.</span><span class="n">get_answer</span><span class="p">(</span><span class="n">o</span><span class="p">,</span><span class="w"> </span><span class="n">q</span><span class="p">)</span><span class="w"></span>
+</code></pre></div></p>
 <h3 id="sanity-checks">Sanity checks</h3>
 <p>When an Oracle literal is passed to a contract, no deep checks are performed.
 For extra safety <a href="../sophia_stdlib/#check">Oracle.check</a> and <a href="../sophia_stdlib/#check_query">Oracle.check_query</a>
@@ -1722,30 +1753,30 @@ an account with address <code>addr</code>. In order to allow a contract <code>ct
 <a href="#delegation-signature">signature</a> <code>sig</code> of <code>addr | name.hash | ct.address</code>.</p>
 <p>Armed with this information we can for example write a function that extends
 the name if it expires within 1000 blocks:
-<code>sophia
-  stateful entrypoint extend_if_necessary(addr : address, name : string, sig : signature) =
-    switch(AENS.lookup(name))
-      None =&gt; ()
-      Some(AENS.Name(_, FixedTTL(expiry), _)) =&gt;
-        if(Chain.block_height + 1000 &gt; expiry)
-          AENS.update(addr, name, Some(RelativeTTL(50000)), None, None, signature = sig)</code></p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">extend_if_necessary</span><span class="p">(</span><span class="n">addr</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="n">sig</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">signature</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="k">switch</span><span class="p">(</span><span class="nc">AENS</span><span class="p">.</span><span class="n">lookup</span><span class="p">(</span><span class="n">name</span><span class="p">))</span><span class="w"></span>
+<span class="w">      </span><span class="nf">None</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="p">()</span><span class="w"></span>
+<span class="w">      </span><span class="nf">Some</span><span class="p">(</span><span class="nc">AENS</span><span class="p">.</span><span class="nf">Name</span><span class="p">(</span><span class="n">_</span><span class="p">,</span><span class="w"> </span><span class="nf">FixedTTL</span><span class="p">(</span><span class="n">expiry</span><span class="p">),</span><span class="w"> </span><span class="n">_</span><span class="p">))</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"></span>
+<span class="w">        </span><span class="k">if</span><span class="p">(</span><span class="nc">Chain</span><span class="p">.</span><span class="n">block_height</span><span class="w"> </span><span class="ow">+</span><span class="w"> </span><span class="mi">1000</span><span class="w"> </span><span class="ow">&gt;</span><span class="w"> </span><span class="n">expiry</span><span class="p">)</span><span class="w"></span>
+<span class="w">          </span><span class="nc">AENS</span><span class="p">.</span><span class="n">update</span><span class="p">(</span><span class="n">addr</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="nf">RelativeTTL</span><span class="p">(</span><span class="mi">50000</span><span class="p">)),</span><span class="w"> </span><span class="nf">None</span><span class="p">,</span><span class="w"> </span><span class="nf">None</span><span class="p">,</span><span class="w"> </span><span class="kt">signature</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">sig</span><span class="p">)</span><span class="w"></span>
+</code></pre></div></p>
 <p>And we can write functions that adds and removes keys from the pointers of the
 name:
-```sophia
-  stateful entrypoint add_key(addr : address, name : string, key : string,
-                              pt : AENS.pointee, sig : signature) =
-    switch(AENS.lookup(name))
-      None =&gt; ()
-      Some(AENS.Name(<em>, </em>, ptrs)) =&gt;
-        AENS.update(addr, name, None, None, Some(ptrs{[key] = pt}), signature = sig)</p>
-<p>stateful entrypoint delete_key(addr : address, name : string,
-                                 key : string, sig : signature) =
-    switch(AENS.lookup(name))
-      None =&gt; ()
-      Some(AENS.Name(<em>, </em>, ptrs)) =&gt;
-        let ptrs = Map.delete(key, ptrs)
-        AENS.update(addr, name, None, None, Some(ptrs), signature = sig)
-```</p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">add_key</span><span class="p">(</span><span class="n">addr</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">,</span><span class="w"></span>
+<span class="w">                              </span><span class="n">pt</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nc">AENS</span><span class="p">.</span><span class="n">pointee</span><span class="p">,</span><span class="w"> </span><span class="n">sig</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">signature</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="k">switch</span><span class="p">(</span><span class="nc">AENS</span><span class="p">.</span><span class="n">lookup</span><span class="p">(</span><span class="n">name</span><span class="p">))</span><span class="w"></span>
+<span class="w">      </span><span class="nf">None</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="p">()</span><span class="w"></span>
+<span class="w">      </span><span class="nf">Some</span><span class="p">(</span><span class="nc">AENS</span><span class="p">.</span><span class="nf">Name</span><span class="p">(</span><span class="n">_</span><span class="p">,</span><span class="w"> </span><span class="n">_</span><span class="p">,</span><span class="w"> </span><span class="n">ptrs</span><span class="p">))</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"></span>
+<span class="w">        </span><span class="nc">AENS</span><span class="p">.</span><span class="n">update</span><span class="p">(</span><span class="n">addr</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="nf">None</span><span class="p">,</span><span class="w"> </span><span class="nf">None</span><span class="p">,</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">ptrs</span><span class="p">{[</span><span class="n">key</span><span class="p">]</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">pt</span><span class="p">}),</span><span class="w"> </span><span class="kt">signature</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">sig</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="k">stateful</span><span class="w"> </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">delete_key</span><span class="p">(</span><span class="n">addr</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">address</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">,</span><span class="w"></span>
+<span class="w">                                 </span><span class="n">key</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="n">sig</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">signature</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="k">switch</span><span class="p">(</span><span class="nc">AENS</span><span class="p">.</span><span class="n">lookup</span><span class="p">(</span><span class="n">name</span><span class="p">))</span><span class="w"></span>
+<span class="w">      </span><span class="nf">None</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"> </span><span class="p">()</span><span class="w"></span>
+<span class="w">      </span><span class="nf">Some</span><span class="p">(</span><span class="nc">AENS</span><span class="p">.</span><span class="nf">Name</span><span class="p">(</span><span class="n">_</span><span class="p">,</span><span class="w"> </span><span class="n">_</span><span class="p">,</span><span class="w"> </span><span class="n">ptrs</span><span class="p">))</span><span class="w"> </span><span class="ow">=&gt;</span><span class="w"></span>
+<span class="w">        </span><span class="k">let</span><span class="w"> </span><span class="n">ptrs</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="nc">Map</span><span class="p">.</span><span class="n">delete</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">ptrs</span><span class="p">)</span><span class="w"></span>
+<span class="w">        </span><span class="nc">AENS</span><span class="p">.</span><span class="n">update</span><span class="p">(</span><span class="n">addr</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="nf">None</span><span class="p">,</span><span class="w"> </span><span class="nf">None</span><span class="p">,</span><span class="w"> </span><span class="nf">Some</span><span class="p">(</span><span class="n">ptrs</span><span class="p">),</span><span class="w"> </span><span class="kt">signature</span><span class="w"> </span><span class="ow">=</span><span class="w"> </span><span class="n">sig</span><span class="p">)</span><span class="w"></span>
+</code></pre></div></p>
 <p><em>Note:</em> From the Iris hardfork more strict rules apply for AENS pointers, when
 a Sophia contract lookup or update (bad) legacy pointers, the bad keys are
 automatically removed so they will not appear in the pointers map.</p>
@@ -1756,12 +1787,12 @@ Solidity</a>.
 Events are further discussed in the <a href="https://github.com/aeternity/protocol/blob/master/contracts/events.md">protocol</a>.</p>
 <p>To use events a contract must declare a datatype <code>event</code>, and events are then
 logged using the <code>Chain.event</code> function:</p>
-<p>```sophia
-  datatype event
-    = Event1(int, int, string)
-    | Event2(string, address)</p>
-<p>Chain.event(e : event) : unit
-```</p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">datatype</span><span class="w"> </span><span class="kt">event</span><span class="w"></span>
+<span class="w">    </span><span class="ow">=</span><span class="w"> </span><span class="nf">Event1</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="kt">string</span><span class="p">)</span><span class="w"></span>
+<span class="w">    </span><span class="ow">|</span><span class="w"> </span><span class="nf">Event2</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="kt">address</span><span class="p">)</span><span class="w"></span>
+
+<span class="w">  </span><span class="nc">Chain</span><span class="p">.</span><span class="n">event</span><span class="p">(</span><span class="n">e</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">event</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">unit</span><span class="w"></span>
+</code></pre></div>
 <p>The event can have 0-3 <em>indexed</em> fields, and an optional <em>payload</em> field. A
 field is indexed if it fits in a 32-byte word, i.e.
 - <code>bool</code>
@@ -1777,43 +1808,44 @@ The fields can appear in any order.</p>
 <p><em>NOTE:</em> Indexing is not part of the core æternity node.</p>
 <p>Events are emitted by using the <code>Chain.event</code> function. The following function
 will emit one Event of each kind in the example.</p>
-<p><code>sophia
-  entrypoint emit_events() : () =
-    Chain.event(Event1(42, 34, "foo"))
-    Chain.event(Event2("This is not indexed", Contract.address))</code></p>
+<div class="highlight"><pre><span></span><code><span class="w">  </span><span class="k">entrypoint</span><span class="w"> </span><span class="n">emit_events</span><span class="p">()</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="p">()</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Chain</span><span class="p">.</span><span class="n">event</span><span class="p">(</span><span class="nf">Event1</span><span class="p">(</span><span class="mi">42</span><span class="p">,</span><span class="w"> </span><span class="mi">34</span><span class="p">,</span><span class="w"> </span><span class="s2">&quot;foo&quot;</span><span class="p">))</span><span class="w"></span>
+<span class="w">    </span><span class="nc">Chain</span><span class="p">.</span><span class="n">event</span><span class="p">(</span><span class="nf">Event2</span><span class="p">(</span><span class="s2">&quot;This is not indexed&quot;</span><span class="p">,</span><span class="w"> </span><span class="nc">Contract</span><span class="p">.</span><span class="n">address</span><span class="p">))</span><span class="w"></span>
+</code></pre></div>
 <h3 id="argument-order">Argument order</h3>
 <p>It is only possible to have one (1) <code>string</code> parameter in the event, but it can
 be placed in any position (and its value will end up in the <code>data</code> field), i.e.
-```sophia
-AnotherEvent(string, indexed address)</p>
-<p>...</p>
-<p>Chain.event(AnotherEvent("This is not indexed", Contract.address))
-```
+<div class="highlight"><pre><span></span><code><span class="nf">AnotherEvent</span><span class="p">(</span><span class="kt">string</span><span class="p">,</span><span class="w"> </span><span class="k">indexed</span><span class="w"> </span><span class="kt">address</span><span class="p">)</span><span class="w"></span>
+
+<span class="p">...</span><span class="w"></span>
+
+<span class="nc">Chain</span><span class="p">.</span><span class="n">event</span><span class="p">(</span><span class="nf">AnotherEvent</span><span class="p">(</span><span class="s2">&quot;This is not indexed&quot;</span><span class="p">,</span><span class="w"> </span><span class="nc">Contract</span><span class="p">.</span><span class="n">address</span><span class="p">))</span><span class="w"></span>
+</code></pre></div>
 would yield exactly the same result in the example above!</p>
 <h2 id="compiler-pragmas">Compiler pragmas</h2>
 <p>To enforce that a contract is only compiled with specific versions of the
 Sophia compiler, you can give one or more <code>@compiler</code> pragmas at the
 top-level (typically at the beginning) of a file. For instance, to enforce that
 a contract is compiled with version 4.3 of the compiler you write</p>
-<p><code>sophia
-@compiler &gt;= 4.3
-@compiler &lt;  4.4</code></p>
+<div class="highlight"><pre><span></span><code><span class="ow">@</span><span class="n">compiler</span><span class="w"> </span><span class="ow">&gt;=</span><span class="w"> </span><span class="mi">4</span><span class="p">.</span><span class="mi">3</span><span class="w"></span>
+<span class="ow">@</span><span class="n">compiler</span><span class="w"> </span><span class="ow">&lt;</span><span class="w">  </span><span class="mi">4</span><span class="p">.</span><span class="mi">4</span><span class="w"></span>
+</code></pre></div>
 <p>Valid operators in compiler pragmas are <code>&lt;</code>, <code>=&lt;</code>, <code>==</code>, <code>&gt;=</code>, and <code>&gt;</code>. Version
 numbers are given as a sequence of non-negative integers separated by dots.
 Trailing zeros are ignored, so <code>4.0.0 == 4</code>. If a constraint is violated an
 error is reported and compilation fails.</p>
 <h2 id="exceptions">Exceptions</h2>
 <p>Contracts can fail with an (uncatchable) exception using the built-in function</p>
-<p><code>sophia
-abort(reason : string) : 'a</code></p>
+<div class="highlight"><pre><span></span><code><span class="nb">abort</span><span class="p">(</span><span class="n">reason</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">)</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="nv">&#39;a</span><span class="w"></span>
+</code></pre></div>
 <p>Calling abort causes the top-level call transaction to return an error result
 containing the <code>reason</code> string. Only the gas used up to and including the abort
 call is charged. This is different from termination due to a crash which
 consumes all available gas.</p>
 <p>For convenience the following function is also built-in:</p>
-<p><code>sophia
-function require(b : bool, err : string) =
-    if(!b) abort(err)</code></p>
+<div class="highlight"><pre><span></span><code><span class="k">function</span><span class="w"> </span><span class="nb">require</span><span class="p">(</span><span class="n">b</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">bool</span><span class="p">,</span><span class="w"> </span><span class="n">err</span><span class="w"> </span><span class="ow">:</span><span class="w"> </span><span class="kt">string</span><span class="p">)</span><span class="w"> </span><span class="ow">=</span><span class="w"></span>
+<span class="w">    </span><span class="k">if</span><span class="p">(</span><span class="ow">!</span><span class="n">b</span><span class="p">)</span><span class="w"> </span><span class="nb">abort</span><span class="p">(</span><span class="n">err</span><span class="p">)</span><span class="w"></span>
+</code></pre></div>
 <h2 id="delegation-signature">Delegation signature</h2>
 <p>Some chain operations (<code>Oracle.&lt;operation&gt;</code> and <code>AENS.&lt;operation&gt;</code>) have an
 optional delegation signature. This is typically used when a user/accounts
@@ -1875,10 +1907,12 @@ the signature data with the <code>network_id</code> (<code>ae_mainnet</code> for
    <div class="md-footer-meta__inner md-grid">
      <div class="md-footer-copyright">
        
-        Made with
-        <a href="https://squidfunk.github.io/mkdocs-material/" target="_blank" rel="noopener">
-          Material for MkDocs
-        </a>
+        
+          Made with
+          <a href="https://squidfunk.github.io/mkdocs-material/" target="_blank" rel="noopener">
+            Material for MkDocs
+          </a>
+        
        
      </div>
      
@@ -1890,10 +1924,10 @@ the signature data with the <code>network_id</code> (<code>ae_mainnet</code> for
    <div class="md-dialog" data-md-component="dialog">
      <div class="md-dialog__inner md-typeset"></div>
    </div>
-    <script id="__config" type="application/json">{"base": "..", "features": ["content.tabs.link", "search.highlight", "search.share", "search.suggest"], "translations": {"clipboard.copy": "Copy to clipboard", "clipboard.copied": "Copied to clipboard", "search.config.lang": "en", "search.config.pipeline": "trimmer, stopWordFilter", "search.config.separator": "[\\s\\-]+", "search.placeholder": "Search", "search.result.placeholder": "Type to start searching", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.term.missing": "Missing", "select.version.title": "Select version"}, "search": "../assets/javascripts/workers/search.477d984a.min.js", "version": {"provider": "mike"}}</script>
+    <script id="__config" type="application/json">{"base": "..", "features": ["content.tabs.link", "search.highlight", "search.share", "search.suggest"], "translations": {"clipboard.copy": "Copy to clipboard", "clipboard.copied": "Copied to clipboard", "search.config.lang": "en", "search.config.pipeline": "trimmer, stopWordFilter", "search.config.separator": "[\\s\\-]+", "search.placeholder": "Search", "search.result.placeholder": "Type to start searching", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.term.missing": "Missing", "select.version.title": "Select version"}, "search": "../assets/javascripts/workers/search.fcfe8b6d.min.js", "version": {"provider": "mike"}}</script>
    
    
-      <script src="../assets/javascripts/bundle.82b56eb2.min.js"></script>
+      <script src="../assets/javascripts/bundle.b1047164.min.js"></script>
      
    
  </body>