openscript 0.4.0__py3-none-any.whl

openscript/verify_shape.py

@@ -0,0 +1,162 @@
+"""Check 1 of ``compiled-program.md`` section 3.5: is this a compiled program at all.
+
+This is the half of verification that reads an untrusted object and answers that
+question before anything else runs, because every later check indexes into a
+table this one proves is a table.
+
+Every failure here is OS6018. A malformed instruction list, an unreadable
+encoding and a field of the wrong type are not three fixes: each is a defect of
+the compiler that wrote the program and none of them is repairable by hand. What
+varies is the location, and the location is a field path, so whoever wrote the
+compiler is told ``outputs.plots[2].channel`` rather than "structure".
+
+One difference from the first engine, and it is this interpreter's alone: its
+own ``True`` is an instance of its integer type, so every numeric test below
+refuses a boolean explicitly. Without that line a program carrying ``true``
+where a channel index belongs would verify, and the failure would arrive later
+as a wrong number.
+"""
+
+from typing import Any, Callable, Optional, Sequence, Set
+
+from .diagnostics import Diagnostic, malformed
+
+#: The tags a constant pool entry may carry, section 2.9.
+CONSTANT_TAGS = ("z", "b", "n", "s", "c")
+
+
+class ShapeCheck:
+    """Collects the first failure and stops: a malformed program has no second opinion."""
+
+    def __init__(self) -> None:
+        self._failure: Optional[Diagnostic] = None
+
+    def problem(self) -> Optional[Diagnostic]:
+        return self._failure
+
+    def fail(self, path: str, reason: str) -> bool:
+        if self._failure is None:
+            self._failure = malformed(path, reason)
+        return False
+
+    def object(self, value: Any, path: str) -> bool:
+        if not isinstance(value, dict):
+            return self.fail(path, "an object was required")
+        return True
+
+    def array(self, value: Any, path: str) -> bool:
+        if not isinstance(value, list):
+            return self.fail(path, "an array was required")
+        return True
+
+    def number(self, value: Any, path: str) -> bool:
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            return self.fail(path, "a finite number was required")
+        if value != value or value in (float("inf"), float("-inf")):
+            return self.fail(path, "a finite number was required")
+        return True
+
+    def whole(self, value: Any, path: str) -> bool:
+        if not self.number(value, path):
+            return False
+        if float(value) != int(value):
+            return self.fail(path, "a whole number was required")
+        return True
+
+    def string(self, value: Any, path: str) -> bool:
+        if not isinstance(value, str):
+            return self.fail(path, "a string was required")
+        return True
+
+    def boolean(self, value: Any, path: str) -> bool:
+        if not isinstance(value, bool):
+            return self.fail(path, "a true or false was required")
+        return True
+
+    def index(self, value: Any, path: str, size: int, table: str) -> bool:
+        """A whole number that indexes a table, with the table's size in the message."""
+        if not self.whole(value, path):
+            return False
+        if value < 0 or value >= size:
+            return self.fail(path, f"{value} is outside {table}, which holds {size}")
+        return True
+
+    def one(self, value: Any, path: str, allowed: Sequence[str]) -> bool:
+        if not self.string(value, path):
+            return False
+        if value not in allowed:
+            return self.fail(path, f"{value} is not one of {', '.join(allowed)}")
+        return True
+
+    def nullable(self, value: Any, path: str, check: Callable[[Any, str], bool]) -> bool:
+        """A field that may be a value or null, which is a value a script could write."""
+        return True if value is None else check(value, path)
+
+
+def check_colour(shape: ShapeCheck, value: Any, path: str) -> bool:
+    if not shape.array(value, path):
+        return False
+    if len(value) != 4:
+        return shape.fail(path, "a colour is four numbers")
+    for at in range(3):
+        if not shape.whole(value[at], f"{path}[{at}]"):
+            return False
+        channel = value[at]
+        if channel < 0 or channel > 255:
+            return shape.fail(f"{path}[{at}]", f"a channel runs 0 to 255 and this is {channel}")
+    if not shape.number(value[3], f"{path}[3]"):
+        return False
+    alpha = value[3]
+    if alpha < 0 or alpha > 1:
+        return shape.fail(f"{path}[3]", f"an alpha runs 0 to 1 and this is {alpha}")
+    return True
+
+
+def check_constant(shape: ShapeCheck, value: Any, path: str) -> bool:
+    """One constant pool entry, section 2.9: a two element array of tag and value."""
+    if not shape.array(value, path):
+        return False
+    if len(value) != 2:
+        return shape.fail(path, "a pool entry is a tag and a value")
+    tag = value[0]
+    if not shape.one(tag, f"{path}[0]", CONSTANT_TAGS):
+        return False
+    held = value[1]
+    if tag == "z":
+        return True if held is None else shape.fail(f"{path}[1]", "the absent entry holds null")
+    if tag == "b":
+        return shape.boolean(held, f"{path}[1]")
+    if tag == "n":
+        return shape.number(held, f"{path}[1]")
+    if tag == "s":
+        return shape.string(held, f"{path}[1]")
+    return check_colour(shape, held, f"{path}[1]")
+
+
+def check_field(shape: ShapeCheck, value: Any, path: str, keys: Set[str]) -> bool:
+    """A declaration field, section 2.3: a value, or the input reference.
+
+    The key half of check 10 lives here, because this is the one walk that visits
+    every field that may hold a reference. The value half runs later, with the
+    host's settings in hand, and is OS6019 rather than OS6018: that value came
+    from a settings dialog and the user who typed it can correct it.
+    """
+    if value is None or isinstance(value, (bool, str)):
+        return True
+    if isinstance(value, (int, float)):
+        return shape.number(value, path)
+    if isinstance(value, list):
+        for at, one in enumerate(value):
+            if not shape.number(one, f"{path}[{at}]"):
+                return False
+        return True
+    if not shape.object(value, path):
+        return False
+    if "input" not in value:
+        return shape.fail(path, "an object here is an input reference")
+    key = value["input"]
+    if not shape.string(key, f"{path}.input"):
+        return False
+    if key not in keys:
+        return shape.fail(path, f"it names the input {key}, which inputs[] does not declare")
+    return True

