Merhaba,

Daha önce hiç denememiştim, ta ki yabancı forumda şu iletiyle karşılaşıncaya kadar. Bildiğiniz ilişkisel (çağrışımsal) diziyi basit bir yapıyla sarmaladığınızda çok güçlü bir arkadaş çıkıyor:

struct LookUp(T)
{
  T*[string] data;

  auto set(string key, ref T value)
    => data[key] = &value;

  auto opIndex(string key)
    => key in data ? *data[key] : T.init;

  auto opSlice()
    => data.keys;
}

Aslında bu D'nin gücünü gösteriyor! Nasıl olur da bu dil yaygınlaşmaz diye hayıflanıyor insan. Buyrun şu aşağıdaki kodla deneyin ve gücü hissedin!

import std.stdio;

void main()
{
  struct S { string data; }
  
  auto foo = S("foo");
  auto bar = S("bar");

  LookUp!S table;
  
  table.set("foo", foo);
  assert(table["foo"] == foo);
  table["foo"].writeln;

  table.set("bar", bar);
  assert(table["bar"] == bar);
  table["bar"].writeln;

  table[].writeln;

  writeln([&foo, &bar]);
  table.writeln;
}

Dip Not: Bir de bunun karmaşığı, Voldemort tipi var ama şimdi çok fazla kafa karıştırmayayım dedim. Yoksa buraya nakledilmesi güç olan başka olaylar da var. Bence yukardaki de çok çok güzel. Haksız mıyım!

Başarılar...

On Thursday, 13 April 2023 at 21:21:53 UTC, Ali Çehreli wrote:

Haklısınız hocam, özellikle yaptığım bir şey değil. Sadece soruyla uyumlu bir cevap içindi. Benzer durum Variant için de var mı?

Hocam mesela burada da "Range Violation" hatası almamak için Uninitialized VariantN döndürerek çözdüm:

mixin template LookUp2(string data = "")
{
  struct LookUp2Impl
  {
    import std.variant;

    private Variant[string] values;
    alias values this;

    @property {
      auto opDispatch(string key)() inout
      {
        Variant val;
        //assert(VariantException(var.length));
        //values.require(key, val);

        if(key in values)
        {
          return values[key];
        }
        return val;
      }

      void opDispatch(string key, T)(T val)
      {
        values[key] = val;
      }
    }
  }

  static if(data.length > 0)
  {
    mixin("LookUp2Impl "~data~";");

  } else {

    LookUp2Impl data;
  }
}

import std.stdio;

void main()
{
  enum Tarih
  {
    AY  = 1,
    YIL = 2023
  }
  mixin LookUp2!"date";
  auto deneme1 = date.month; // normalde bu satırda hata veriyordu

  date.month = cast(ubyte)Tarih.AY;
  date.month.write("/");

  assert(date["month"] != Tarih.AY);
  assert(date["month"].type == typeid(ubyte));

  date.year = cast(short)Tarih.YIL;
  date.year.writeln(" in Turkish format");

  assert(date["year"] != Tarih.YIL);
  assert(date["year"].type == typeid(short));

  writefln("Date: %s/%s", date.year, date.month);

  auto deneme2 = date.month;
  assert(deneme2 == 1);
}

Bilmiyorum yöntem nasıl?

Vee tabi, bunu da çok seviyorum! Mixin&AA ikilisi Variant ile güçlendirilmiş. Üstelik Variant&opDispatch işbirliği ile esnek bir kullanım alanı sağlanmış.

Sevgiler, saygılar...

On Thursday, 13 April 2023 at 21:21:53 UTC, Ali Çehreli wrote:

Hocam, araya class Payload koysak sorunu (escaping reference) temelli çözmüş olur muyuz? Örneğin:

struct Lookup(T)
{
	T[string] table;
	alias type = T;

	auto set(string key, ref T value)
		=> table[key] = value;

	auto opIndex(string key)
		=> key in table ? table[key] : T.init;

	auto opSlice()
		=> table.keys;
}

class Payload(T)
{
	
	import std.format : format;
	import std.conv : to;
	
	T data;
	
	this(R)(R data) {
		this.data = data.to!T;
    }
	
	override string toString()
		=> data.format!"Content: %s";
}

void fillTable(R)(ref R data, int loop)
{
	import std.conv : text;
	typeof(data.table).stringof.writeln;

    while(--loop)
    {
        auto key = "ID" ~ loop.text;
        loop.writefln!"Value: %s,  Key: %s"(key);

        auto value = new data.type(loop);
        data.set(key, value);
    }
}

import std.stdio;
void main()
{
	alias PL = Payload!int;

	Lookup!PL table;
	table.fillTable(10);

	table["ID4"].writeln;
	table["ID1"].writeln;
} /* ÇIKTISI:

Payload!int[string]
Value: 9,  Key: ID9
Value: 8,  Key: ID8
Value: 7,  Key: ID7
Value: 6,  Key: ID6
Value: 5,  Key: ID5
Value: 4,  Key: ID4
Value: 3,  Key: ID3
Value: 2,  Key: ID2
Value: 1,  Key: ID1
Content: 4
Content: 1

*/

Teşekkürler...

On Wednesday, 3 May 2023 at 13:32:09 UTC, Salih Dincer wrote:

/* ÇIKTISI:

Payload!int[string]
Value: 9,  Key: ID9
Value: 8,  Key: ID8
Value: 7,  Key: ID7
Value: 6,  Key: ID6
Value: 5,  Key: ID5
Value: 4,  Key: ID4
Value: 3,  Key: ID3
Value: 2,  Key: ID2
Value: 1,  Key: ID1
Content: 4
Content: 1

*/

Bir de şunu deneyin, bence güzel yani :)

	import std.algorithm : each;
	table[].each!((a) => table[a].data.write(", "));
	writeln; // "4, 2, 9, 6, 5, 3, 1, 8, 7,"

Elbette table, sıradan bir Associative Array olabilirdi ve değerleri listelemek daha kolay olurdu. O zaman da pekala şöyle basit bir çıktı alabilirdik:

	table.values.writef!"%-(%s, %)";
	writeln; // "4, 2, 9, 6, 5, 3, 1, 8, 7"

Özetle ne öğrendik? Boşuna bir çaba mı? Faydası ne olabilirdi?

On Wednesday, 3 May 2023 at 14:14:37 UTC, Ali Çehreli wrote:

Hayır, çünkü sınıf sadece bir payload; yani taşıyıcı. Ve taşıyacağı yükü programcı belirleyebilir. Bu uygulamanın faydası, programcının karşılaşabileceği "Range violation" hatalarından korumak ve in işleçi yerine is ile null kontrolü sağlamasına yardımcı olmak. Bunu yaparken Variant veya Nullable kullanma ihtiyacı bırakmaması ayrı bir avantaj. Örneğin:

import std.stdio, std.conv : text;

void main()
{
	alias PL = Payload!string; // Programcı dilerse string de kullanabilir.

	Lookup!PL table;
	table.fillTable(10);

	auto test1 = table["ID10"];
	assert(test1 is null);

	int[string] tablo;
	int loop = 10;
	
	while(--loop)
	{
		tablo["ID" ~ loop.text] = loop;
	}
	
	// auto test2 = tablo["ID10"];
	// RangeError: Range violation

	tablo.values.writef!"%-(%s, %)";
	writeln; // "4, 2, 9, 6, 5, 3, 1, 8, 7"
}

On Wednesday, 3 May 2023 at 14:14:37 UTC, Ali Çehreli wrote:

Emin değilim ama ref kullanmadığım zaman veriye erişim sağlayamadım.

Sevgiler, saygılar...