Merhaba Ali Hocam,

Önceki başlıkta şöyle bir cevabınız vardı:

On Tuesday, 4 October 2022 at 18:36:53 UTC, Ali Çehreli wrote:

Yabancı forumda @property kullananlar oylanırken (sanırım Rikki Cattermole açmıştı) 4. sayfanın sonunda, mealen (çeviride hata olabilir) şöyle özetlendi:

02/10/2022 03:12'de Dom DiSc şunu yazdı:

Tabi şu an büyük tartışma konusu çünkü kodların kırılmaması için kullanmayın deniyor. Ama en basitten std.array.Appender'da onlarla dolu. Hatta Phobos'a baktığımızda her yerde karşınıza çıkabilir. Neyse bu ayrı bir konu...

Ali hocanın bahsettiği, kelimelere verdiğimiz anlamı haketmesi veya sahip olduğumuz kazanımları karşılaması açısından iyi seçim yapmak gerekiyor. Yoksa aradan uzun zaman geçtiğinde siz bile anlamayacaksınız :)

Hocam bilmiyorum konuyu doğru yerden mi başlattım. Size cevaben ise ben kendi değişkenlerime doğrudan erişilmeyip getter/setter özelliklerini kullanmaya bayılıyorum. Ama D bu konuda bizim elimizden tutmuyor ve herkes bildiğini okuyor tabi :)

Aslında .length olayı oturdu ve sanırım herkes kullanıyor. Ama ben bazen ona parametre aldırıyorum. Çünkü kendi türümde bana neyin uzunluğunu vereceğini iyi tasarlayamıyorum. Bir sürü de .length olmasın diye varsayılan parametre ile birlikte kullanıyorum. Eğer T.sizeof gibi bir şeyi döndürmesini istersem atıyorum şöyle bir şey:

auto length(bool bitLength = false) {
  size_t result;
  // ...
  return result;
}

Yukardaki gibi olan bir işlevi kendiTürüm.length(true) şeklinde kullanıyorum. Tabi bu basit olan ve şu an aklıma gelen. Sanırım enum'lar kullanmıştım. Şimdi hatırlayamadım ama konusu geçerse örnek kodları bulup paylaşırım.

Eminim yukardaki verdiğim örneğe şöyle bir gülümsediniz :)

Ben de anlamsız buluyorum ve gerçi böyle bir işlev yazmamışımdır (sanırım!) yani belirsizlik var çünkü. Bu durumda bitLength() isminde ayrı bir işlev gerekir. Neyse çok uzattım.

Sevgiler, saygılar...

On Wednesday, 5 October 2022 at 23:28:37 UTC, Ali Çehreli wrote:

  int x;
  int y;
}

struct Nokta {
private:

  int x_;
  int y_;

public:

  int x() const { return x_; }
  int y() const { return y_; }
}

Peki hocam, 2 sorum var:

Birincisi, aşağıdaki gibi 20 küsür satırlık bir yapıda getter/setter işlevlerine ihtiyacımız yok muydu?

struct Point
{
  union
  {
    uint points;
    ushort[2] p;
  }
  // getters:
  uint x() { return p[1]; }
  uint y() { return p[0]; }
  // setters:
  auto x(ushort n) { p[1] = n; }
  auto y(ushort n) { p[0] = n; }

  string toString()
  {
    import std.format;
    return format("%08X", points);
  }
} unittest {
  auto n = Point(uint.max);
  assert(n.points == 0xFFFF_FFFF);
  assert(n.x == ushort.max);
  assert(n.y == ushort.max);
}

Vardı çünkü ben grafik çalışırken böyle şeyleri elimin altında tutup template marifeti ile kullanmayı seviyorum. D ne yapıyor (?) peki @property konusunda tembellik yapıp tanımlamıyor (!) ve bana bunu otomatik veremiyor, beni serbest bırakıyor :)

İkincisi, bunun setter işlevlerini return'lü olarak şu şekilde kurgulasaydık avantajımız ne olurdu?

  // setters:
  auto x(ushort n) { return p[1] = n; }
  auto y(ushort n) { return p[0] = n; }

