Eko: New Programming language write entirely in D (Feedback welcome)

[Danol]

Okay, did a brief look on the language - I am sorry, but I don't 
have energy to do something deeper, I'm drained enough from doing 
code reviews in my job :D

First, it's hard for me to make an opinion on the language, 
because the examples are rather limited.

But from what I've seen, I've generated a feedback below. Please 
keep in mind that even at my job, I am labeled as "the mean one", 
so don't feel discouraged by my words. Trying to write a custom 
programming language is something every programmer should go 
through, and it's a wonderful journey.

1. `write("Hello" + "\s0" + "World\n");` Here you're 
concatenating strings, but I haven't seen any explanation what 
that does under the hood. Is the language GCd? Are the strings 
dynamically allocated?
1. "s0 is a escape for space" why? I don't think I've seen this 
syntax in any language. And why do we even need to escape a space?
1. I am very confused about the code block/scope syntax. On one 
hand, I can see standard C++ `{}` at the function level, on other 
hand, I see Python-like `if :` on the conditions level, but then 
I also see `end;` followed by `else` that is not followed by 
`end` (what are the rules here?). That feels quite inconsistent - 
pick one scoping system and use it everywhere.
1. (minor) You're also inconsistent in the naming standards. For 
functions, I've seen camelCase `main` and `getInput`, PascalCase 
`Printer`, plus I think I saw you requiring underscores somewhere 
as well on the beginning of the function.
1. You're using `strcmp` function in your examples, which is one 
of the most C things ever :D For new languages, I would recommend 
avoiding it - it returns 0 if the strings equal, which is 
something one can easily forget and make a mistake in.
1. The `-v:` prefix for variables... In my programming 
experience, I actually prefer to not to have to care whether 
something is a variable or a function. It has often happened to 
me that I needed to turn some variable into a function at some 
point during development - at that point, having to rewrite every 
usage of such symbol to make it compile again is tedious, 
generates diffs, and is grounds for merge confilicts and such. In 
this regard, I find the D's UFCS very neat for example - you just 
turn the variable into a function, and the rest of the code just 
keeps working without a hitch. The "-v:" prefix goes against 
that, plus the combination of letters you've picked is rather 
finger-bending to type.
1. Also I've randomly opened a file: 
https://github.com/ekolang/eko/blob/main/src/source/app.d From 
what I've seen there, I'd recommend you utilizing libraries more 
for the "standard" things - parsing arguments is something that 
is plenty standardized and has libraries in basically every 
programming language, for example 
https://code.dlang.org/packages/argparse