Mech Platform Specification

, ws0

, ":"

, ws0

, ?comma

, ws0

;

A Map is defined using curly braces {} and contains a set of key-value mappings. Each key is unique and associated with a corresponding value.

Kind

The kind of a map consists of:

The kind of the keys
The kind of the values
The number of key-value pairs, which can be dynamic or fixed

<{string:u8}>--

A map of strings to unsigned 8-bit integers

<{string:{string:u8}}>--

A map of strings to a map of strings to unsigned 8-bit integers

Examples

{_:_}--

Empty map

{"a":1}--

Map with a single key-value pair

{1:0xA, 2:0xB, 3:0xC}--

Map with multiple key-value pairs

{"a":{"b":10}}--

Nested map

{"a":10, "b":20, "c":30}--

Multiline map

Edge Cases

{_:_} represents an empty map.
If the map is mutable, inserting a duplicate key overwrites the previous value
{1: "hello", 2: "world"} is valid, but {1: "hello", "one": "world"} results in an error, as the keys are not homogenous.

Semantics

Key Uniqueness: Each key in a map must be unique.
Unordered: The order of key-value pairs within a map is not preserved.
Key-Value Association: Each key is mapped to exactly one value.

Operations

Insertion: Adding a key-value pair updates the map. If the key already exists, its value is updated.
Deletion: Removing a key-value pair removes the key and its associated value.
Lookup: Retrieving the value associated with a key.
Merge: Combining two maps, where duplicate keys take precedence from the second map.

Tuple

tuple :="(", ?[expression,","], ")" ;

tuple-struct :=atom

, "("

, ")"

;

A Tuple is defined using parentheses () and contains an ordered collection of elements, which can be of different types.

Kind

<(u8,string)>--

Two-tuple of u8 and string

<(u8,u8,u8)>--

Three-tuple of u8s

Examples

()(1)(1,1,3)(1,(2,3))(1,true,"Hello")([

],7,false)

Edge Cases:

() represents an empty tuple.
(1) is a single-element tuple, not a parenthetical expression that evaluates to 1.
Tuples maintain the type of each element, so (1, "hello") has the kind <(f64,string)>,, unlike sets which require homogeneity.

Semantics

Ordered: The order of elements within a tuple is preserved.
Heterogeneous: A tuple can contain elements of different types.
Immutable: Once created, the elements in a tuple cannot be changed.

Operations

Access: Elements can be accessed by their position (zero-based index).
Concatenation: Tuples can be combined to form a larger tuple.
Decomposition: Tuples can be unpacked into individual variables.

Table

table :=table-start

, *(box-drawing-char | whitespace)

, table-header

, *(box-drawing-char | whitespace)

, +table-row

, *box-drawing-char

, ws0

, table-end

;

binding :=identifier

, ?kind-annotation

, colon

, ?","

;

table-column :=*(space | tab), expression, *((space | tab), ?("," | table-separator), *(space | tab)) ;

table-row :=?table-separator

, *(space | tab)

, +table-column

, ?semicolon

, ?new-line

, ?(+box-drawing-char, new-line)

;

table-header :=[field,+space-tab]

, *(space | tab)

, (bar | box-vert)

, ws0

;

field :=identifier, ?kind-annotation ;

empty-table :=table-start, ws0, table-end ;

A Table represents a structured collection of records, where each record consists of multiple fields (columns). Tables allow organizing data in a flexible, expressive manner.

Kind

A table's kind includes the column types and table dimensions. For example:

<|x<u8>,y<string>,z<[u8]:1,3>|:4>

This denotes:

Columns: |x, y, z<[u8]:3>|

x: An unsigned 8-bit integer column.
y: A string column.
z<[u8]:1,3>: A column containing row vectors of u8 with a fixed length of 3 elements.

Shape: The 4 indicates there are 4 rows in the table.

An underscore _ can be used to indicate that the number of rows is dynamic,
Rows can be omitted if the number of rows is to be inferred from an expression.

The kind of a table row is equivalent to a record with the same column kinds. Each row of the table has kind:

