Yeni yaptığım faydalı test sonuçları şöyle:

• D’de function literal olarak anılan delegate ve function türünde olmak üzere 2 lambda işlev vardır. Bunların farklı yazım türlerinden dolayı kısa/uzun, tek satır veya isimsiz/anonim kullanım şekilleri olsa da çoğu birbirinin hemen hemen aynısıdır. Derleyici kontrolünde auto ile kurulması tavsiye edilir.

• Delegate (temsilci) olarak tanımlanan uygulamanın diğerine göre bir avantajı vardır. O da içinde bulunduğu kapsamın dışında tanımlı nesnelere erişebilmesidir. Ancak function öyle değidir, global alanda tanımlananlar hariç, bir yapı/sınıf içinde bile this’e erişemez. Her ikisi de yerel değişkenlerine doğal olarak erişir.

• Sıradan bir işlev gibi tek başına çağrıldığında mutlaka sonunda 2. bir parantez aç/kapa olmalıdır. Ama hem UFCS ile çalışır, hem de ilk parametre soluna yazılsa ve () işareti unutulsa bile çağrıldığı yere by-value olarak dönüş sağlar. Eğer parametre almıyorsa isimsiz olanı saymazsak baştaki () işaretini kullanmayabilirsiniz. Örneğin:

auto logYaz = {
  auto logger = new LOGLAYICIM(LogLevel.info);
  logger.log("Kurulum tamam, hata yok.");
}

• Dilerseniz, derleme zamanı değerlere ihtiyaç duyan uygulamalar için (örn. bir yapı içine işlev enjekte etmekte) alias kullanabilirsiniz Pratikte faydası olmasa da const ile de kurabilirsiniz ama sadece aldığı parametrelerde kullandığınızda etkisini görebilirsiniz. Çünkü kendi içinde (eğer erişebiliyorsa) kapsam dışındakileri değiştirmeye devam edecektir. O yüzden delegate türünü kullanırken dikkatli olmalısınız, affetmez!

• Dilerseniz de iki aşamalı, sanki virtual function tanımlar gibi (sınıflardaki abstract konusuna bakınız) hiçbir şeye eşitlemeden daha sonra neyi tanımladıysanız ona uygun bir işlev bağlanabilir. (-bknz. örnekteki global delegate/function tanımlaması, farketmez main() içinde de olabilir)

Bu 5 madde dışında başka sonuçlar da çıkarabilir ya da eksik ifadeler olabilir. Ama lütfen, örnek kod sonundaki bonus'lara da bakıptest()'den başlayarak deneyiniz.

Aslında konu,şurada örnekleriyle anlatılıyor. Ayrıca Ali Çehreli'nin kitabındaki ilgili bölümde daha fazla bilgi ve örnek mevcut. Ama hızlıca denemek isterseniz elde ettiğim sonuçları aşağıdaki örneklerde görebilirsiniz:

import std.stdio;

void test()
{
  string str;
//        ^-- bu noktada str = null

  (){
    str = "Merhaba D";
  }();
//  ^-- tam bu noktada str değişir

  auto anonim = {
    str = "Merhaba C";
    return 0;
  };
// Ama bu çağrılmayı bekler...

  str.writeln; // "Merhaba D"

  anonim(); /* int delegate() türünde bir işlev,
             gereksiz yere 0 değerini döndürür */

  str.writeln; // "Merhaba C"

  anonim = () => 1;
  anonim().writeln; /* Şimdi döndürdüğü kullanılır
  ama dileseydik temsilci kullanmazdık:         */

  auto func = () => 2;
  typeid(func).writeln; // ÇIKTISI:
//       int function() pure nothrow @nogc @safe*
  int i = 3;
  // func = () => i;
}   /* Bu değer --^
döndürülemeyeceği için kod derlenmez! */

Çünkü function türünde kurmuştuk. Eğer delegate olsaydı main() içinde temsil edilebilirdi. Ayrıca dikkat: @safe yanındaki asterix (*) işaretine bakılırsa by-value değilmiş! Sizce neden delegate'de işaretçi olduğu belirtilmemiş olabilir? Çünkü zaten temsilci nesne olduğu için mi?

int eight = 8;

int dokuz() { return 9; }
int sekiz() { return eight; }

int delegate() del;
int function() fun;

void main()
{
  test();

  auto dokuz = 9;

//  del = () => 8;/* bu satır yerel değişken döndürür
  del = ()
  {
    return dokuz;
  }; /*
  Bu temsilci (delegate) işlev yerel olmayan değer
  de döndürebilir */




//  fun = () => dokuz;/* bu satır derlenöz!
  fun = ()
  {
    return 8; // eight; <-- bunu da dene, lütfen!
  }; /*
  Bu anonim (function) işlevin derlenmediğinde,
  Error: __lambda2 cannot access
         frame of function D main
  hatası verir çünkü bulunduğu kapsamın yerel değişken döndürür */

  writeln("- Lambda işlevler: () ile kullanıma dikkat!");
  del().writeln(", ", fun());

  "\n".writeln("- Normal işlevler:");
  dokuz.writeln(", ", sekiz);
}

