my wish list

[a11e99z]

please dont hint me to specification, I have already exploded on 
these things, and would like to remake them as I see it in more 
right behavior/style.
I'm not complaining, I want to make the language better and 
clearer without a rakes in it (you can step on them and get it on 
the forehead or lower)
u have your own opinion and tastes.
I typed whishes as non-ordered, without priority.

1) bool is bool
dont call bool overloaded func when exists other, try call byte, 
int, long, real first.
call bool when other options are not exists. probably user try to 
check that is 0/null or not.

2) dont pass implicitly any enum to something that is not base 
type of it
void fn( bool v ) { "bool %s".writefln( v ); }
void fn( byte v ) { "byte %s".writefln( v ); }
void fn( short v ) { "short %s".writefln( v ); }
void fn( long v ) { "long %s".writefln( v ); }
enum Week : int { Mon, Tue, .. , Sun }
fn( Week.Tue ); // fn( true ) WTF?
fn( Week.Wed ); // fn( byte ) WTF? use integer promotion. next 
for int32 is long, call it.
fn( Week.Mon as bool ); // looks weird but probably I know what I 
do here

another weird shit:
fn( 8-7 ); // fn( true )
fn( 9-7 ); // fn( byte )
fn( 270-7 ); // fn( short )
fn( 99999-7 ); // fn( long )
for arg of one type we called here FOUR DIFFERENT functions.
try to call:
[tuple(8,7),tuple(9,7),tuple(270,7),tuple(99999,7)].each!(t => 
fn( t[0]-t[1]));
u got different behavior for same values. don't you think it's 
weird?

3) tuple as part of language with deconstructing and naming 
(indexing is supported too)
auto (one, two) = { return (1, 2.0); }();
void fn( (int x, real y) arg ) { }
(int a, real b) hz = (5, 6.0);
fn( hz ); // names for tuple fields doesn't matter (like LLVM 
structs)

4) "it" as implicit arg for "one arg" lambdas as Kotlin does
// we already has better tuples so
[(8,7), (9,7), (270,7), (99999,7)].each!fn( it[0]-it[1])

5) cast( Type )val is ugly
too many brackets that makes code non readable
consider option Rust's AS "12345 as byte" that has precedence 
between unary and */%

6) nullable types as language feature not the Phobos
int? x;
real? y;
SomeStuct? z;
with implemented operators
if (x !is null) // cuz we check x than we can use it without any 
actions like suffix!
x! - either value of x or NullReferenceException
z?.meth( "arg" ) - Elvis operator: result is either null (method 
not called for nulls) or ReturnType!method (RTM). when RTM is not 
nullable then total result of such op will be RTM? - can store 
null or RTM
y ?? PI - returns right expression when left is null

7) simpler version of switch as expression with pattern matching
that supports set, lambdas and "else"
auto res = case (val) {
   of 1,2,3,5,7: "small prime",
   of it>10: "big one",
   else "negative", // trailing comma. see next
}; // total result is "string"
its a lil complicated version of ternary "cond ? a : b"

8) trailing comma is allowed
DONT CARE but can be useful for copy-paste
probably it already supported, I just saw it in pred point.
and for tuples too: (5,6,7,) - 3-field tuple, not 4

9) lambdas as func args goes automatically as scoped
dont need explicitly increase the text when it is clear and 
compiler can do best job/choice for us

10) "=>" works like in C# for lambdas and functions
struct Rect {
   double area() => width * height; // to simplify funcs
}
lambda does not returns implicitly another lambda
(arg) => { float acc; ...; return acc; } // WTF? returns float 
delegate()
when I want to return lambda I can ask it explicitly
(arg) => { float acc; ...; return () => acc; } // I return 
lambda, anybody see it

11) string interpolation
can we add formatting like C# does?
$"pi={PI:F6} e={E:F9}".writeln;
should we change toString() to toString( string fmt =null ) for 
all?

12) (not sure)
can use # as stringify op
auto str = PI#"F6" ~ E#; // with format specifier and without
// that invokes toString( PI, "F6" ) and toString( E, =null )
or
auto str = #PI ~ #E; // connot request format with prefix
for now u can use .text, .format, to!string..

13) I want selective bounds checking.
for example Release disable the one, but for some arrays I want 
to check bounds in any case cuz I am not sure in indexing calcs 
or it depends from side services (do u add C++ integration? 
probably I mean it)
and I dont want to check it manually for every access writing 
something:
enforce( cast( ulong )calcedIndex < arr.length );
compiler can do such job better than me, it easy for it.
my code is unsafe so I cant use @safe with bounds checking.
I need something like:
@boundcheck
auto arr = ...
its something like Rust attributes, u can change behavior of 
entity, lets name it "manners".
in future u can invent any more useful manners that somehow 
change behaviour.
u can define it something different as attributes for now.

14) versioned modules
import core.memory!2.0 : memcpy;
you have to figure out how to store same files with diff versions.

15) easy using of shared Phobos and runtime
Windows is outsider for this point, but Windows has 90% of all 
computer users.

16) I want interoperate with C++ (DPP)
I want to use C++ STL without headache cuz Phobos STL is not 
enough.
I want to use others libs from world without abandoned wrappers.
do we still needed DIP1014 cuz std::string uses SSO?

17) (not sure but I want that)
precise GC shouldn't scan all DATA segs just some fields with 
using TypeInfo.
if compiler cannot understand where exactly pointers in DATA seg 
add "gcpointer" as new type and scan only it.
any bits in data seg holds unused memory.
and when app is finished for ENoMem without option to catch 
exception u just cannot name language as "safe".

18) "mutable" keyword
same meanings as C++

19) dynamic compilation and scripting like .NET allows
LLVM contains this feature. LDC supports it to a limited extent.

20) do we needed checked math?
if so probably better choice is checked { blocks } like in C# and 
@checked manner for vars cuz when we have such var we should 
check all math with it not just 1 op
@checked
long x = ...; // and compiler add checks for us

21) some features from C++ easy/clear than in D
- lambdas with capture clause: u can request which var cap as 
value and which as ref
- "ref" keyword is stodgy (not sure in English meaning) than refs 
in C++
ref int fn( ref float ) { } // D
int& fn( float& ) { } // C++. imo better
NB: ref shouldn't be attribute of func, its attr of input arg 
type and returned type
- when I will remember other I will add here

I am happy with other things :)

PS
I may be mistaken in some points, because my knowledge is not yet 
complete