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.

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.

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.

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

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.

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.

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.

Kind

-- Two-tuple of u8 and string    <(u8,string)>
-- Three-tuple of u8s            <(u8,u8,u8)>

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.

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 _).

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 | denotes the end of the header, and each row is separated by a semicolon ;.

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]:3>
_	"a"	[ 1 2 3 ]
4	"b"	_
7	_	[ 7 8 9 ]

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]:3> │
├───────┬──────────┬───────────┤
│   _   │   "a"    │  [1;2;3]  │
├───────┼──────────┼───────────┤
│   4   │   "b"    │     _     │
├───────┼──────────┼───────────┤
│   7   │    _     │  [7;8;9]  │
╰───────┴──────────┴───────────╯

Kind

A table's kind includes the column types and table dimensions. For example, the pretty print table's kind is: <{u8, string, [u8]:3}:3,3>.

This denotes:

Columns: { u8, string, [u8]:3 } (a mix of an -integer, a string, and a fixed-size array).
Shape: 3,3 (3 rows, 3 columns).

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

<{u8, string, [u8]:3}>

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]:3,1>

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.

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.

Examples

Examples 1: Implicitly Typed Records

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

1 2 3

]}

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:[

1 2 3

]}

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].

Kind

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

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

This denotes a record with:

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

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 :=(parenthetical-term

| structure

| 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,","]

;

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

;

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 :="<"

, ">"