Aslında cevabı biliyorum, çünkü aynı satırda etkileşebilir (örneğin ekrana yazabilir) ya da aşağıdaki assert'de olduğu gibi hemen tek satırda doğrulayabilirdik:

import std.stdio;
void main()
{
  auto point = Point();
  with(point) {
    x(10).writeln; // "10"
    y(11).writeln; // "11"
    points.writefln!"%08X"; // "000A000B"
  }
  assert(point.x(1) + point.y(9) == 0x0A);
  point.writeln; // "00010009"
}

Yanıtlarınız için teşekkürler, şu sıralar çok kod yazamıyorum. Geç cevap için üzgünüm yoksa yazışacak çok konu var. :)

Sevgiler, saygılar...

On Sunday, 9 October 2022 at 20:15:08 UTC, Salih Dincer wrote:

struct Point
{
  union
  {
//...

Aslında D, o kadar güzel bir dil ki 10 satırada da bir union kurarak benzer şeyler yapılabiliyor. İşte 2 eksiği var ve birincisi yakında olacak sanırım:
1.'si kısa yazımı desteklemesi ki aşağıdaki kodda süslü parantez ve return yerine doğrudan yazabileceğiz,

2.'si, şu Allah'ın cezası @property'nin hakkını verseler ya (!) neyse şimdi ağzımı açmıyorum çok fazla. Yoksa Walter'a çok söylenecek söz var :)

union Point
{
  uint points;
  ushort[2] p;

  @property x() { return p[1]; }
  @property y() { return p[0]; }