<{x<u8>,y<string>,z<[u8]:1,3>}>--

A table row is a record.

The kind of a table column is equivalent to a vector of the table column kind. For example the kind of the first column in the above table is:

<[u8]:1,3>--

A table column is a vector.

Examples

Tables are enclosed in {} and contain a header row specifying column names and kinds. The pipe | separates the header from the data rows.

x<f32>	y<u8>
1.2	9
1.3	8

This defines a table with two columns:

x: A floating-point column.
y: An unsigned 8-bit integer column.

The same table can be written in a compact, inline format using semicolons | to separate rows.

| x y | 1.2 9 | 1.3 8 |

Where the first cell is the header row, and the subsequent cells are the data rows, with each column separated by a space or comma.

Semantics

Structured: Each record consists of ordered fields (columns).
Heterogeneous: Fields can have different kinds (types).
Homogeneous: Each row has a similar structure, with the same fields.
Sparse: Tables allow missing values (denoted by _).

Any Fields

The * is the "any" kind and allows columns to contain data from mixed kinds.

x<*>	y<*>
1.2	true
"Hi"	8<u8>

Here, x holds both floats and strings, and y holds both integers and booleans. This can be useful for dealing with data whose type is not known at compiletime.

Incomplete Tables

When used as a value in a table, _ indicates that a cell is missing and will be filled in later.

x<u8>	y<string>	z<[u8]:1,3>
_	"a"	[ 1 2 3 ]
4	"b"	_
7	_	[ 7 8 ]

Fancy Representation

The Mech REPL prints tables using a fancy represntation, which is valid as input to a Mech program as well. The above table is equavlent to the following fancy table:

╭───────────────────────────────────╮
│ x   y  z<[u8]:1,4?> │
├────────┬───────────┬──────────────┤
│   _    │    "a"    │   [1 2 3]    │
├────────┼───────────┼──────────────┤
│   4    │    "b"    │      _       │
├────────┼───────────┼──────────────┤
│   7    │     _     │   [7 8 9]    │
╰────────┴───────────┴──────────────╯

Performance Considerations:

Tables are more expressive and flexible than matrices, because they can support missing values and mixed types. However, they may be slower due to additional metadata and dynamic typing associated with each cell, and the unwrapping involved in accessing data.

Table columns are stored in a column matrix with unboxed value element, so operating column-wise on table values can be fast.

However, "any" kinded columns resolve to a column matrix of fully wrapped values, so they will not work with matrix operations that expect unboxed values.

Record

record :=table-start

, ws0

, +binding

, ws0

, table-end

;

A Record is a collection of named fields, where each field consists of a key-value pair. Records provide a structured way to group related data while allowing heterogeneous types.

Kind

A record's kind describes the types of its fields:

<{x<u8>,y<string>,z<[u8]:1,3>}>

This denotes a record with three fields:

x: u8
y: string
z: [u8]:1,3 (a 1×3 array of u8 values)

Examples

Examples 1: Implicitly Typed Records

{x:1, y:"a", z:[

]}

This defines a record with three fields:

x (implicitly an float).
y (implicitly a string).
z (implicitly a column matrix of floats).

Example 2: Explicitly Typed Record

{x:1, y:"a", z:[

]}

Here, each field has an explicit kind:

x: A u8 integer.
y: A string.
z<[u8]:3,1>: A fixed-size 3×1 matrix of u8 integers.

Example 3: Nested Records

{a:{b:1, c:"hi"}, b:[

1 2 3

]}

This record contains:

a: A nested record {b: 1, c: "hi"}.
b: A columm matrix [1;2;3].

Semantics

Named Fields: Each field is identified by a unique name.
Heterogeneous: Fields can have different types.
Nested: Records can contain other records.

Defining Records:

Records are enclosed in {} and contain bindings of the form key: value. The type of each field can be inferred or explicitly specified.

Comparison to Tables

Records group related attributes of a single entity.
Access a field on a record yields a scalar of that type, rather than a column matrix.
A table with one row is not the same as a record, as they have to be stored differently internally.
A table can be thought of as a vector of records.

