Merhaba,

İlk olarak aşağıdaki gibi bir yapımız olsun; tür şablonu ile çevrelenen:

struct Enumlarım(T)/*
alias T = int;
struct Enumlarım//*/
{
  enum UzunAdıOlanTürüm : T
  {
    False, True
  }
  //...
}

Yani buradaki şablon parametresi olan T'ye dikkat. Aslında Enumlarım yapısını bir instance name ile ilişkilendirmek istemiyorum ama aşağıdaki gibi kurmak zorunda kalıyorum çünkü o zaman Bool alias'ı kurulmuyor!

void main()
{
  // Kurulum:
  Enumlarım!int enumlarım;
  alias Bool = enumlarım.UzunAdıOlanTürüm;

  // Kontrol:
  auto selamVer(Bool vereyim_mi) {
    return vereyim_mi ? "selam" : "küstüm :)";
  }

  // Sonuç:
  import std.stdio;
  Bool selam;
  selamVer(++selam).writeln; // selam
}

Eğer Bool ='den sonra büyük harfle (lütfen değiştirip deneyin) doğrudan takma ad oluşturursanız çok garip bir hata alıyorum:

Neden böyle? Aslında cevabını biliyorum, sanırım! Eğer örnek kodun en üstünü kaparsanız (// - toggle comment ekleyin) T'yi yapıdan ayırmış olacaksınız. Eee tabi enumlarım'ı artık silin gitsin ve şu şekilde çalıştığını göreceksiniz:

alias Bool = Enumlarım.UzunAdıOlanTürüm;
auto selamVer(Bool vereyim_mi) {
  return vereyim_mi ? "selam" : "küstüm :)";
}

import std.stdio;
void main()
{
  Bool selam;
  selam.selamVer.writeln; // küstüm :)
}

struct Enumlarım {
  enum UzunAdıOlanTürüm { False, True }
}

Özetle, cevabını bildiğim bir soru çünkü şablon parametresi aldığı için o artık başka bir yapı ama alias içinde bağlayamamak üzücü. Çünkü kullandığım enum'ları bir struct içinde ve varsayılan temel veri türlerini (T) derleme anında değiştirebileceğim bir düzene ihtiyaç duyuyorum.

Diğer soru(n) az sonra...

On Sunday, 5 February 2023 at 14:45:46 UTC, Salih Dincer wrote:

Aslında çok sorum var ve bunları İngilizce forumda sormak istemiyorum çünkü anlamıyorlar. Sanırım benim engin İngilizce dilim onlara çok geliyor! Oxford'da okumak başka tabi... 😀

Şaka bir yana hakikaten İngilizce yazmak zor bea. Teknik terimleri bilmeyince anlamıyorlar da. Translator da anlamıyor/çeviremiyo 😞

Bir yardım lütfen ve gelelim asıl soruya...

Aşağıdaki gibi çalışan kodumuzun, #line 1 ile işaretlenen bölümde nasıl oluyorda kurucuya paremetre göndermeden kurulabilir?

import std.stdio;

void main()
{
  auto num = [68, 76, 65, 78, 71];
  auto str = "abcd12345";
  auto funy = Funy!long(str);
  funy.writeln(": ", funy.length);

  Funy!long foo;
  foo.writeln;

  foo = funy; // belli ki burada kopyalanmadı:
  funy.ws[1] = funy.ws[1].init;
  foo.writeln;

#line 1
  auto bar = Funy!long(); /*
  auto bar = Funy();//* Error: */
  // source_file.d(2): none of the overloads of struct `source.Funy` are callable using argument types `!()()`
  // source_file.d(7): Candidate is source.Funy(alias T = size_t)
}

template Funy(alias T = size_t) {
  struct Funy {
    Word[] ws;
    struct Word {
      T[T.sizeof] letters;
      auto toString() {
        return cast(string)letters;
      }
    }
    //@disable this(this);
    this(A)(A[] arr) {
      size_t size, cell;
      foreach(data; arr) {
        if(cell == T.sizeof) {
          cell = 0;
          size++;
        }
        if(cell == 0) {
          ws ~= Word(0);
        }
        ws[size].letters[cell++] = cast(T)data;
      }
    }
    size_t length() {
      return ws.length;
    }
  }
}

Hadi onun bir özellik olduğunu düşünelim, şablon paremetresi olmadan şöyle varsayılan türü belirttiğimde:

template Funy(alias T = size_t) {
 //...

Neden bir helper() kolaylık işlevi yazmadan tür belirtme şartı koşulur? Çünkü ilgili satırı açınca 2 ve 7. satır hatalarını alıyorum.

Aslında foo'ya funy'i kopyaladığımı zannettikten sonra funy'de yapılan bir değişiklik nasıl oluyor da foo'yu etkiliyor?

Teşekkürler...

On Sunday, 5 February 2023 at 15:43:19 UTC, Ali Çehreli wrote:

Çok teşekkür ederim hocam, alias'ın bu özelliğini bilmiyordum. Şablon kısmında elim inanılmaz güçlendi. Gerçi enum'larımı bir yapıda toplama macerasına aşırı bir kartkısı olmadı ama o soru şekerlemeydi. Asıl konuyu Voldemort ile çözdüm:

void main()
{
  template Arr(alias T = size_t) {
    struct Word {
      T[T.sizeof] letters;
      auto toString() { return cast(string)letters; }
    }
    struct Result {
      Word[] ws;
      size_t length() { return ws.length; }
    }
    Result Arr(A)(A[] arr) {
      Result result;
      size_t size, cell;
      foreach(data; arr) {
        if(cell == T.sizeof) {
          cell = 0;
          size++;
        }
        if(cell == 0) {
          result.ws ~= Word(0);
        }
        result.ws[size].letters[cell++] = cast(T)data;
      }
      return result;
    }
  }
  import std.stdio : writeln;
  auto foo = Arr("deneme123");
  foo.writeln(": ", foo.length);
  // Result([deneme12, 3]): 2
}

Başka mevzular da var, çok meşgul etmek istemiyorum. Çözcem! 😉

Sevgiler, saygılar...

On Sunday, 5 February 2023 at 17:28:02 UTC, Ali Çehreli wrote:

Bu durum statik diziler için geçerli değilmiş. Örneğin şurada kopyalayıcı devre dışı (@disable) da değil kişiselleştirilme yapılmamış da:

void main()
{
    auto far = Sarr!()("DLANG'99".dup);
    auto bar = far;

    far[ 0 ] = 'C';
    assert(far[0] != bar[ 0 ]);

    auto hash = cast(size_t)far;
    assert(hash == 4123370121043463235);

    hash++; // ilk harfteki fark sadece 1
    assert(hash == cast(size_t)bar);
}

template Sarr(alias T = char)
{
    enum s = size_t.sizeof / T.sizeof;
    struct Sarr
    {
        union
        {
            size_t e;            
            T[s] arr;
        }
        static length = s;
        /*
        this(this)
        {
            arr = arr.dup;
        }//*/

        this(A)(A[] arr) in(s >= arr.length)
        {
            foreach(i, e; arr)
            {
                this.arr[ i ] = cast(T)e;
            }
        }

        auto toString() { return cast(string)arr; }
        auto opCast(CastT : size_t)() { return e; }
        auto opIndex(size_t i) { return arr[ i ]; }
        auto opIndexAssign(T a, size_t i) in(i < s)
        {
            return arr[ i ] = a;
        }
    }

Başarılar, sizi bilmem ama benim çok ihtiyacım var...

On Tuesday, 7 February 2023 at 23:54:44 UTC, Ali Çehreli wrote:

İyi olur hocam, örneğin bugün şu kodu yanlış okudum:

    auto arr = [ 0, 1 ];
    arr ~= ++arr[ $ - 1 ];

Nedense son elemanın bir fazlasını ekle diye okudum ve 8 kere tekrarlarsa tüm rakamların dizi içinde oluşacağını zannettim. Aslında öğrenciler için tam test sorusu:

void main()
{
    auto arr = [ 0, 1 ];
    while( arr[ $ - 1 ] < 9 ) {
        arr ~= ++arr[ $ - 1 ];
    }
    assert(arr == [0, 2, 3, 4, 5, 6, 7, 8, 9, 9]);

Cevap ise basit, tekli işleç yerine (opUnary ++), çiftli olanı (opBinary + 1) tercih edilmeli yoksa yukarda kanıtlandığı gibi yanlış sonuç çıkıyor 😀

Kolay gelsin...