Everyone knows HTML, but new programmers are often intimidated by JavaScript and its code-looking syntax. Unfortunately, HTML does not have scripting abilities of its own. Until now!
HyperText Markup Script provides a way to express computations using just HTML. It even provides full interoperability with JavaScript code for a smooth transition when you feel ready to use a "real" language.
- Include the
htms.min.jsscript on the page - Create your root
<htms></htms>element - Write your code!
The formal syntax of the language is exactly the same as HTML, though the tags have slightly different meanings.
The root HTMS node defines where to start running your HTMS code. All exported
values will be placed in a global JavaScript object with the name given by the
name attribute. (i.e. some_name, or window.some_name).
The final value of the <htms> node is automatically exported with the name
default.
<HTMS>
<!-- your program here -->
</HTMS>Provides no special purpose other than to execute its children in order. It can
be used to turn variables into strings and numbers (see <q> and <i>).
<span>
<!-- some block of code -->
</span>Assigns the final value of its children to the variable given by the name attribute. This variable can then be referenced later by its name.
Note that there are a few built in identifiers which cannot be used as variable
names, namely true, false, and $_. These correspond to the Boolean true
and false values, and the "previous value".
$_ is often used internally, and so you should not need to reference it, but
you can. $_ always holds the value of the previously executed node in the
current block. When no nodes have yet been run in the current block, the value
of $_ is null. This is the only way to obtain the null value, which may be
useful at times.
<!-- string = "Hello world" -->
<var name="string"><q>Hello world</q></var>
<span>
<!-- some code -->
string
</span> <!-- evaluates to "Hello world" -->Turns its final value into a string. If it is a text node, the text is used literally. Otherwise, it is the return value of evaluating the final element.
<var name="x"><i>3</i></var>
<q>Hello world</q> <!-- String: "Hello world" -->
<q>x</q> <!-- String: "x" -->
<q><span>x</span></q> <!-- String: "3" -->Similar to <q> but for numbers.
<var name="x"><q>5</q></var>
<i>3</i> <!-- Number: 3 -->
<i>x</i> <!-- Number: NaN -->
<i><span>x</span></i> <!-- Number: 5 -->Similar to <q> but for Booleans.
<var name="x"><q>0</q></var>
<b>3</b> <!-- Boolean: true -->
<b>0</b> <!-- Boolean: false -->
<b>false</b> <!-- Boolean: false -->
<b>true</b> <!-- Boolean: true -->
<b><q>false</q></b> <!-- Boolean: true -->
<b>x</b> <!-- Boolean: true -->
<b><span>x</span></b> <!-- Boolean: false -->Negates its final value as a Boolean. Note that this is an operator, and not a
type constructor, so untyped values are evaluated as variables automatically and
do not require being nested in a <span>.
<var name="x">false</var>
<del>true</del> <!-- false -->
<del>3</del> <!-- false -->
<del>false</del> <!-- true -->
<del>x</del> <!-- true -->
<del><span>x</span></del> <!-- true -->Produces the sum of all the elements in its final value, which must be an array of numbers or strings. With strings, it performs concatenation.
<!-- 12 -->
<a>
<ol>
<li><i>3</i></li>
<li><i>4</i></li>
<li><i>5</i></li>
</ol>
</a>
<!-- "345" -->
<a>
<ol>
<li><q>3</q></li>
<li><q>4</q></li>
<li><q>5</q></li>
</ol>
</a>Similar to <a>, but performs subtraction. Does not work on strings.
<!-- -6 -->
<s>
<ol>
<li><i>3</i></li>
<li><i>4</i></li>
<li><i>5</i></li>
</ol>
</s>Similar to <s>, but performs division.
<!-- 1 -->
<div>
<ol>
<li><i>10</i></li>
<li><i>2</i></li>
<li><i>5</i></li>
</ol>
</div>Similar to <div>, but performs multiplication.
<!-- 100 -->
<em>
<ol>
<li><i>10</i></li>
<li><i>2</i></li>
<li><i>5</i></li>
</ol>
</em>Raises $_ to the power of its final value. Both must be numbers.
<!-- 9 -->
<i>3</i><sup><i>2</i></sup>Performs a less than comparison between $_ and its final value.
<!-- true -->
<i>3</i><small><i>5</i></small>
<!-- false -->
<i>5</i><small><i>3</i></small>Performs an equality comparison between $_ and its final value. Types of both
arguments must be the same for this to evaluate to true.
<!-- true -->
<i>3</i><samp><i>3</i></samp>
<!-- false -->
<i>5</i><samp><i>3</i></samp>Creates an array, where each array element is the final value of each <li>
<!-- [3, "Hi", [ 5 ]] -->
<ol>
<li><i>3</i></li>
<li><q>Hi</q></li>
<li>
<ol>
<li><i>5</i></li>
</ol>
</li>
</ol>Creates a dictionary where each key, denoted by <dd>, corresponds to the value
of the following <dt>. The children of <dl> must start with <dd> and then
alternate <dd><dt><dd><dt>
<!--
{
first_name: "John",
last_name: "Smith",
age: 15
}
-->
<dl>
<dd><q>first_name</q></dd>
<dt><q>John</q></dt>
<dd><q>last_name</q></dd>
<dt><q>Smith</q></dt>
<dd><q>age</q></dd>
<dt><i>15</i></dt>
</dl>Perform the subscript operation to extract the values of an array or object. The
final value of the <sub> is the key to extract.
<var name="obj">
<dl>
<dd><q>first_name</q></dd>
<dt><q>John</q></dt>
<dd><q>last_name</q></dd>
<dt><q>Smith</q></dt>
<dd><q>age</q></dd>
<dt><i>15</i></dt>
</dl>
</var>
obj<sub><q>first_name</q></sub> <!-- "John" -->
<var name="arr">
<ol>
<li><i>3</i></li>
<li><q>Hi</q></li>
<li>
<ol>
<li><i>5</i></li>
</ol>
</li>
</ol>
</var>
arr<sub><i>1</i></sub> <!-- "Hi" -->Defines a function. User-defined functions can take only one argument. If you need more arguments, consider currying or passing an array or dictionary instead.
The contents of the <template> tag define the body of the function. To
reference the argument, use the variable argument. The final value is used as
the return value.
The function can be later referenced by its name, given by the name attribute.
<template name="fn">
<!-- ... some function body -->
</template>Performs a function call, passing its final value to the function referred to
by the previous value ($_). This node evaluates to the return value of the
function.
<template name="fn">
<!-- ... some function body -->
</template><ins><q>hello world</q></ins> <!-- $_ is the template[name="fn"] -->
<!-- or make $_ fn, then call it -->
fn<ins><q>hello world</q></ins>The if-else block. If the final value of the (required) <header> tag is
true, the (optional) <main> block is run. If it is false, the (optional)
<aside> block is run. The return value of the <article> is the final value
of whichever block was run. If the block to run did not exist, the previous
value of $_ is returned instead.
For those experienced with programming who are used to the else if clause,
there is none, and you must instead nest <articles> to achieve this effect.
Obtains the native, global, JavaScript object window[identifier], where the
identifier is the final value of its children. Notice that the types of native
objects are not the same as HTMS types, so if you wish to use it as a HTMS
number or string, you must use the respective <i> or <q> to perform the
conversion. You can, however, pass HTMS values to these functions as they will
be converted automatically.
<!-- Produces the number 3 -->
<i>
<code><q>Math</q></code><sub><q>min</q></sub>
<fieldset>
<ol>
<li><i>3</i></li>
<li><i>7</i></li>
</ol>
</fieldset>
<i>Performs a function call, but instead of passing its final value as the argument, its final value must be an array whose elements are passed as multiple arguments to the function. This is most useful for interacting with native JavaScript code, as user-defined functions can only have one argument.
<!-- Produces the number 3 -->
<i>
<code><q>Math</q></code><sub><q>min</q></sub>
<fieldset>
<ol>
<li><i>3</i></li>
<li><i>7</i></li>
</ol>
</fieldset>
<i>Exports a HTMS value to the host program with the name given by the name attribute.
<HTMS name="program">
<output name="x"><i>3</i></output>
</HTMS>
<!-- Now in the native JS: window.program.x === 3 -->