Tables represent multiple records (rows) sharing a common structure.

Expressions

expression :=range-expression | formula ;

Expressions define computations in Mech. Most expressions operate elementwise over collections according to the rules of broadcasting.

Broadcasting Rules:

Scalars expand to match the shape of collections.
Operations between collections are elementwise when shapes are compatible.
Higher-dimensional collections expand along singleton dimensions when necessary.
Tables support column-wise elementwise operations but use set-based operations (e.g., unions, joins) for whole-table manipulation.

Expression Categories:

Arithmetic: Addition, subtraction, multiplication, and division over scalars, vectors, and matrices.
Matrix Operations: Matrix multiplication, transposition, and other matrix-specific operations.
Comparison: Elementwise relational comparisons (<, >, ==, etc.).
Logical Operations: Boolean elementwise operations (and, or, not).
Set Operations: Union, intersection, and other set-specific operations.
Range Expressions: Constructing sequences of values.
Indexing: Accessing elements within collections using direct and computed indices.

Formula

parenthetical-term :=left-parenthesis, formula, right-parenthesis ;

negate-factor :="-", factor ;

formula :=l1, *(range-operator, l1) ;

add-sub-operator :=add | subtract ;

l1 :=l2, *(add-sub-operator, l2) ;

mul-div-operator :=multiply | divide ;

matrix-operator :=matrix-multiply

| multiply

| divide

| matrix-solve

;

l2 :=l3, *(mul-div-operator | matrix-operator, l3) ;

exponent-operator :=exponent ;

l3 :=l4, *(exponent-operator, l4) ;

logic-operator :=and | or | xor ;

l4 :=l5, *(logic-operator, l5) ;

comparison-operator :=not-equal

;

l5 :=factor, *(comparison-operator, factor) ;

factor :=(structure

| parenthetical-term

| fsm-pipe

| function-call

| literal

| slice

| var

), ?transpose ;

A formula is an expression that follows operator precedence rules and consists of arithmetic, logical, comparison, matrix, and range expressions. Expressions in formulas are evaluated according to their precedence, with higher-precedence operations being evaluated first.

Operator Precedence

Operators in formulas are applied according to the following precedence, from highest to lowest:

Parentheses - Explicit grouping of expressions.
Negation and Logical NOT - Unary operations.
Exponentiation - Raising to a power.
Multiplication, Division, and Matrix Operations - Elementwise and matrix operations.
Addition and Subtraction - Binary arithmetic operations.
Comparison Operators - Elementwise comparisons.
Logical Operators - and, or, xor.
Range Operators - Used in range expressions.

Evaluation Order and Associativity

Left-to-right associativity applies to all operators, including exponentiation.
Parentheses explicitly override precedence rules.

Arithmetic

add :="+" ;

subtract :="-" ;

multiply :="*" ;

divide :="/" ;

exponent :="^" ;

remainder :="%" ;

Matrix

solve :="\\" ;

dot-product :="·" ;

cross-product :="⨯" ;

matrix-multiply :="**" ;

transpose :="'" ;

Comparison

not-equal :="!=" | "¬=" | "≠" ;

equal :="==" ;

greater :=">" ;

less :="<" ;

greater-or-equal :=">=" | "≥" ;

less-or-equal :="<=" | "≤" ;

Logical

or :="|" ;

and :="&" ;

not :="!" | "¬" ;

exclusive-or :="xor" | "⊕" | "⊻" ;

Set

union :="∪" ;

intersection :="∩" ;

difference :="∖" ;

complement :="∁" | "'" ;

subset :="⊆" ;

superset :="⊇" ;

proper-subset :="⊊" ;

proper-superset :="⊋" ;

element-of :="∈" ;

not-element-of :="∉" ;

Range

range-inclusive :="..=" ;

range-exclusive :=".." ;

Indexing

subscript :=swizzle-subscript

;

index :=identifier, +subscript ;

Slicing

bracket-subscript :="[", [(select-all | range-subscript | formula-subscript),","], "]" ;

