dopp0/docs

Description (My bad opinionated opinions :D)

0. Reason - Why? - Because!

Because I need a more user-friendly tool, that's why!

0.1. less f*ck brains with parentheses

todo (about problems in languages with C-like syntax)

0.2. less f*ck brains with whitespaces

todo (about problems in languages with indentation syntax - Off-side rule - YAML, Python, Nim)

0.3. less key presses

Erlang is most laconic high-level language that I ever seen -
laconic and expressive, very simple (not overcomplicated) and is easy to learn.

0.4. target language

The only imperfection of Erlang is .. VM -
so if you write any crypto miner in Erlang - it won't impress with its performance...
(Erlang is very well designed for IO - network, parallel tasks etc,
but can show not better results for "number crusher" - CPU heavy tasks)
.
so as target needs system programming language that compiles to native single executable binary file.
.
Haskell was rejected cause - sometimes headache with io-pure-impure functions, non-optional GC, too many ways to make the same (so read other people's code may be too nontrivial);
Go was rejected cause - that was not more easy that Haskell for me (Haskell was more easy in use), also non-optional GC;
Rust was rejected cause - overcomplicated style of writing code - you do not thinking about your app architecture but have f*ck your brains with compiler - borrow checker etc (also is not so "memory safe" in reality as in advertising);
C++ was rejected cause - super overcomplicated, not need so headache ;) ;
C was rejected cause - I think for 2025 year C is a bit outdated (not so user friendly as we want), also don't want to write function declarations twice, and other cucumbers;
OCaml was rejected cause - has not user friendly compiler (non-informative errors messages), non-optional GC;
Nim was rejected cause - too less performance comparing to Dlang and C;
Zig was rejected cause - unstabled - in active development phase (will check - compare in future);
Jai was rejected cause - still in closed beta (will check - compare in future);
Forth, Common Lisp, Red, Ada, Lua, Mojo and Swift - have not been considered for this task;
D - Dlang - compiles to native single executable binary file, rich of features - not less possibilities than in C++, has optional GC, stable - mature etc.
so Dlang has been selected as target language, and compiler v1 will be in Dlang (v2 will be seft-hosted).

1. Naming

Compiler dopp for doppelganger
(also dopp command),

Language DEF-lang for
[based on] Dlang [and influenced by / inspiration from] Erlang [new] Fine language.

File extension - *.de (because de is more short than def).

2. Syntax and Ideas

2.1 toml file for config keys-values

[lexer]
indent_type = 0
indent_matter = 4
indent_not_matter = 2

this means we have basic indent (Off-side rule) as 4 whitespaces,
but we do not got error when next line have 5, 6 or 3, 2 whitespaces -
needs to have more that 2 whitespaces for change indent (Off-side rule) for next level.

2.2 do not use any reserved words (keywords) for function definition (like in Erlang)

todo add examples

2.3 Pattern Matching that transforms into if .. else if .. else ..

todo think - there are case in dlang already (maybe use case .. of ?):
https://dlang.org/spec/statement.html#SwitchStatement
https://dlang.org/spec/statement.html#case-range
https://tour.dlang.org/tour/uk/basics/controlling-flow
https://dlang.org/spec/expression.html#IsExpression
todo add examples

2.4 Pattern Matching at functions too (like in Erlang)

Function overloading in dlang allows to define the same function but with different versions for different data types:

int my_func(int x) {
    return x;
}

int my_func(string x) {
    return x.length; // or other operation(s) with argument
}

that similar to erlang's functions clauses:

my_func(X) when is_integer(X) -> X;
my_func(Y) when is_binary(Y) orelse is_list(Y) -> string:length(Y). %% is_list for list string (list chars codes)

other example

my_func(1) -> 1;
my_func(5) -> 5 * 2;
my_func(9) -> 9 * 3;
my_func(X) -> X * 4.

->

int my_func(int x) {
    if (x == 1) return 1;
    else if (x == 5) return x * 2;
    else if (x == 9) return x * 3;
    else return x * 4; // other cases
}

// or

int my_func(int x) {
    switch (x) {
        case 1:
            return 1; // if x == 1
        case 5:
            return x * 2; // if x == 5
        case 9:
            return x * 3; // if x == 9
        default:
            return x * 4; // other cases
    }
}

note that compiler can optimise few comparison conditions for switch better than that in if .. else.

todo add examples

2.5 aliases for imports, externs etc

use std [ stdio array string algorithm ] as use_std // definition at the beginning of the file

use use_std // allows use elsewhere in the file -- generate next code in this position in the target .d file

->

import std.stdio;
import std.array;
import std.string;
import std.algorithm;

todo add more examples

2.6 code between dlang reserved words translates into target .d file without changes

...

dlang

// common dlang code here

dlang

...

2.7 reserved words (keywords) list

including https://dlang.org/spec/lex.html#keywords

abstract alias align asm assert auto 
bool break byte 
case cast catch char class const continue 
dchar debug default delegate deprecated do double 
else enum export extern 
false final finally float for foreach foreach_reverse function 
goto  
if immutable import in inout int interface invariant is 
lazy long 
macro mixin module 
new nothrow null 
out override 
package pragma private protected public pure 
real ref return 
scope shared static struct super switch synchronized 
template this throw true try typeid typeof 
ubyte uint ulong union unittest ushort 
version void 
wchar while with 

__FILE__
__FILE_FULL_PATH__
__FUNCTION__
__LINE__
__MODULE__
__PRETTY_FUNCTION__

__gshared
__parameters
__rvalue
__traits
__vector

__DATE__
__EOF__
__TIME__
__TIMESTAMP__
__VENDOR__
__VERSION__


[deprecated keywords] body cdouble cent cfloat creal delete idouble ifloat ireal ucent


dlang
use
as

todo