Is to implement a replacement for VHDL/Verilog - so called VSDL(working title) language. Erlang was chosen as an implementation language and proved to be a great choice : pattern matching, dynamic typing, garbage collection. For a short time life seemed to be great....
Until the single assignment concept became a headache. It restricted the structure of all data to be acyclic graphs, a show stopper for writing a compiler. Also that functional approach really made all algorithms un-understandable quickly. Very quickly.
In order to somehow move forward a crazy experiment was performed - Erlang was modified to support mutable tuples. A single bif function called "replace" was introduced to allow modification of the tuple. Everything worked, but programming was tricky and once in awhile produced unexpected results. The good news : VSDL language came to life and prooved to be a working concept. Bad news : the code became obscured. And of course the ugly news - the hack itself...
it was too risky to continue using hacked Erlang.... The hard desicion was made to make a new language to develope the other language. Virlang (notice similarities?) language was born sometime in december of 2017 and to the big surprise very quickly became a language that is worth to have a life of its own. Ta-Dah!
The source code is written in plain, utf-8 encoded text files. Files should have .vrl extension. The file name without extension is a module name. All names in Virlang, including filenames are case sensitive.
C++ style comments are supported.
12345 // this is a comment all the way to the end of line
/* This is a
multiline comment */
The data types are similar to Erlang, with some modifications.
Any signed integer, the size is only limited by memory.
12345 -99834034 0x122232334 // hexdecimal integer 9982772899873781981728361254146154263 // a really big number....
1#1000101 // binary number 7#76543 // octal numer F#EDA0012 // hexidecimal number
Real numbers are represented as 64-bit doubles with least 3 bits set to zero, making mantissa slightly less precise.
3.14 23.7654e-10
An atom is a named constant. It has to be enclosed in single quotes and can contain any symbol, single quote is coded as \' and backslash as \\
'atom' 'true' 'hello'
Tuple is a fixed size array of terms.
{1, 2, 'tuple'}
Record is similar to a tuple - a fixed array ot terms, but elements of the record can be accessed only by names. Records are mutable unless the field inside the record is declared to be immutable. It is possible to extend an existing record by inheriting it from the other one, similar to single inherited classes in object oriented languages. All field names inside record should be different. The records and global functions are practically the same from the compiler point of view. This strange "discovery" will be explained later.
#node -> {id, name}; // declaring record node
#nodik -> #node {value} () -> value; (V) -> value := V end; // declaring record with methods aka C++ class...
List is a pair of 2 terms, first element is called HEAD and the second TAIL. The pair is separated by the vertical bar: |.
[1] // a single element list [1,2] // 2 element list [1|[2]] // same as previous
Binary is a fixed size immutable(for now) array of bytes. It is assumed that all binaries are utf-8 encoded when interpreted as strings. They are represented as something enclosed in double quotes. Double quote is encoded with \" and a backslash with \\. Also \n - is a new line, \t - tab Just like in Erlang biaries can be constructed from values as well. This is stil work in progress...
"string" "Hello, World!\n"
Map is a dictionary that is implemented as rb-tree. Virlang maps are mutable. Maps are created using following syntaxis:
#{} // emty map
#{'A'=>1} // single element map
#{'A'=>1, 'B'=>2} // 2 element map
Fun is a function. A first-class object. There are two ways of defining one: at the top level of the module, in this case it starts with a name following by cases:
my_fun
("hello", From) -> @:display("Hi, "++From);
("bye", From) -> @:display("Chao, "++From)
end;
the second case is anonymous function declared inside the body of others:
Main(_)->
f_mul=fun(X,Y)->X*Y end,
f_div=fun(X,Y)->X/Y end,
f_div(f_mul(1,3), 3)
end;
functions can be passed as parameters, stored inside tuples,maps, lists, variables just like any other terms. All the constants are captured by "shallow" value: immutable types will look like they been copied, mutable types will reference to the same object. Only variables are captured by REFERENCE.
there is 'self' keyword that represents a current function, it allows for the function to call itself in a simple way. All calls are tail-call optimized when appropritate, the following will be an infinite loop, not a stack overflow:
Main(P)->
self(P)
end;
The arity of the function can be different in matching cases, the appropriate one will be chosen...
There are few zeros that evaluate to false during boolean operations. nil is a an empty term.
nil
""
{}
[]
'false'
0
0.0
There are 2 types of automatic variables: constants and mutable variables. Constants are bound to their values inside pattern matching expressions. The simplest one is assignment:
C=1 // creates a new constant variable C that is bound to integer 1
Variables are declared and assigned with the value, the keyword 'var' is used for clarity and a special assignment operator is used to make it clear that this is a declaration of the variable.
var V:=2 // creates a new variable with initial value set to 2 V:=3 // changes the value of variable V to 3
Pattern matching is similar to Erlang at least in the "concept", the actual implementation is a work in-progress as the whole algorithm was made from scratch in order to support some tricky situations, especially when variables are used.
as of today pattern matching was pushed even further to automatically create refernce to internal strucutre, here is example:
T={1,2,3,4,5}, // tuple is created
{var a, var b,..}=T, // new VARIABLES a and b are created, they reference to items inside tuple
a:='A', // tuple T now becomes {'A', 2, 3, 4, 5}
b:='B' // tuple T now becomes {'A', 'B', 3, 4, 5}
This new way of pattern matching now works for tuples, records, lists and maps (everytime there is pattern with unbound identifiers inside a strucutre - those identifiers reference to the values inside. Read/write checks are still performed, if a record has a read only field - it is not possible to modify it, the bound identifier will be a constant. This way it is possible to write a lot more clear code...of course if you understand clearly what is going on...it might seem complicated but so far feels natural as to what human might expect will happen. Look at 'Prime numbers generator' example
Virlang follows the concept of eager evalution - all subexpressions are evaluated from left to right beore proceeding to the encapsulatig expression. example:
ExprA * ExprB // ExprA is evaluated first, ExprB next and after that multiplication of both is evaluated.
Terms are the simplest form of expression.
A constant is an expression. Constants are bound to their values using pattern matching. Constants start with a letter and can contain letters, numbers or underscore. There is ananymous constant _ (underscore) that can be used as a place holder for constants inside patterns.
Variables start with a letter and can contain letters, numbers or underscore. Any attempt to modify a constant will issue a compile time error. In the future releases there will be a constant evaluation optimization implemented that might eliminate constants altogether. The variable by itself is an expression, it returnrs the term last stored inside it. In order to change a varialbe there is a special assignment operator:
V:=5
A()->
var B:=1, // variable B is created with initial value 1
C=fun()-> B+10 end, // function is created with captured B
B:=B+1, // variable B is incremented and its value is 2 now
C() // function C is called and returns 12
end;
K()->
T={1,2,3}, // tuple T is created
C=fun()-> T[0]:=4 end,
C()
// after function C is called tuple T will be equal to {4, 2, 3}
end;
Patterns are used to bind constants to values.
List=[1,2,3,4,5], [A|_]=List, // A is bound to 1 [_|B]=List, // B is boind to [2,3,4,5]
Also, an experimental version of regular expression patterns is supported
Str="ABCDEF",
/S2/ =Str, // matches the whole string
/_/ =Str, // checks if Str is string
/.*?, A="C"("A"|"D"), _/ = Str // new constant A is bound to "CD"
Usual expression +,-,*,/ are supported on integers and real numbers. some logical operations as well. 'and' and 'or' operators are "short-curcuits". 'band' and 'bor' are not. There are some strange rules involved in the applying arithmetics to different types, it is still work in progress.
'if' expressions checks conditions one at the time and if condition is true executes related code and its value is returned. If there are no conditions but 'else' is followed - the related code is executed and it's value is returned. 'If' expression is a shortcurcuit - if there is no else statement and no conditions are true the result of last condition is returned (that can be one of those Zeros)
if
A > B -> A;
A == B -> A+B
else 0
end
Case expression matches each statement against expression and if match occurs - it returns the result of the following expression, if nothing matches a runtime exception is generated.
case Expr of
{A, ..} -> A;
[A|_] -> A
end
Case statement can have multiple expressions separated by comma, just like function but without brackets, in this case it should have matching number of patterns separated by a comma, again similar to function, but without brackets
case Expr1, Expr2 of
{A, ..}, ?atom -> A;
[A|_], /_/ -> A
end
There are many forms of loops, the simplest is loop, it is executed until a break statement is reached within a loop
loop
if
is_escape_pressed() -> break 0
end
end
loop get_next_string() of
"stop" -> break 0;
"hello" -> print("friend")
end
'while' loop is executed if condition is true. It is possible to put 'after' statement after the loop, if 'while' is stoped because condition becomes false - the 'after' code is executed, if 'while' is exited through break - 'after' code is by passed (not executed).
while Cond of
if Cond == nil -> break report_error() end,
do_some_work()
after
finish_work_and_return_result()
end
'for' loop iterates using generators. There are several types of generator, The simplest is a list generator:
List=[1,2,3,4],
for I <- List do
print_list_head(I)
end
It will print 1 2 3 4, 'I' becomes bound to the head of the list and is a variable, it is possible to assign to I and the current head of the list will be modified, it is captured by reference.
Next is the integer generator
for I <- 1..4 do
print(I)
end
Map=#{1=>'a', 2=>'b'},
for K, V <- Map do
print({K,V}),
V:=K,
print(V)
end
Loops with conditions ('for' and 'while') can have 'after' statement. It is executed if condition becomes false. If the 'break' statement is executed inside the loop, after portion is by-passed.
for K <- 1..23 do
if K == Limit -> break true end
after
false
end
Exceptions are processed similar to other languages. 'always' always executed no metter what happened after all that happened. The 'after' statement if present puts the timeout (in milliseconds) for the main expression to be executed. The timeout is checked only by the io library functions IF they decide to do so, in other words it is more of recommendation rather than a restriction.
try
do_something_dangerous()
catch
'oops' -> print("didn't work")
after 100 -> v:disaply("timeout after 100 ms")
always
cleanup() // always executed after things happened.
end
Loops can have labels. Those labels can be used in 'break' and 'continue' to specify enclosing loop they refer to.
var Acc:=0,
L1:for I <- 1..10 do
for K <- I..I*2 do
if
I+K > 20 -> break:L1 true;
K > 15 -> continue:L1
end,
Acc := Acc+1
end
end
It is possible to create a new process by calling @:spawn. First argument is the function to start a new process and the rest are parameters passed into the function. A new process starts as a completly independent from the previous process, all the values are copied into a new process, global/static variables are re-initialized (or may be copied from the previous process - it is still under investigation). The only shared objects are literal objects such as files, channels and so on..
Synchronization between processes is done in the same way as rendezvous in Ada.
server(Ch) ->
loop
try
accept Ch of
{'print', Msg} -> @:print(Msg),@:print("\n");
_ -> throw "not supported"
end
catch
"not supported" -> 'ok'
end
end
end;
Main(_) ->
var Counter:=0,
Ch=@:spawn(server, Ch),
loop
Ch(Counter), Counter:=Counter+1
end
end;