brace-subscript :="{", [(select-all | formula-subscript),","], "}" ;

formula-subscript :=formula ;

range-subscript :=range-expression ;

select-all :=":" ;

Examples

    array := [10, 20, 30, 40, 50]
    slice_1 := array[1:]                -- Select all from index 1 to the end (select-all)
    slice_2 := array[1, 3]              -- Range subscript (from index 1 to 3)
    slice_3 := array[2, 4]              -- Another range from index 2 to 4
    slice_4 := array[:4]                -- Select all up to index 4
    slice_formula := array[(x + y), 3]  -- Formula-based subscript, with a calculated index

    matrix := { {1, 2}, {3, 4}, {5, 6} }
    brace_index := matrix{(x * y)}      -- Formula-based indexing within braces

Dot Index

dot-subscript :=".", identifier ;

dot-subscript-int :=".", integer-literal ;

Examples

dot_result_1 := object.field        -- Dot subscript with identifier
dot_result_2 := object.42           -- Dot subscript with integer literal

Swizzle

swizzle-subscript :="."

, identifier

, ","

, [identifier,","]

;

Examples

    vector := {x: 1, y: 2, z: 3}
    swizzle_result := vector.x, y      -- Swizzling: selecting x and y
    swizzle_combined := vector.x, y, z -- Swizzling: selecting x, y, z

Statements

statement :=variable-define

;

Variable Define

define-operator :=":=" ;

variable-define :=?tilde

, var

, ¬assign-operator

, define-operator

;

Examples

    intVar := 10                                -- Variable definition with initialization
    optionalVar := ~stringVar                   -- Variable definition with optional tilde
    varWithExpression := ~calculatedValue * 5   -- Variable definition with expression

Variable Assign

assign-operator :="=" ;

variable-assign :=slice-ref

, ¬define-operator

, assign-operator

;

Examples

numbers:=[

] numbers[2] = 10 --

Assign value 10 to index 2 of the array

Op-Assign

add-assign-operator :="+=" ;

sub-assign-operator :="-=" ;

mul-assign-operator :="*=" ;

div-assign-operator :="/=" ;

exp-assign-operator :="^=" ;

op-assign-operator :=add-assign-operator

| sub-assign-operator

| mul-assign-operator

| div-assign-operator

| exp-assign-operator

;

op-assign :=slice-ref

, ¬define-operator

, op-assign-operator

;

Examples

counter:=0counter+=5--

Add 5 to counter (addition assignment)

counter-=3--

Subtract 3 from counter (subtraction assignment)

counter*=2--

Multiply counter by 2 (multiplication assignment)

counter/=4--

Divide counter by 4 (division assignment)

counter^=2--

Exponentiate counter by 2 (exponentiation assignment)

Enum Define

enum-define :="<"

, identifier

, ">"

, define-operator

, [enum-variant,enum-separator]

;

enum-variant :=?grave, identifier, ?enum-variant-kind ;

enum-variant-kind :="(", kind-annotation, ")" ;

Examples

    status < Active | Inactive | Pending  -- Enum definition with variants
    priority < High | Medium | Low        -- Enum definition for priority levels

Kind Define

kind-define :="<"

, identifier

, ">"

, define-operator

, kind-annotation

;

Examples

    userKind < Person > :< string | int -- Kind definition with annotation

Mech Programs

mech :=mechdown-program | statement ;

Mechdown

Mechdown is a markup language for writing Mech programs. It is designed to maintain vague compatibility with Markdown, it is not a superset of Markdown. Rather, Mechdown is a distinct markup language with its own syntax and semantics. For instance, hashtag notation is not supported for titles, which is a departure from Markdown.

Moreover, Mechdown supports tables and other features that are not present in Markdown, but can be found in extension to Markdown like Github Flavored Markdown (GFM), and Mech-specific features like that ability to query Mech values and print them inline using {} syntax.

Mech programs and scripts can be written entirely without Mechdown, but literate programming with Mechdown is idomatic.

Document Structure

program :=ws0

, ?title

, body