  @property x(ushort n) { return p[1] = n; }
  @property y(ushort n) { return p[0] = n; }

/* Şahsen şunu yapabilmek isterdim:

  @property {
    x(ushort n) => p[1] = n;
    y(ushort n) => p[0] = n;
  }
*/
}

import std.stdio;
void main()
{
  with(new Point())
  {
    x = 10;
    y = 11;
    points.writefln!"%08X"; // "000A000B"
    assert( x(1)
          + y(9)
        == 0x0A);
  }
}

Başarılar...

On Sunday, 9 October 2022 at 22:59:30 UTC, Ali Çehreli wrote:

struct Point
{
   union
   {
     uint points;
     ushort[2] p;
   }
   // getters:
   uint x() { return p[1]; }
   uint y() { return p[0]; }

Hocam bu soruyu cevaplamamışım. Kusura bakmayın ve o gün neyi katettiğimi hatırlamıyorum. O yüzden özür dilerim ama isterseniz altı dolu olan benzer bir konuyla devam edelim:

https://forum.dlang.org/post/nweemnsoctbmhhttkvgk@forum.dlang.org

Sevgiler, saygılar...

On Wednesday, 5 October 2022 at 23:05:27 UTC, Salih Dincer wrote:

....

Bu özellik konusuna ben de ilgili olduğumdan bu konuyu canlandırmakta uygunsuzluk görmedim.

Bu konuyla ilgili benim düşüncemi özetleyen en güzel yazı
"
I must say that I'm totally against introducing so-called properties
to Java records. So far, Java is a very clear language. If I see x = foo.bar, I definitely know that it's a very simple field dereference
and assignment action. By no means, this line may perform a network
request or a database query. So when debugging, I don't expect
anything funny with this line of code. I don't need to navigate to
foo or bar definition to understand what's going on here. It's a
great feature, compared to other modern languages where many things
could be overridden and it's impossible to understand what's going on,
simply by looking at the code line. I don't want to lose this feature
in Java for the sake of saving two characters.
"
biçiminde ele alınmış gözülüyor. İlgili bağlantı: https://mail.openjdk.org/pipermail/amber-dev/2020-September/006657.html

Alıntılanan başlıktaki sav UFCS özelliği için de geçerli. Kısaca bir atama işleminde bir yan etkinin olmayacağını bilmek çok rahatlatıcı. Ya da bu aslında işlev mi diye adına güvenmemek ya da tanımına gitme yükümlülüğünde olmamak.

Özellik'lerin uygun bir biçimde dile eklenmesi bence ayrıca dile karmaşıklığı getirecektir.
Kurma ve alma belirteçlerini gerçekleştirken almanın kurmadan kısıtlayıcı olması denetimi, ön tanımlı alma değer atama gibi belki ilerde gelecek pek çok özellik dili karıştıracaktır.

Yine buna karşın bence çok kışkırtıcı ve var olsa en çok kullanılacak olanak olacağına da ayrıca eminim :-)

On Friday, 16 December 2022 at 23:43:37 UTC, Ali Çehreli wrote:

İşlev yükleme ve biraz aldatıcı olsa da tek parametreli işlevi değişken gibi eşitlemeyi, verdiğiniz örnekteki gibi kullanabilmeyi seviyorum. Bir süre getter/setter (alma/kurma) özelliklerini bu şekilde kullanabiliriz ama D dili o kadar güçlü bir dil ki sizi diğer olanakları kullanmaya teşvik ediyor. Tamam, eksik yanları da yok değil hani:

C#'daki gibi, örneğin bir sınıfın üyelerini yazarken hemen yanına (hatta otomatik) alma/kurma özelliklerini yerleştirmesi çekici gözüküyor. İyi programcılar tembel olduğuna göre tembeller için pekala bir attributes gibi @GetSet şeklinde bir şey hiç de fena olmazdı. 😀

On Friday, 16 December 2022 at 22:57:03 UTC, Can Alpay Çiftci wrote:

Sorun değil çünkü güzel ve dallanıp budaklanan bir konu. Üstelik @property'nin topu topu 3 etkisi varken (biri kod yazarken kodlayan için bilgi vermesi) şaşırtıcı derecede sayfalar dolusu tartışmalar yapılır. En hacimlileri senelerdir yabancı forumda alevlenmekte ve muhafaza edilmektedir. Bir tanesini şurada işledim ve yinelemekte fayda var:

https://forum.dlang.org/post/nweemnsoctbmhhttkvgk@forum.dlang.org

Bu bulduğum 3. etkisi, önceki iletimde yönlendirdiğim alias ... this ile açığa çıkıyor ve bence bu bir bug değil ama az önce bulduğum ve private ile anlaşamayan bir bug var. Yeterince emin olunca değineceğim.

Şimdi alma/verme konusunda ve D dilinin güçlü yanlarını da kullanarak bir örnek paylaşacağımz az sonra:

(HAZIR ASLINDA, YENİ BİR İLETİ İLE ADIM ADIM GİDELİM...)

On Saturday, 17 December 2022 at 07:39:50 UTC, Salih Dincer wrote:

Şimdi paylaşacağım kod, eski ve yeni neredeyse her sürümde çalışıyor, denemenize bile gerek yok çünkü tüm çıktı "A (ok)\nC (ok)" şeklinde. Yani kanıtladığı sadece basit işleç yükleme olanakları ile hayatınızı kolaylaştırması. Ben bunu şu örnekte denedim:

void main()
{
  class Öğrenci {
    Nx!char sınıfı;
    Nx!uint numarası;

    this(char s, uint n) {
      sınıfı(s);
      numarası(n);
    }
  }
  auto ali = new Öğrenci('A', 741);
  assert(ali.numarası == 741);
  ali.numarası = 742;
  ali.numarası += 8; // artık 750

  auto can = new Öğrenci('C', 746);
  assert(can.numarası == 746);
  can.numarası = 747;
  can.numarası += 3; // artık 750

  import std.stdio;
  foreach(test; [ali, can]) {
    assert(test.numarası == 750);
    test.sınıfı.writeln(" (ok)");
  }
}

Bu aşağıdaki Nx yapısı benim kullandığım, elimin altında olan bir şey. Tabi sarmanın sadeleştirilmiş sürümü bu, belki ilginizi çekebilir istediğiniz yerde diğer işleçleri de yükleyip kullanabilir ve alma/verme özelliklerini kişiselleştirip farklı kopyalar oluşturabilirsiniz:

// Nx Base:
static struct Nx(T) { // kullanmak için Nx! eklenir
  T değer;

  alias değer this;         // [a] getter
  @property opAssign(T x) { // [b] setter
    return değer = x;
  }
  alias opCall = opAssign; /* hack: `opAssign` methods
                      are not used for initialization,
                      but for subsequent assignments
  [c] incrementor:         */
  @property opOpAssign(string op: "+")(T x) {
    değer = değer + x;
  }
}