options gen2

Its very easy to ignore reality. Ignoring effects of ignoring reality - now that's tricky.

First things first. How do we go from gen1 (or gen1.5) to gen2? Fear not

daslang -run-fmt -i -v2 hello_world.das

It will convert in place (hence -i).

Now, Boris, what on earth are you talking about? Why it's generation 2 syntax for daslang. Its now enabled by default in the CodeOfPolicies. Its also -v2syntax (or -v1syntax) as a command line argument. And of cause its an option

option gen2 // that is

Now, to the very first obvious question. Why new syntax?

It's simple, really. We use AI more and more. And AI likes to write code a certain way. It tries to write daslang code, but there were missing or misleading bits. New syntax fixes a lot of that.

People tend to write code they are used to, as well. Daslang integrates into C++. Some cross-pollination is unavoidable; turns out a tad more is needed.

There are also issues with ambiguity, as well as misc parser problems. New syntax addresses a lot of those too.

To the next obvious question. Why keep two?

As we discovered daslang really has two target audiences. One likes to write script-like code in python-like language. Another writes foundational systems from the C++ inspired background. Both gravitate towards the DSL's, but get there from the different perspective. Code looks very different. Syntax now reflects it.

---

So, lets give it some overview. What changed?

Most obvious one is blocks, and constructions. Blocks now require explicit { }, and constructions now require ( ) around conditions

for ( x in 0..5 ) {         // notice () and {}
    print("x = {x}\n" )     // notice no semicolon
}
if ( true ) {
    bar()
} elif ( false ) {
    foo()
} else {
    par()
}
while ( something ) {
    break
}
with ( someexpr ) {
    pass
}
unsafe {
    that_thing()
}

Semicolon still separate expressions, but it is not required for the last one in the line.

In type, function, and other declarations, we now use column almost exclusively

def add ( a:int, b:float ) {    // notice , though ; still works
    return float(a) + b
}

Field annotations are now using @ syntax

struct Foo {
    @do_not_delete a : Foo?
}

All sorts of calls and member access can now be written via dot

let a = SomeEnum.value  // was SomeEnum value
foo.bar(args)           // was foo->bar(args), can still use ->
someblock(args)         // was invoke(block,args), can still use invoke

All sorts of shortcuts for data initialization, including das figuring out move vs copy

let a = [1,2,3,4,5]     // was let a <- [[auto 1;2;3;4;5]]
var b = (1,2.,"3")      // was var b =  [[auto 1,2.,"3"]]
var c = {1=>"1",2=>"2"} // was var c <- {{1=>"1"; 2=>"2"}}
var d = Foo(a=1,b=2.)   // was [[Foo() a=1,b=2.]]
let e = default<FooBar> // was [[FooBar]]

We now have tuple variable expansion

var (a,b) = some_tuple_function()
print("a={a} b={b}, ab={a`b}\n")            // can access fields, as well as combined tuples
for ( (a,b) in some_tuple_container() ) {   // works the same in the for loop
    print("a={a} b={b}, ab={a`b}\n")
}

Missing comprehensions

var a = {for (a in 0..20); a=>"{a}"; where is_odd(a) }  // table comprehension

Capture is now spelled explicitly (old way still works with &, -> and := symbols)

var a <- @ capture(move(a),clone(b)) ( x:int ) {
    b.set(x)
    return a[x]
}

Blocks (local functions, lambdas) no longer need piping on initialization. Some blocks require nothing at all

var a <- $ ( a,b ) { a + b; }   // local block
foo() {                         // same as foo(${print("bar\n);})
    print("bar\n");
}
foo() $ ( a, b ) {              // same as foo($(a,b){print("a={a} b={b}\n")})
    print("a={a} b={b}\n")
}

String builder now supports format

var f = 13.; f ++
print("f = {f:3.2f}\n")         // same as std::fmt in C++

Typeinfo command is now outside of ( ), and < > now requires type

typeinfo sizeof(type<int>)      // typeinfo(sizeof type<int>)
typeinfo has_field<foo>(bar)    // typeinfo(has_field<foo> type<bar>)

There are bunch of other small things, and I did my best documenting them.

The best part is most of advanced syntax works with gen1 as well. Only [[ ]] and similar constructions are gone, and even those are just off via CodeOfPolicies. You can convert to version 1.5 - which will fix obsolete syntax, and keep the 'script' portion there. Or you can go straight to version 2. Its really down to culture, and task at hand.