, ws0

;

body :=ws0, +(section, section-elements), ws0 ;

section-element :=+mech-code

| list

| img

| float

;

section :=ul-subtitle, *section-element ;

section-elements :=+(¬ul-subtitle, section-element) ;

A Mechdown document consists of an optional title followed by a body containing sections. Each section can contain various elements such as paragraphs, subtitles, code blocks, lists, footnotes, citations, images, equations, tables, and thematic breaks.

Titles

title :=+text

, +"="

, *(space | tab)

, ws0

;

paragraph-element :=+(¬define-operator, text) ;

paragraph :=paragraph-starter, *paragraph-element ;

subtitle :=+digit-token

, "."

, *space

, +text

, +"-"

, *(space | tab)

, *(space | tab)

, ws0

;

number-subtitle :=*(space | tab)

, "("

, integer-literal

, ")"

, +(space | tab)

, +text

, *(space | tab)

, ws0

;

alpha-subtitle :=*(space | tab)

, "("

, alpha

, ")"

, +(space | tab)

, +text

, *(space | tab)

, ws0

;

There are 6 levels of titles: the document title, section titles, and two levels of sub section titles.

Example:

Title
========

1. Section Title
----------------

(1.1) Sub Section Title

(1.1.1) Sub Sub Section Title

Section titles and the first level of sub-section titles comprise the table of contents, which is generated automatically.

Paragraphs

paragraph :=+paragraph-element ;

paragraph-element :=hyperlink

| eval-inline-mech-code

| strong

;

paragraph-exclude :=img-prefix

| tilde

| grave

| bar

;

paragraph-text :=+(¬(paragraph-exclude), text) ;

At their base, paragraphs are blocks or raw text that start with a valid paragraph starter and end with a newline character.

Paragraph Elements

strong :=(asterisk, asterisk), +paragraph-element, (asterisk, asterisk) ;

emphasis :=asterisk, +paragraph-element, asterisk ;

strikethrough :=tilde, +paragraph-element, tilde ;

underline :=underscore, +paragraph-element, underscore ;

highlight :="!!", +paragraph-element, "!!" ;

inline-code :=grave, +text, grave ;

inline-equation :=equation-sigil, +text, equation-sigil ;

hyperlink :="["

, +text

, "]"

, "("

, +text

, ")"

;

raw-hyperlink :=http-prefix, +text ;

eval-inline-mech-cdoe :="{", expression, "}" ;

inline-mech-cdoe :="{{", expression, "}}" ;

Beyond raw text, paragraphs also can contain various markup which indicates inline elements. Mechdown supports the following inline markup:

- Text Markup
  - **Bold Text**
  - *Italic Text*
  - __Underline Text__
  - ~~Strikethough Text~~
  - !!Highlighted Text!!
- Inline Elements
  - `Inline code blocks`
  - {{inline-mech := syntax + "highlighting"}}
  - $$\pm\sqrt{inline^2 + equation^2}$$
