ref: 82f94a1ad3d38b62ea08351190ec237646c52a17
dir: /doc/lang.txt/
The Myrddin Programming Language
Aug 2012
Ori Bernstein
1. OVERVIEW:
Myrddin is designed to be a simple, low level programming
language. It is designed to provide the programmer with
predictable behavior and a transparent compilation model,
while at the same time providing the benefits of strong
type checking, generics, type inference, and similar.
Myrddin is not a language designed to explore the forefront
of type theory, or compiler technology. It is not a language
that is focused on guaranteeing perfect safety. It's focus
is on being a practical, small, fairly well defined, and
easy to understand language for work that needs to be close
to the hardware.
Myrddin is a computer language influenced strongly by C
and ML, with ideas from Rust, Go, C++, and numerous other
sources and resources.
2. LEXICAL CONVENTIONS:
The language is composed of several classes of token. There
are comments, identifiers, keywords, punctuation, and whitespace.
Comments, begin with "/*" and end with "*/". They may nest.
/* this is a comment /* with another inside */ */
Identifiers begin with any alphabetic character or underscore,
and continue with any number of alphanumeric characters or
underscores. Currently the compiler places a limit of 1024
bytes on the length of the identifier.
some_id_234__
Keywords are a special class of identifier that is reserved
by the language and given a special meaning. The set of
keywords in Myrddin are as follows:
castto match
const pkg
default protect
elif sizeof
else struct
export trait
extern true
false type
for union
generic use
goto var
if while
At the current stage of development, not all of these keywords
are implemented within the language.[1]
Literals are a direct representation of a data object within the
source of the program. There are several literals implemented
within the Myrddin language:
Integers literals are a sequence of digits, beginning with a
digit and possibly separated by underscores. They are of a
generic type, and can be used where any numeric type is
expected. They may be prefixed with "0x" to indicate that the
following number is a hexadecimal value, or 0b to indicate a
binary value. Decimal values are not prefixed, and octal values
are not supported.
eg: 0x123_fff, 0b1111, 1234
Float literals are also a sequence of digits beginning with a
digit and possibly separated by underscores. They are also of a
generic type, and may be used whenever a floating point type is
expected. Floating point literals are always in decimal, and
as of this writing, exponential notation is not supported[2]
eg: 123.456
String literals represent a byte array describing a string in
the compile time character set. Any byte values are allowed in
a string literal. There are a number of escape sequences
supported:
\n newline
\r carriage return
\t tab
\b backspace
\" double quote
\' single quote
\v vertical tab
\\ single slash
\0 nul character
\xDD single byte value, where DD are two hex digits.
String literals begin with a ", and continue to the next
unescaped ".
eg: "foo\"bar"
Character literals represent a single codepoint in the character
set. A character starts with a single quote, contains a single
codepoint worth of text, encoded either as an escape sequence
or in the input character set for the compiler (generally UTF8).
eg: 'א', '\n', '\u1234'[3]
Boolean literals are either the keyword "true" or the keyword
"false".
eg: true, false
Funciton literals describe a function. They begin with a '{',
followed by a newline-terminated argument list, followed by a
body and closing '}'. They will be described in more detail
later in this manual.
eg: {a : int, b
-> a + b
}
Sequence literals describe either an array or a structure
literal. They begin with a '[', followed by an initializer
sequence and closing ']'. For array literals, the initializer
sequence is either an indexed initializer sequence[4], or an
unindexed initializer sequence. For struct literals, the
initializer sequence is always a named initializer sequence.
An unindexed initializer sequence is simply a comma separated
list of values. An indexed initializer sequence contains a
'#number=value' comma separated sequence, which indicates the
index of the array into which the value is inserted. A named
initializer sequence contains a comma separated list of
'.name=value' pairs.
eg: [1,2,3], [#2=3, #1=2, #0=1], [.a = 42, .b="str"]
A tuple literal is a parentheses separated list of values.
A single element tuple contains a trailing comma.
eg: (1,), (1,'b',"three")
3. SYNTAX OVERVIEW:
Myrddin syntax will likely have a familiar-but-strange taste
to many people. Many of the concepts and constructions will be
similar to those present in C, but different.
3.1: Declarations:
A declaration consists of a declaration class (ie, one
of 'const', 'var', or 'generic'), followed by a declaration
name, optionally followed by a type and assignment. One thing
you may note is that unlike most other languages, there is no
special function declaration syntax. Instead, a function is
declared like any other value: By assigning its name to a
constant or variable.
const: Declares a constant value, which may not be
modified at run time. Constants must have
initializers defined.
var: Declares a variable value. This value may be
assigned to, copied from, and
generic: Declares a specializable value. This value
has the same restricitions as a const, but
taking its address is not defined. The type
parameters for a generic must be explicitly
named in the declaration in order for their
substitution to be allowed.
Examples:
Declare a constant with a value 123. The type is not defined,
and will be inferred.
const x = 123
Declares a variable with no value and no type defined. The
value can be assigned later (and must be assigned before use),
and the type will be inferred.
var y
Declares a generic with type '@a', and assigns it the value
'blah'. Every place that 'z' is used, it will be specialized,
and the type parameter '@a' will be substituted.
generic z : @a = blah
Declares a function f with and without type inference. Both
forms are equivalent. 'f' takes two parameters, both of type
int, and returns their sum as an int
const f = {a, b
var c : int = 42
-> a + b + c
}
const f : (a : int, b : int -> int) = {a : int, b : int -> int
var c : int = 42
-> a + b + c
}
3.2: Data Types:
The language defines a number of built in primitive types. These
are not keywords, and in fact live in a separate namespace from
the variable names. Yes, this does mean that you could, if you want,
define a variable named 'int'.
There are no implicit conversions within the language. All types
must be explicitly cast if you want to convert, and the casts must
be of compatible types, as will be described later.
3.2.1. Primitive types:
void
bool char
int8 uint8
int16 uint16
int32 uint32
int64 uint64
int uint
long ulong
float32 float64
These types are as you would expect. 'void' represents a
lack of type, although for the sake of genericity, you can
assign between void, return void, and so on. This allows
generics to not have to somehow work around void being a
toxic type.
bool is a boolean type, and can only be used for assignment
and comparison.
char is a 32 bit integer type, and is guaranteed to be able
to hold exactly one codepoint. It can be assigned integer
literals, tested against, compared, and all the other usual
numeric types.
The various [u]intXX types hold, as expected, signed and
unsigned integers of the named sizes respectively.
Similarly, floats hold floating point types with the
indicated precision.
var x : int declare x as an int
var y : float32 declare y as a 32 bit float
3.2.2. Composite types:
pointer
slice array
Pointers are, as expected, values that hold the address of
the pointed to value. They are declared by appending a '*'
to the type. Pointer arithmetic is not allowed. They are
declared by appending a '*' to the base type
Arrays are a group of N values, where N is part of the type.
Arrays of different sizes are incompatible. Arrays in
Myrddin, unlike many other languages, are passed by value.
They are declared by appending a '[SIZE]' to the base type.
Slices are similar to arrays in many contemporary languages.
They are reference types that store the length of their
contents. They are declared by appending a '[,]' to the base
type.
foo* type: pointer to foo
foo[123] type: array of 123 foo
foo[,] type: slice of foo
3.2.3. Aggregate types:
tuple struct
union
Tuples are the traditional product type. They are declared
by putting the comma separated list of types within square
brackets.
Structs are aggregations of types with named members. They
are declared by putting the word 'struct' before a block of
declaration cores (ie, declarations without the storage type
specifier).
Unions are the traditional sum type. They consist of a tag
(a keyword prefixed with a '`' (backtick)) indicating their
current contents, and a type to hold. They are declared by
placing the keyword 'union' before a list of tag-type pairs.
[int, int, char] a tuple of 2 ints and a char
struct a struct containing an int named
a : int 'a', and a char named 'b'.
b : char
;;
union a union containing one of
`Thing int int or char. The values are not
`Other float32 named, but they are tagged.
;;
3.2.4. Magic types:
tyvar typaram
tyname
A tyname is a named type, similar to a typedef in C, however
it genuinely creates a new type, and not an alias. There are
no implicit conversions, but a tyname will inherit all
constraints of its underlying type.
A typaram is a parametric type. It is used in generics as
a placeholder for a type that will be substituted in later.
It is an identifier prefixed with '@'. These are only valid
within generic contexts, and may not appear elsewhere.
A tyvar is an internal implementation detail that currently
leaks out during type inference, and is a major cause of
confusing error messages. It should not be in this manual,
except that the current incarnation of the compiler will
make you aware of it. It looks like '@$type', and is a
variable that holds an incompletely inferred type.
type mine = int creates a tyname named
'mine', equivalent to int.
@foo creates a type parameter
named '@foo'.
3.2.5. Traits:
3.3: Control Constructs:
3.4: Packages and Uses:
3.5: Expressions
4. TYPES:
5. EXAMPLES:
6. GRAMMAR:
7. FUTURE DIRECTIONS:
BUGS:
[1] TODO: trait, default, protect,
[2] TODO: exponential notation.
[3] TODO: \uDDDD escape sequences not yet recognized
[4] TODO: currently the only sequence literal implemented is the
unindexed one