On Monday, 2 June 2014 at 22:53:10 UTC, ponce wrote:
My thoughts while browsing the site:
- function-leve type inference much like Rust
- no constness in the type-system (I like it)
- class are reference types, structs are values types, much
like D and C#
- runtime dispacthed OO interfaces called "protocols". Blend
the difference between runtime or compile-time polymorphism.
Classes, structs and enums can implement a protocol. Available
as first class runtime values, so the protocol dispatch will
be slow like in Golang.
- enumerations are much like Ocaml ADT, can be parameterized
by a tuple of values, value types, recursive definitions
- worrying focus on properties.
- strange closure syntax
- optional chaining, another anti-feature in my eyes
- normal arithmetic operator throw a trap on integer overflow
(!). This must be incredibly slow.
- looks like Array is a fat slice to a reference-counted array
- operator overloading is in, supercharged with custom
operator, custom precedence (!?)
- builtin tuples syntax
- break with C integer promotion, like Rust.
- I haven't seen pointers
- convenience is a keyword!
- no exceptions (!)
- unsigned integers; check
- type inference is "bidirectional by expression or statement"
- class have deterministic destructors, structs have no
destructors; like D except reversed
- It seems the only RAII source is through RC and classes.
- no single root class
No exceptions (!) so this is at least something that this
language do better as C++ and D :D
Not everyone think that exceptions are necessary or there is no
other way to handle errors.
But if there is no RAII and only automatic memory management then
it is very bad.