- Link Elements
  - [Hyperlinks](#)
  - Autonumbered inline references [MECH]
  - Autonumbered footnote references[^1]
  - Section references §10.3

This renders as

Text Markup

Bold Text
Italic Text
Underline Text
~~Strikethough Text~~
Highlighted Text

Inline Elements

Inline code blocks
inline-mech:=syntax+"highlighting"

Link Elements

Hyperlinks
Autonumbered inline references [1]
Autonumbered footnote references1
Section references §10.3

References

footnote :="[^"

, +text

, "]"

, ":"

, ws0

;

footnote-reference :="[^", +text, "]" ;

citation-reference :="[", +alphanumeric, "]" ;

citation :="["

, (identifier | number)

, "]"

, ":"

, ws0

, ws0

, ?("(", +text, ")")

;

section-reference :="§", +(alphanumeric | period) ;

Mechdown supports various references including footnotes, citations, and section references.

Footnotes are used to indicate additional information or references at the bottom of the document. They are referenced inline using a [^label] syntax. Footnotes are defined as section elements, and are rendered where they are defined. They are indicated with a [^label]: syntax, followed by the footnote text.

Citations are used to reference external sources or documents. They are indicated inline using a [label] syntax. Citations are defined as section elements, and are rendered at the bottom of the document, in an auto-generated "Works Cited" section. They are indicated with a [label]: syntax, followed by the citation text and optional additional information in parentheses. The label used in reference must match the label used in the citation definition.

Section references are inline references to section titles, and are indicated with a § followed by the section number, or a unique section label.

Examples

This is a paragraph with a footnote reference.[^1] Here is a citation reference.[MECH] Finally, we have a section reference to §10.4.

[^1]: This is the text of the footnote.
[MECH]: Mech Programming Language. (2024). Retrieved from https://mech-lang.org (Mech Official Website)

This renders as:

This is a paragraph with a footnote reference.1 Here is a citation reference.[2] Finally, we have a section reference to §10.4.

This is the text of the footnote.

Although the referenec is defined here in the document, it will be rendered at the bottom of the document in the "Works Cited" section. This is in contrast to footnotes, which are rendered where they are defined.

Lists

unordered-list :=+list-item, ?new-line, ws0 ;

ordered-list :=+ordered-list-item, ?new-line, ws0 ;

ordered-list-item :=integer-literal

, "."

, *space

, *new-line

;

list-item :=dash

, +space

, *new-line

;

There are two varities of lists, unordered, which are delinated with a - or a graphicl and ordered list, which are delinated with a numeral like 1., and are numbered in order automatically when formatted.

Example:

- Item 1
- Item 2
- Item 3

1. Item 1
2. Item 2
3. Item 3

When rendered, they look like this:

Item 1
Item 2
Item 3

List items are paragraphs, and can contain any inline elements.

Example:

- **First**: item 1
- **Second**: item 2
- **Third**: item 3

Here's a list of some of the features of lists:

Bullet lists

One
Two
Three

Custom lists

Four
Five
Six

Numbered lists

One
Two
Three

Custom start number

One
Two
Three

Check lists

One
Two
Three

Thematic Breaks

thematic-break :=asterisks, asterisks, +asterisks ;

Thematic breaks are horizontal lines that can be used to separate sections of a document. They are created using three or more asterisks.

Example:

***
***********

When rendered, they look like this:

Code Blocks

code-block :=codeblock-sigil

, *space-tab

, ?code-identifier

, ?option-map

, *space-tab

, code-content

, codeblock-sigil

, ws0

;

codeblock-sigil :=grave-codeblock-sigil | tilde-codeblock-sigil ;

grave-codeblock-sigil :=grave, grave, grave ;

tilde-codeblock-sigil :=tilde, tilde, tilde ;

code-identifier :=+((¬"{", text)) ;

code-content :=*(¬codeblock-sigil, any) ;

Mechdown supports code blocks, which are enclosed in triple backticks (graves) and can contain any text. Code blocks are useful for including Mech code snippets or other text that should be displayed verbatim.

Blocks are deliniated by a code fence, whether triple graves or triple tildes. Optionally, a code identifier can be provided after the opening code fence to indicate the programming language of the code block. This enables syntax highlighting when rendered.

When "mech" is specified as the code identifier, the code block is treated as Mech code and syntax highlighting is applied accordingly. See §10.10 for more details specific to Mech code blocks.

When "ebnf" is specified as the code identifier, the code block is treated as EBNF syntax and syntax highlighting is applied accordingly.

Start and end code fences must be of the same type (either graves or tildes). To embed a code fence in another code fence, use the alternate type for the inner fence.

Examples

```
This is a code block deliniated with graves.
```

~~~
This is a code block deliniated with tildes.
~~~

This one has a label:

```ebnf
X := A | B, C ;
```

The label can also have an options map:

```ebnf{width: "25px}
X := A | B, C ;
```

Equations

equation :=(dollar, dollar), +text, new-line ;

Equations are orefixed with $$ and can contain any text. They are used to display mathematical expressions or formulas expressed in LaTeX syntax.

For instance,

$$ c = \pm\sqrt{a^2 + b^2}

when rendered will look like this:

Mechdown also supports inline equations, which begin and conclude with a $$. They are expressed with LaTeX syntax, like so: $$c^2 = a^2 + b^2$$. This is rendered by a third-party library into .

Callout Blocks

block-quote :=">", ws0, +paragraph ;

block-important :="(!)>", ws0, +paragraph ;

block-question :="(?)>", ws0, +paragraph ;

Callouts are used to emphasize a paragraphs, and classifies them into one of three semantic categories:

Quotes: for quotations, indicated with a >.
Important: for information critical to the reader, indicated with a (!)>
Question: for anticipated and frequently asked questions, indicated with a (?)>

Multiple paragraphs can be included in the callout block as long as there are no newline characters between them (although a newline is of course required to end a paragraph).

Example:

> This is a quote block.

(!)> This is an important block.

(?)> This is a question block.

(?)> This is a question block with multiple paragraphs.
This is the second paragraph.

When rendered, they look like this:

This is a quote block.

This is an important block.

This is a question block.

This is a question block with multiple paragraphs.

This is the second paragraph.

Tables

markdown-table :=markdown-table-header, *markdown-table-row ;

markdown-table-header :=whitespace0

, bar

, bar

;

column-header :=bar, paragraph ;

column-alignment :=bar

, whitespace0

, alignment-separator

, whitespace0

;

alignment-separator :=center-alignment

| left-alignment

| right-alignment

| no-alignment

;

no-alignment :=+dash ;

left-alignment :=colon, +dash ;

right-alignment :=+dash, colon ;

center-alignment :=colon, +dash, colon ;

markdown-table-row :=whitespace0

, +column-cell

, bar

;

column-cell :=bar, paragraph ;

Markdown tables consist of a header, and a body. The header is defined using a pipe | to separate columns, and a row of dashes - to indicate the alignment of each column. The body of the table contains rows of data, also separated by pipes.

Table Heading::

The header of a table is defined using a row of text followed by a row of dashes. The dashes indicate the alignment of each column.

Column Alignment:

Columns can be aligned in one of three ways:

Left-aligned: :-- or --
Right-aligned: --:
Center-aligned: :--:

Any number of dashes can be used to indicate the width of the column, and they can be of different lengths.

Table Body:

The body of a table is defined using rows of text separated by pipes. Each row can contain any number of columns, and the number of columns in each row must match the number of columns in the header.

Example

| Align Left  | Align Center | Align Right |
|:------------|:------------:|------------:|
| One         | Four         | {1 * 10}    |
| Two         | Five         | {2 * 20}    |
| Three       | Six          | {3 * 30}    |

Renders the following table:

Align Left	Align Center	Align Right
:------------	:------------:	0-----------:
One	Four	`1*10`
Two	Five	`2*20`
Three	Six	`3*30`

Images

img :="!["

, "]"

, "("

, +text

, ")"

, ?option-map

;

option-map :="{"

, ws0

, *mapping

, ws0

, "}"

;

option-mapping :=ws0

, ws0

, ":"

, ws0

, ?comma

, ws0

;

Images are added to Mechdown documents using the ![alt-text](image-url) syntax. An optional options map can be provided within curly braces {} to specify additional attributes for the image, such as width, height, or alignment.

The alt-text is a rich paragraph that can contain any paragraph elements. It is configured to display below the image as a caption by default. The caption is accompanied by a figure number, which is automatically assigned based on the section of the document in which the image appears.

Images can be floated to the left or right by prefixing with << or >>, respectively. This allows text to wrap around the image and caption.

Example

![The Mech "M"](https://github.com/mech-lang/assets/blob/main/images/mech-m2.png?raw=true)
![A smaller Mech "M"](https://github.com/mech-lang/assets/blob/main/images/mech-m2.png?raw=true){width: "100px", height: "100px"}

This renders as:

Mech Extensions

eval-inline-mech-cdoe :="{"

, ws0

, ws0

, "}"

;

inline-mech-cdoe :="{{"

, ws0