openscript/verify_tables.py

@@ -0,0 +1,256 @@
+"""Check 1 of section 3.5 over the program's own tables, and check 10's key half.
+
+``verify_shape.py`` answers whether a field is a number; this walks the whole
+program asking it, table by table, and checks that every index into a table is
+in range: the constant pool, slots, cells, states, registers, channels, library
+functions, call sites, loops and functions. It is separate from ``verify.py``
+because it is one long traversal with no decisions in it, and the decisions
+there, which version, which capability, which budget, are what a reader comes
+looking for.
+"""
+
+from typing import Any, Dict, List, Sequence, Set
+
+from .verify_requests import MachineTables, check_machine_tables, check_requests
+from .verify_shape import ShapeCheck, check_constant, check_field
+
+META_KINDS = ("study", "strategy")
+CHANNEL_TYPES = ("number", "string", "color", "bool")
+EFFECTS = ("none", "signal", "order", "draw", "log")
+
+#: Every declaration option of ``meta``, section 2.3.
+META_FIELDS = (
+    "title",
+    "short",
+    "overlay",
+    "precision",
+    "format",
+    "range",
+    "scale",
+    "group",
+    "onUnconfirmed",
+)
+
+#: The tables a later minor of this format major added, with the minor that added each.
+#:
+#: Section 9.2's rule read from the other side, which 9.4 step 3 states and
+#: ``spec/decisions.md`` minute 56 settled: a table a later minor added and an
+#: earlier program lacks reads as empty, never as a refusal, because 9.5's first
+#: line is a promise about that program. A program stamped at this minor or a
+#: later one has no such excuse. Section 2 says an empty table is written as an
+#: empty array and never omitted, so its absence there is the defect check 1
+#: exists for, and the version is what tells the two apart.
+#:
+#: ``spec/format-history.json`` records the same additions, one entry per format
+#: version, and this engine's tests read that file rather than a list of their
+#: own, so a version the history gains is a case the tests gain.
+ADDED_AT_MINOR = (("requests", 1),)
+
+
+def minor_of(raw: Dict[str, Any]) -> int:
+    """The minor of a ``major.minor`` the version step has already proved is one."""
+    parts = str(raw["openscript"]["format"]).split(".")
+    return int(parts[1]) if len(parts) > 1 else 0
+
+
+def supply_added_tables(raw: Dict[str, Any]) -> None:
+    """Writes the empty table an earlier minor is owed into the program itself.
+
+    Into the object rather than into a local, because every later step reads the
+    program as its own shape and would find the table missing again: the
+    verifier hands the same object on, and the engine holds it.
+    """
+    minor = minor_of(raw)
+    for table, added in ADDED_AT_MINOR:
+        if table in raw or minor >= added:
+            continue
+        raw[table] = []
+
+
+ARRAY_TABLES = (
+    "requires",
+    "inputs",
+    "channels",
+    "consts",
+    "series",
+    "cells",
+    "states",
+    "functions",
+    "callSites",
+    "loops",
+    "code",
+    "requests",
+)
+
+OBJECT_TABLES = ("compiler", "source", "meta", "limits", "lib", "outputs", "frame", "debug")
+
+
+def check_tables(shape: ShapeCheck, raw: Any) -> bool:
+    """Check 1 over every table the machine indexes, and every declaration field."""
+    if not shape.object(raw, "the program"):
+        return False
+    supply_added_tables(raw)
+    for name in ARRAY_TABLES:
+        if not shape.array(raw.get(name), name):
+            return False
+    for name in OBJECT_TABLES:
+        if not shape.object(raw.get(name), name):
+            return False
+
+    limits = raw["limits"]
+    if not shape.whole(limits.get("loops"), "limits.loops"):
+        return False
+    if limits.get("history") is not None and not shape.whole(limits["history"], "limits.history"):
+        return False
+
+    frame = raw["frame"]
+    if not shape.whole(frame.get("slots"), "frame.slots"):
+        return False
+
+    lib = raw["lib"]
+    if not shape.whole(lib.get("manifest"), "lib.manifest"):
+        return False
+    if not shape.array(lib.get("functions"), "lib.functions"):
+        return False
+    for at, entry in enumerate(lib["functions"]):
+        path = f"lib.functions[{at}]"
+        if not shape.object(entry, path):
+            return False
+        if not shape.string(entry.get("name"), f"{path}.name"):
+            return False
+        if not shape.whole(entry.get("arity"), f"{path}.arity"):
+            return False
+        if not shape.boolean(entry.get("state"), f"{path}.state"):
+            return False
+        if not shape.one(entry.get("effect"), f"{path}.effect", EFFECTS):
+            return False
+
+    for at, entry in enumerate(raw["consts"]):
+        if not check_constant(shape, entry, f"consts[{at}]"):
+            return False
+
+    keys: Set[str] = set()
+    for at, one in enumerate(raw["inputs"]):
+        path = f"inputs[{at}]"
+        if not shape.object(one, path):
+            return False
+        if not shape.string(one.get("key"), f"{path}.key"):
+            return False
+        if not shape.string(one.get("kind"), f"{path}.kind"):
+            return False
+        if not shape.index(one.get("slot"), f"{path}.slot", frame["slots"], "the frame"):
+            return False
+        if not check_constant(shape, one.get("default"), f"{path}.default"):
+            return False
+        keys.add(one["key"])
+
+    for at, channel in enumerate(raw["channels"]):
+        path = f"channels[{at}]"
+        if not shape.object(channel, path):
+            return False
+        if channel.get("id") != at:
+            return shape.fail(f"{path}.id", "a channel id is its position")
+        if not shape.one(channel.get("type"), f"{path}.type", CHANNEL_TYPES):
+            return False
+        for name in ("defer", "once"):
+            if not shape.boolean(channel.get(name), f"{path}.{name}"):
+                return False
+
+    tables = MachineTables(
+        series=raw["series"],
+        cells=raw["cells"],
+        states=raw["states"],
+        functions=raw["functions"],
+        call_sites=raw["callSites"],
+        loops=raw["loops"],
+        slots=frame["slots"],
+        lib_functions=len(lib["functions"]),
+    )
+    if not check_machine_tables(shape, "", tables):
+        return False
+
+    # 2.16: a read's body is walked on the same terms, because the same machine
+    # executes it over another instrument's bars.
+    if not check_requests(shape, "", raw["requests"], len(raw["series"]), len(lib["functions"]), keys):
+        return False
+
+    meta = raw["meta"]
+    if not shape.one(meta.get("kind"), "meta.kind", META_KINDS):
+        return False
+    for name in META_FIELDS:
+        if not check_field(shape, meta.get(name), f"meta.{name}", keys):
+            return False
+
+    debug = raw["debug"]
+    for name in ("pos", "fnPos"):
+        if not shape.array(debug.get(name), f"debug.{name}"):
+            return False
+
+    return _check_outputs(shape, raw["outputs"], len(raw["channels"]), frame["slots"], keys)
+
+
+#: Each declaration group, the fields of it that name a channel, and the fields
+#: that hold a value or the input reference that resolves to one.
+DECLARATIONS = (
+    ("plots", ("channel",),
+     ("title", "color", "width", "lineStyle", "offset", "overlay", "scale")),
+    ("levels", ("channel",), ("title", "color", "lineStyle", "lineWidth")),
+    ("markers", ("channel",), ("position", "shape", "color", "textColor")),
+    ("alerts", ("condChannel",), ("title", "frequency")),
+)
+
+OUTPUT_GROUPS = ("plots", "fills", "levels", "markers", "tables", "alerts")
+
+
+def _check_outputs(
+    shape: ShapeCheck, outputs: Any, channels: int, slots: int, keys: Set[str]
+) -> bool:
+    """Every declaration in ``outputs``, and every channel it points at."""
+    for group in OUTPUT_GROUPS:
+        if not shape.array(outputs.get(group), f"outputs.{group}"):
+            return False
+
+    def channel_field(holder: Any, path: str, name: str) -> bool:
+        return shape.index(holder.get(name), f"{path}.{name}", channels, "channels")
+
+    for group, channel_fields, value_fields in DECLARATIONS:
+        for at, one in enumerate(outputs[group]):
+            path = f"outputs.{group}[{at}]"
+            if not shape.object(one, path):
+                return False
+            for name in channel_fields:
+                if not channel_field(one, path, name):
+                    return False
+            for name in value_fields:
+                if not check_field(shape, one.get(name), f"{path}.{name}", keys):
+                    return False
+
+    for at, grid in enumerate(outputs["tables"]):
+        path = f"outputs.tables[{at}]"
+        if not shape.object(grid, path):
+            return False
+        if not shape.index(grid.get("slot"), f"{path}.slot", slots, "the frame"):
+            return False
+        for name in ("title", "position", "rows", "cols"):
+            if not check_field(shape, grid.get(name), f"{path}.{name}", keys):
+                return False
+
+    for paint in ("barColor", "background"):
+        value = outputs.get(paint)
+        if value is None:
+            continue
+        if not shape.object(value, f"outputs.{paint}"):
+            return False
+        if not channel_field(value, f"outputs.{paint}", "channel"):
+            return False
+
+    return True
+
+
+def input_keys(raw: Any) -> List[str]:
+    """The declared settings keys, in the order of section 2.6."""
+    return [one["key"] for one in raw["inputs"]]
+
+
+def channel_flags(raw: Any, name: str) -> Sequence[bool]:
+    return [bool(one[name]) for one in raw["channels"]]