6. numara (bonus):

Eğer denediyseniz fun() eight değişkenine erişebiliyor çünkü global alanda tanımlanmış. Burada delegate/function farklı bellek alanlarında bulunduğu sonucu çıkarılabilir. Bilemiyorum belki de izinler ile ilgili bir durumdur.

Ayrıca farkettiyseniz dokuz() işlevi ile main() içindeki aynı isimde değişken karışmıyor. Çünkü farklı kapsamlarda (biri global'de) ve hata da vermiyor. Derleyiciye yardım etmek istersek sonunda () işaretini koyabiliriz. Bir benzerini şu örnekte de uygulabilirsiniz:

int delegate(int) karesi;

void main()
{
  karesi = (int a) => a * a;
  int karesi = 5.karesi;
  assert(karesi == 25);
}

Başarılar...

On Tuesday, 12 April 2022 at 00:33:23 UTC, Ali Çehreli wrote:

Teşekkürler hocam, ben de örneğinizi geliştirerek 2x2 genişletilmiş bir kod uygulamasını paylaşmak istiyorum. Sizden farklı olarak oluşturulan değişkenin adresini, üret()içine parametre olarak verdim vebunu global/stack ayrımını vurgulamak için yaptım. Gereksiz yere aynı adresleri göreceksiniz ama durum bu:

int globalDeğişkeni; /* önce global state'de
bir değişkenimiz ve bir de üreteceğimiz şeyi
gösteren bir takma adımız olsun:             */

alias int delegate(int) @system temsilci;
temsilci G; // main() içinde lazım olcak...

temsilci üret(int* i)
{
  writeln("(üret) işlevinde...");
  writefln("i: %s", i);

  return (int j)
  {
    writeln("(temsilci) işlevinde...");
    writefln!"i: %s\nj: %s"(i, &j);
    return *i + j;
  };
}

import std.stdio;
void main()
{
  int stackDeğişkeni; "bu (main)'deki
   ilk değişken:".writeln(&stackDeğişkeni);

  globalDeğişkeni = 1; "bu (main) dışındaki
   ilk değişken:".writeln(&globalDeğişkeni);

  /*************/ writeln("\n"); /**************/

  temsilci m = üret(&stackDeğişkeni);
  writeln("(main) içindeki temsilcinin kapsamı
  (context'i):");
  writeln("@: ", m.ptr);

  auto i = m(int.max);
  assert(i == int.max);

  /*************/ writeln("\n"); /**************/

  G = üret(&globalDeğişkeni);
  writeln("(main) dışındaki temsilcinin kapsamı
  (context'i):");
  writeln("@: ", G.ptr);

  auto ii = G(int.max - 1);
  assert(ii == int.max);
} /* ÇIKTISI:

On Tuesday, 12 April 2022 at 07:40:04 UTC, Salih Dincer wrote:

Çıktısını unutmuşum, onu da bütünlük olsun diye hemen yukarı alıntı olarak iliştiriyorum. Ayrıca ekstra bir örnek nakledeyim. Sonra isteyen olursa kritik ederiz:

alias int delegate(int) del;

struct MAT(del)
{
  int sonuç;
  del işlem;

  this(int sayı, del işlem)
  {
    this.işlem = işlem;
    this.sonuç = işlem(sayı);
  }
}

void main()
{
  del karesi = (int a) => a*a;
  auto mat = MAT!del(5, karesi);
  assert(mat.sonuç == 25);
*/

On Tuesday, 12 April 2022 at 16:49:33 UTC, Ali Çehreli wrote:

Hocam kusura bakmayın...

Öylesine ayaküstü, 1-2 dakikada yazılmış bir denemeydi. Kafam karışmış olcak ki istediğim şeyi tam koda dökemedim. Amacım embed and launch function yöntemini icraa etmek. Böyle bir yöntem muhtemelen yok çünkü ben uydurdum :)

Ama ReturnType iyimiş, teşekkürler...

Kodun güncellenmiş hali şöyle:

struct MAT(alias fp)
{
  import std.traits : ReturnType;
  import std.format;

  alias T = ReturnType!(typeof(fp));
  T sonuç;
  typeof(fp) işlem;

  this(T sayı)
  {
    this.işlem = fp;
    this.sonuç = fp(sayı);
  }

  string toString()
  {
    return format("İşlem Sonucu: %d", sonuç);
  }
}

import std.stdio;
void main()
{
  alias karesi = (int a) => a * a;
  auto mat = MAT!karesi(5);

  with(mat) {
    işlem(sonuç).writeln; //625
    işlem = (int a) => 2 ^^ a;
    işlem(9).writeln; // 512

    assert(sonuç == 25);
    sonuç = işlem(8);
    assert(sonuç == 256);
  }
}