, [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 :="<"

, ">"

, kind-annotation

;

Examples

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

Functions

Function Define

function-define :=identifier

, "("

, ?[function-arg,list-separator]

, ")"

, "="

, (function-out-args | function-out-arg)

, [statement,(ws1 | statement-separator)]

, "."

;

function-out-args :="(", [function-arg,list-separator], ")" ;

function-out-arg :=function-arg ;

function-arg :=identifier, kind-annotation ;

argument-list :="(", ?[(call-arg-with-biding | call-arg),","], ")" ;

Examples

    -- Simple function definition with no return value
    addNumbers(x: int, y: int) = (result: int) := 
        result = x + y
        .  -- Return result (implicitly)

    -- Function with multiple output arguments
    createRectangle(length: int, width: int) = (area: int, perimeter: int) := 
        area = length * width
        perimeter = 2 * (length + width)
        .  -- Return both area and perimeter

    -- Function with an optional argument (no output)
    greetUser(name: string) = := 
        print("Hello, " + name)
        .  -- No output, just side-effect

    -- Function with complex arguments and output
    calculateStats(x: int, y: int, z: int) = (average: float, max: int) := 
        average = (x + y + z) / 3.0
        max = max(x, max(y, z))  -- Function calls inside function body
        .  -- Return both average and max

Function Call

function-call :=identifier, argument-list ;

call-arg-with-binding :=identifier, colon, expression ;

call-arg :=expression ;

var :=identifier, ?kind-annotation ;

Examples

Call function with simple arguments

sumResult = addNumbers(5, 10) --

Call addNumbers with two integer arguments

Call function with binding (using colon syntax to bind a specific argument)

rectangleDetails = createRectangle(10, 20) --

Call with two integers

area = rectangleDetails.area --

Accessing the area

perimeter = rectangleDetails.perimeter --

Accessing the perimeter

Call function with complex arguments and output

stats = calculateStats(10, 20, 30) --

Call calculateStats

average = stats.average --

Extract average

maxValue = stats.max --

Extract max value

Call function with optional argument

greetUser("Alice")--

Function call with a single string argument

State Machines

fsm :="#"

, ?argument-list

, ?kind-annotation

;

Operators

output-operator :="=>" ;

transition-operator :="->" ;

async-transition-operator :="~>" ;

guard-operator :="|"

| "│"

| "├"

| "└"

;

Specification

fsm-specification :="#"

, "("

, ?[var,","]

, ")"

, ?output-operator

, ?kind-annotation

, +fsm-state-definition

, "."

;

fsm-tuple-struct :=grave

, "("

, [fsm-pattern,","]

, ")"

;

fsm-state-definition :=guard-operator

, grave

, ?fsm-state-definition-variables

;

fsm-state-definition-variables :="(", ?[var,list-separator], ")" ;

fsm-pipe :=fsm-instance, *(fsm-state-transition | fsm-async-transition | fsm-output) ;

fsm-declare :=fsm, define-operator, fsm-pipe ;

fsm-instance :="#", identifier, ?fsm-args ;

fsm-args :="(", ?[(call-arg-with-binding | call-arg),list-separator], ")" ;

Implementation

fsm-implementation :="#"

, "("

, ?[identifier,list-separator]

, ")"

, transition-operator

, fsm-pattern

, ws0

, +fsm-arm

, "."

;

fsm-arm :=*comment, (fsm-transition | fsm-guard-arm), ws0 ;

fsm-guard-arm :=*comment, fsm-pattern, +fsm-guard ;

fsm-guard :=guard-operator, fsm-pattern, +(fsm-statement-transition

| fsm-state-transition

| fsm-output

| fsm-async-transition

| fsm-block-transition

) ;

fsm-transition :=*comment, fsm-pattern, +(fsm-statement-transition

| fsm-state-transition

| fsm-output

| fsm-async-transition

| fsm-block-transition

) ;

fsm-state-transition :=transition-operator, fsm-pattern ;

fsm-async-transition :=async-transition-operator, fsm-pattern ;

fsm-statement-transition :=transition-operator, statement ;

fsm-block-transition :=transition-operator

, left-brace

, +mech-code

, right-brace

;

fsm-output :=output-operator, fsm-pattern ;

fsm-pattern :=fsm-tuple-struct | wildcard | formula ;

wildcard :="*" ;

Examples

    -- Simple FSM Declaration
    fsm SimpleFSM
        (var1, var2)         -- Variables for FSM
        =>                   -- Output operator
        ;                    -- End of the state machine definition

    -- FSM with states and transitions
    fsm StateMachine1
        (state1, state2)
        => "StateMachineOutput"   -- Output operator for the FSM
        kind "simple"
        define
        #state1
            -> state2    -- Transition operator
            | guard1     -- Guard operator for conditional transitions
        .

    fsm-instance MyFSM
        (stateA, stateB)
        -> stateB         -- Simple state transition
        ~> stateA         -- Asynchronous transition operator


    -- FSM with variables and multiple states
    fsm ComplexFSM
        (state1, state2, state3)
        => "Processing"
        define
        #state1
            -> state2    -- Transition from state1 to state2
        | state2
            -> state3    -- Transition from state2 to state3
            ~> state1    -- Asynchronous transition back to state1
        .

    fsm-instance ComplexFSMInstance
        (stateX, stateY, stateZ)
        -> stateX       -- Transition to stateX
        ~> stateY       -- Async transition to stateY
        => outputX      -- FSM Output
        .


    -- FSM with guards and output operators
    fsm-implementation MyFSMImpl
        #FSMTransition1
        (state1, state2)
        -> state3         -- Transition from state1 to state3
        => stateOutput    -- Output from this FSM transition
        .

    fsm-guard-arm MyFSMGuard
        #FSMGuardState
        (stateGuard)
        | guard-condition  -- Guard operator for conditional checking
        .

    fsm-guard MyFSMGuardExample
        | FSMGuardPattern
        -> FSMGuardTransition
        ~> FSMAsyncGuard
        .

    fsm-block-transition MyFSMBlockTransition
        -> {
            // Complex code block executed during state transition
            set stateA = true
            set stateB = false
        }
        .


    -- FSM pattern with tuple struct
    fsm-pattern MyFSMPattern
        grave TupleState
        (varA, varB)
        .


    -- FSM instance with arguments
    fsm-instance ComplexArgsFSM
        (stateStart, stateEnd)
        (inputData1, inputData2) -- Call arguments with bindings
        -> stateStart
        .


    -- FSM State definition with guard and pattern matching
    fsm-state-definition MyStateDefinition
        | stateGuard
        grave stateDefinition
        (variableX, variableY)
        .


    -- FSM with wildcards and formulas in patterns
    fsm-pattern MyWildcardPattern
        *
        .

    fsm-pattern MyFormulaPattern
        formula("x + y = 10")
        .

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.

Body

program :=?title, body ;

body :=+section ;

Sections and Section Elements

section-element :=+mech-code

;

section :=?ul-subtitle, +section-element ;

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 4 levels of titles: the document title, section titles, and two levels of sub section titles.

Example:

Title
========

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

(2) Sub Section Title

(a) Sub Sub Section Title

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

Paragraphs and Paragraph Elements

paragraph :=+paragraph-element ;

paragraph-element :=hyperlink

| strong

;

paragraph-exclude :=http-prefix

| tilde

| grave

| bar

;

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

Paragraphs are a block element that can contain a number of inline elements including:

Strong text: **text**
Emphasis text: *text*
Strikethrough text: ~text~
Underlined text: _text_
Inline code: code
Hyperlinks: [text](url) also raw links http://example.com
Inline Mech: {expression}

Lists

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

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

ordered-list-item :=integer-literal

, "."

, *space

, paragraph

, *new-line

;

list-item :=dash

, +space

, paragraph

, *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 :=(grave, grave, grave)

, any

, (grave, grave, grave)

, ws0

;

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.

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 .

Block Quotes

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

Block quotes are used to indicate quoted text. They are created using the > character followed by a space, and can contain any text until a newline.

Example:

> This is a block quote.

When rendered, they look like this:

This is a block quote.

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