openscript/version.py

@@ -0,0 +1,39 @@
+"""The two version numbers this engine declares, and why they are typed here.
+
+``openscript.format`` versions the compiled program's structure and
+``openscript.language`` versions meaning, and section 9.1 says they move at
+different speeds for different reasons. An engine declares which majors it can
+load and which language versions it has library semantics for, and section 9.4
+refuses on both.
+
+**These numbers exist elsewhere and this is the second copy, held by a check.**
+The first engine has them generated from the page and from the package manifest,
+because a number typed twice is a number that will disagree the day somebody
+edits one copy. That generator writes one language's file. A package a host
+installs cannot read the specification, which is not shipped with it, so the
+numbers have to be in the package, and the honest arrangement is the one the
+distribution file next door already uses for the package version: write it, and
+have a check fail the build the day it drifts. ``tests/test_version.py`` reads
+the sentence out of ``spec/compiled-program.md`` by the same pattern the
+generator uses, so the page stays the source and this stays a copy that cannot
+go stale quietly.
+"""
+
+#: The compiled format this engine implements: the major it loads, and the
+#: highest minor of that major it was written against.
+FORMAT = "1.1"
+
+#: The language versions this engine has library semantics for.
+#:
+#: An engine selects semantics by the program's ``language`` and not by the
+#: newest it implements, so that a saved script never changes its numbers.
+LANGUAGE_VERSIONS = (1,)
+
+
+def format_major() -> int:
+    return int(FORMAT.split(".")[0])
+
+
+def format_minor() -> int:
+    parts = FORMAT.split(".")
+    return int(parts[1]) if len(parts) > 1 else 0

