On Tuesday, 12 July 2022 at 19:55:46 UTC, ag0aep6g wrote:

ah yes. The case I thought to was actually

void test1(string s = null)
{
    assert(s is null);
}

void test2(string s = "") // s is null term'ed, i.e not null
{
    assert(s is null);
}

void main()
{
    test1();
    test2(); // fails
}

the rule of thumb is to use stuff.length as condition, always, and not stuff itself, to prevent natyx, hard to find bugs.

On Tuesday, 12 July 2022 at 18:56:43 UTC, Paul Backus wrote:

string s = "hello";
string empty1 = s[0 .. 0];
string empty2 = s[1 .. 1];
assert(empty1 == null);
assert(empty2 == null);
assert(empty1 == empty2);

Then:

string a = null;
assert(a is null);
assert(a == "");

string b = "");
assert(b !is null);
assert(b == "");

Honestly, it is difficult to understand for newcomers... there is a reason, but there is a reason in javascript for 0 == '' too

On Tuesday, 12 July 2022 at 20:36:03 UTC, Antonio wrote:

Correction

string a = null;
assert(a is null);
assert(a == "");

string b = "";
assert(b !is null);
assert(b == null);

On 7/12/22 4:36 PM, Antonio wrote:

string a = null;
assert(a is null);
assert(a == "");

string b = "");
assert(b !is null);
assert(b == null);

It's not just for null. And it's unrelated to what javascript is doing.

string a = "abcabc";
assert(a[0 .. 3] ==  a[3 .. $])
assert(a[0 .. 3] !is a[3 .. $])

The point is, == compares value, is always compares identity.

And you cannot override is, it must always be predictable. For arrays, of course, you can't override ==, but custom types can.

-Steve

Hi @Steven Schveighoffer,
Yes solution looking useful and sure it will work.

Thanks.

On Tuesday, 12 July 2022 at 22:58:32 UTC, Steven Schveighoffer wrote:

string a = "abcabc";
assert(a[0 .. 3] ==  a[3 .. $])
assert(a[0 .. 3] !is a[3 .. $])

Consider null type array which is a related topic but it cannot get a null element! The first is ok, but the second is legal. So no effect, is it normal?

auto p = [ null, null ];//*
  assert(
    is(typeof(null)[] :
       typeof(p)
    )
  ); /* and it has two(2) elements */

  p ~= null;             // okay
  assert(p.length == 3); // true

  p ~= [];               // legal (no error)
  assert(p.length != 4); // what! (no effect)

  assert(p[0] == []);    // true
  assert([] == null);    // right on

  import std.stdio;
  typeid(p).write(": ", p.length);
  writeln("->", []); // typeof(null)[]: 3->[]

SDB@79

On Friday, 15 July 2022 at 06:38:58 UTC, Salih Dincer wrote:

auto p = [ null, null ];//*
  assert(
    is(typeof(null)[] :
       typeof(p)
    )
  ); /* and it has two(2) elements */

  p ~= null;             // okay
  assert(p.length == 3); // true

  p ~= [];               // legal (no error)
  assert(p.length != 4); // what! (no effect)

  assert(p[0] == []);    // true
  assert([] == null);    // right on

  import std.stdio;
  typeid(p).write(": ", p.length);
  writeln("->", []); // typeof(null)[]: 3->[]

Yes, this is expected.

Note that the term null and [] are special tokens that morph type to whatever is most appropriate at the time. null implicitly can be typed as any pointer type, or any array type. [] can be typed as any array type. However, it can't be implicitly typed as typeof(null), which is a special unit type.

typeof(null) x;
x = []; // error;

So consider that appending an element type to an array increases the array size, whereas appending an array type to an array adds the elements of the latter to the former. In this case, zero elements.

There are still some inconsistencies though:

pragma(msg, typeof([])); // void[], likely to avoid breaking code.
void[][] arr;
arr ~= []; // does not append an element

int[] x = [1, 2];
int[] y = null; // ok, null implicitly converts to any array
x ~= y; // ok, no elements added
x ~= null; // error, does not consider the implicit conversion to int[]

-Steve

On Friday, 15 July 2022 at 11:12:07 UTC, Steven Schveighoffer wrote:

Thank you. I didn't know what to do with a null array though? I think void[] would be more useful.

SDB@79

On Tuesday, 12 July 2022 at 20:36:03 UTC, Antonio wrote:

People would have different preferences there. Difference between null and empty is useless. D does the right thing here, what other languages do, is a mistake. If you want such difference, use the Nullable wrapper or Algebraic.