Just now, I was looking to extend our mock framework to allow leaving single parameters unspecified. "Okay," I thought, "this shouldn't be too hard":

import std.sumtype;

struct Mocker
{
  static struct any {}
}

alias typeOrAny(T) = sumtype!(T, Mocker.any);

template expectationMethod(alias fn)
{
  alias ExpectedParams = staticMap!(typeOrAny, Parameters!fn);

  void method(ExpectedParams params)
}

.....

class TestClass {
  void call(string name, int value);
}

unittest
{
  auto mockedClass = mock!TestClass;

  mockedClass.expect.call("Hello World", Mocker.any); // So terse and elegant!
}

But, actually, that doesn't work: here's what you currently need to write in D.

unittest
{
  ...
  mockedClass.expect.call(typeOrAny!string("Hello World"), typeOrAny!int(Mocker.any));

I don't care if it needs a feature with two or even three underscores in front. I don't care if it's undocumented. I don't care if it only works for std.sumtype, even though std.typecons: nullable is begging for the same functionality; or if you literally write into the compiler license that you can sue people for thousands of dollars if they use it badly.

Just, please, give std.sumtype the ability to be implicitly constructed from a member type in function parameters.

[...]

Just now, I was looking to extend our mock framework to allow leaving single parameters unspecified. "Okay," I thought, "this shouldn't be too hard":

import std.sumtype;

struct Mocker
{
  static struct any {}
}

alias typeOrAny(T) = sumtype!(T, Mocker.any);

template expectationMethod(alias fn)
{
  alias ExpectedParams = staticMap!(typeOrAny, Parameters!fn);

  void method(ExpectedParams params)
}

.....

class TestClass {
  void call(string name, int value);
}

unittest
{
  auto mockedClass = mock!TestClass;

  mockedClass.expect.call("Hello World", Mocker.any); // So terse and elegant!
}

But, actually, that doesn't work: here's what you currently need to write in D.

unittest
{
  ...
  mockedClass.expect.call(typeOrAny!string("Hello World"), typeOrAny!int(Mocker.any));

I don't care if it needs a feature with two or even three underscores in front. I don't care if it's undocumented. I don't care if it only works for std.sumtype, even though std.typecons: nullable is begging for the same functionality; or if you literally write into the compiler license that you can sue people for thousands of dollars if they use it badly.

Just, please, give std.sumtype the ability to be implicitly constructed from a member type in function parameters.

... into my result library to ...

import std;
struct A_VERY_LARGE_NAME{
    int a;
}
void main()
{
    //A_VERY_LARGE_NAME[string] AA = ["fasf": 3, "hweh":5]; 		//doesn't work :(
    A_VERY_LARGE_NAME[string] AA = ["fasf": A_VERY_LARGE_NAME(3), "hweh":A_VERY_LARGE_NAME(5)]; 	//works
}

On Wednesday, 17 November 2021 at 03:49:41 UTC, StarCanopy wrote:

could you please, publish link to library?
if it possible, of couse.