openscript/zones.py

@@ -0,0 +1,118 @@
+"""Reading an instant in a named zone, and the one zone this engine can read.
+
+`stdlib.md` section 12.1 fixes what a zone is: an IANA name, never a fixed
+offset, because an offset held constant is silently wrong for half the year
+anywhere that observes a seasonal clock change and nothing about the wrong half
+looks wrong. Section 12.2 adds that the name is resolved against the host
+runtime's own timezone database, that two engines agree as far as their databases
+do, and that a name a database does not hold is OS6005 and never a guessed
+offset.
+
+**This engine holds one zone and declines the rest, and the reason is the
+dependency rule rather than the calendar.** What the standard library can answer
+is set out here rather than discovered by whoever meets it:
+
+- The civil arithmetic needs nothing installed. ``civil.py`` is the proleptic
+  Gregorian formula, so ``UTC`` is exact on every machine and for every instant,
+  including the ones an interpreter's own date type refuses.
+- The offsets do not come with the interpreter. The module that reads named
+  zones is in the standard library, but the table it reads is not: it looks for a
+  database the operating system ships, and where there is none it falls back to a
+  separately installed package of the same data. On the machine this stage was
+  written on, that search path is empty and the fallback package is what answers,
+  so an engine built on it would have taken a dependency the host never accepted,
+  and ``scripts/check-python.mjs`` could not have caught it: the check reads
+  import names against the interpreter's own list, and the import that resolves
+  a zone is one of the interpreter's own. It is the data behind it that is not.
+- The consequence is worse than the dependency. `conformance.md` section 5
+  requires a case to produce the same result on every machine and to read nothing
+  outside the case directory, environment variables included, and that module
+  consults an environment variable for its search path. A run that answered a
+  session in one zone on a build machine and declined it on a laptop would be
+  reproducible on neither.
+
+So a zone that is not ``UTC`` is not answered here under a guessed offset and not
+answered from a table this repository copied, which would be the same staleness a
+fixed offset has. It is declined, and the caller reports the case
+``unsupported`` naming the feature, which `conformance.md` section 8 defines and
+counts separately from a pass. A host whose instruments trade in another zone
+supplies the reader, which is the same footing `stdlib.md` section 12.2 puts every
+engine on: the database is the host runtime's.
+
+**The shape of the name is checked before any database is.** Section 12.2
+requires it: "an engine applies this rule before it consults one: a script
+refused on one engine has to be refused on every engine, and an abbreviation is
+ambiguous in any case". So a name that is neither an area and a location nor
+``UTC`` is malformed on every engine, whatever any database would have said about
+it, and that is a different answer from a well formed name this engine cannot
+read. The two are told apart below because only one of them is this engine's
+limit.
+"""
+
+import re
+from typing import Optional
+
+from .civil import MAX_INSTANT, Civil, fields_at, instant_at, whole_instant
+
+#: The one name with no area, which names one offset everywhere and is the whole
+#: of what this engine's own calendar is right for.
+READABLE = "UTC"
+
+#: An area and a location, section 12.2's rule, applied before any database is.
+_AREA_AND_LOCATION = re.compile(r"^[A-Za-z][A-Za-z0-9+_-]*/[A-Za-z][A-Za-z0-9+_/-]*$")
+
+
+def named(zone: object) -> bool:
+    """Whether this is a zone name at all, as against an abbreviation or an offset.
+
+    ``"UTC"`` or an area and a location. A name that fails this is one every
+    engine refuses, and refusing it is OS6005's own sentence rather than a
+    limit of this engine's calendar.
+    """
+    if not isinstance(zone, str):
+        return False
+    return zone == READABLE or _AREA_AND_LOCATION.match(zone) is not None
+
+
+def readable(zone: object) -> bool:
+    """Whether this engine can read a calendar in this zone.
+
+    True of one name. A well formed name this answers false to is not a bad
+    name: it is a zone whose offsets this engine does not hold, which is the
+    caller's ``unsupported`` and never an answer under another zone's clock.
+    """
+    return zone == READABLE
+
+
+def fields_in(instant: float, zone: object) -> Optional[Civil]:
+    """The civil fields an instant has in a zone, or nothing where there are none.
+
+    Three ways to have none, and they are one answer here because the calls above
+    make one of them: a zone this engine does not read, a timestamp that is not a
+    number, and a magnitude past the largest instant a calendar reads.
+    """
+    if not readable(zone):
+        return None
+    if not isinstance(instant, (int, float)) or isinstance(instant, bool):
+        return None
+    whole = whole_instant(float(instant))
+    return None if whole is None else fields_at(whole)
+
+
+def instant_of(fields: Civil, zone: object) -> Optional[int]:
+    """The instant a wall clock reading names in a zone, or nothing for no reading.
+
+    In ``UTC`` a reading names exactly one instant, so the two readings section
+    12.2 settles for a zone that changes its clock do not arise: there is no hour
+    this zone skips and none it repeats. A zone that has them is one this engine
+    declines above, which is why that rule is stated there and the arithmetic is
+    not written here to be exercised by nothing.
+    """
+    if not readable(zone):
+        return None
+    found = instant_at(fields)
+    # Compared as it is rather than as a binary64: a year a script computed can
+    # be an integer with three hundred digits in it, and converting one of those
+    # to a float raises where the first engine answers absence. Nothing in this
+    # package raises, so the magnitude is compared and the answer is absence.
+    return None if abs(found) > MAX_INSTANT else found

openscript-0.4.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: openscript
+Version: 0.4.0
+Summary: An open trading language: the engine that runs a compiled program.
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/marketcalls/openscript#readme
+Project-URL: Source, https://github.com/marketcalls/openscript
+Keywords: trading,language,interpreter,indicators,backtesting
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# openscript
+
+The engine that runs a compiled OpenScript program, in Python.
+
+OpenScript is an open trading language. A script is compiled to a **compiled
+program**: plain data, an instruction list, never generated code. This package
+runs one.
+
+It exists so that a platform can run a strategy where a JavaScript runtime is
+not available, which for a production trading server is the ordinary case. The
+compiler and the first engine are the `openalgo-script` package on npm; this is
+the second engine, and the two are held to each other by a conformance suite
+where any disagreement is a release blocker.
+
+## What it is
+
+- **No compiler.** This package is handed a compiled program and never a script.
+  The program arrives as canonical text, which is what a run's hash is taken
+  over, so an engine cannot quietly run something other than what was recorded.
+- **Nothing builds code out of text.** No string evaluator, no statement
+  executor, no import driven by hand, no object graph loaded out of bytes. That
+  is what lets a platform run many people's scripts in one process, and it is
+  enforced by a check rather than intended.
+- **Zero dependencies.** The standard library only, and not the parts of it that
+  stop a run being reproducible. Measured on every build against the module
+  names the running interpreter says are its own.
+
+## Installing
+
+```
+pip install openscript
+```
+
+Python 3.12 or newer. Nothing else.
+
+## Using it
+
+```python
+from openscript.run import load_text
+
+loaded = load_text(program_text, settings, library)
+if loaded.ok:
+    result = loaded.run.execute_bar(0, bar)
+```
+
+A host loads a program once and pushes bars at it one at a time, keeping a
+checkpoint so a bar that is still moving can be executed again and rolled back.
+The conformance adapter is the other way in:
+
+```
+python -m openscript --describe
+python -m openscript <case-directory>
+```
+
+## Where the documentation is
+
+The specification and the guides live in the repository:
+
+- `docs/integrating/the-python-engine.md` for what is in this package and what a
+  host needs.
+- `docs/integrating/running-a-strategy.md` for driving it bar by bar: the load,
+  the bar cycle, the rollback a moving bar rests on, and the order boundary.
+- `spec/` for the language, the compiled program format, the standard library
+  and the conformance suite.
+
+## Licence
+
+Apache-2.0.