On 4/4/22 07:34, Salih Dincer wrote:

> TDK milleti temsil etmiyor ve halk yararına fazla bir şey üretmiyor.

Yine de elimizdeki tek ortak nokta o. Dil çok kaygan ve çok hızlı değişiyor.

Daha dün bir arkadaşa "irtibat kuramıyor musunuz" dedim "hayır, kontağımız yok" dedi. :) Arapçayı herhalde yabancı dil diye kabul etmiyoruz ama İngilizce'yi (yoksa Fransızca mı?) yabancı dil diye mi kabul ediyoruz? :) Bir tane daha: Ben hâlâ "lokanta" derim ama kardeşim doğrusunun artık "restoran" olduğunu söylüyor.

Bir kurum "iletişim" filan gibi sözcükler düşünüp bizi ortada buluştursa... Bu gibi sözcüklerin bazıları da edebî kişilerden çıkıyormuş. Kurum onları da göze almalı.

Tabii öte yandan, serbest bırakıp herşeyi kabul etmek de var. İngilizce öyle yapmış ve o yüzden dünyanın en fazla sözcüğe sahip dillerinden birisi olmuş. Bunun sonucunda dilin özü kalmamış olsa da çok sözcüklü diller zengin olarak kabul ediliyorlar çünkü bizim aynı anlamda olduklarını düşüneceğimiz iki sözcük küçük anlam farklılıkları taşıyabiliyor.

Ama İsmail Emre haklı: Hem konu dışına çıktık hem de bu konu zaten hiç bitmez. :)

Ali

On Sunday, 3 April 2022 at 23:18:45 UTC, Ali Çehreli wrote:
> Her zaman olduğu gibi Türkiye saati ama ilk defa olarak 11:00...
>
> Bu arada, çok geç öğrendiğime göre, Türkiye'de saatler : ile değil . ile gösteriliyormuş. Acaba artık biliyorum diye 11.00 mı yazmalıyım yoksa öğrenmemişim gibi 11:00 mı? :)
>
> [...]

slide çok iyiymiş. moving average gibi sinyal duzgunlestirme gibi işlemler geldi aklıma. Bir ara bununla oynamalıyım :)

On Monday, 4 April 2022 at 19:35:22 UTC, Ferhat Kurtulmuş wrote:
> On Sunday, 3 April 2022 at 23:18:45 UTC, Ali Çehreli wrote:
>> Her zaman olduğu gibi Türkiye saati ama ilk defa olarak 11:00...
>>
>> Bu arada, çok geç öğrendiğime göre, Türkiye'de saatler : ile değil . ile gösteriliyormuş. Acaba artık biliyorum diye 11.00 mı yazmalıyım yoksa öğrenmemişim gibi 11:00 mı? :)
>>
>> [...]
>
> slide çok iyiymiş. moving average gibi sinyal duzgunlestirme gibi işlemler geldi aklıma. Bir ara bununla oynamalıyım :)

```d
  auto r = iota(5).slide(2)
           .map!((i) {
               // writeln(i, " için hesaplanıyor");
               ++hesapAdedi;
               return i;
             });
 ```
slide'i iotadan sonra cagirirsak hesapAdeti 4 oluyor

On 4/4/22 12:42, Ferhat Kurtulmuş wrote:

> ```d
>    auto r = iota(5).slide(2)
>             .map!((i) {
>                 // writeln(i, " için hesaplanıyor");
>                 ++hesapAdedi;
>                 return i;
>               });
>   ```
> slide'i iotadan sonra cagirirsak hesapAdeti 4 oluyor

Çünkü map() o durumda slide()'ın elemanları üzerinde işletiliyor ve slide() 4 eleman üretiyor: [0, 1][1, 2][2, 3][3, 4]

iota()'nın içine writeln yazabilsek, slide() tarafından 8 eleman kullanıldığını görürdük. (Yani, slide() iota()'nın front'unu 8 kere çağırı{r|ıyor olmalı}.)

Gösterdiğim kod basitleştirilmişti. (O yüzden i alıp i üretiyor. :) ) Asıl kodda slide() map()'ten sonra gelmek zorundaydı.

Ali

On 4/8/22 11:52, Salih Dincer wrote:

> bir benzeri chunks(2) ile yapılabiliyor:

Güzel.

> ```d
> import std;
>
> enum { x = 18, y = 2 }
>
> void main() {
>    int[y][] dizi;
>    10.iota(x).chunks(y).array

.array'i çağırınca sorun zaten ortadan kalkıyor çünkü doğrudan sonuçları saklıyorsun. (Ama senin örneğinde map olmayınca birden fazla işletilip işletilmediğini de göremiyoruz.)

.array çok iyi ve çoğu programda kullanılabilir ama iki sorunu var:

- Genel bir çözüm olamaz çünkü giriş sonsuz olabilir

- Sonsuz olmasa bile çok fazla olur ve .array'in ayırdığı bellek masraflı olabilir

Tekrar söylemek gerekirse, kılı kırk yarıyorum çünkü genel bir çözüm arıyorum.

>      .each!( (i, ref a) {

.each'in sayaç alan çeşidi olduğunu bilmiyordum. Teşekkür! :)

Anlaşılan, yalnızca bazı aralık türleriyle kullanılabiliyormuş. Örneğin, .array'i kaldırınca kullanılamıyor.

>            if(i) dizi ~= [
>              dizi[$-1][1],
>                      a[0]
>            ];
>            dizi ~= [
>              a[0], a[1]
>            ];//*/
>      });

Denemek gerek ama orada işler masraflı görünüyor çünkü acaba derleyici önce sağ tarafta bir dizi oluşturur da sonra dizi'ye mi ekler? Sanki şöyle de olabilir:

  dizi ~= a[0];
  dizi ~= a[1];

Tekrar söylemeye gerek yok ama aralıkların en büyük yararlarından birisi, elemanları dizilere yerleştirmenin gerekmiyor olması. Elemanları teker teker oluşturup kullanabiliyoruz. Ne güzel...

Ali

 Sohbete katılan tüm katılımcılara kendim adına teşekkür ederim. Türkçe forumumuzdaki insnanlarla tanışmış oldum. Beni açımdan güzel oldu.

 const anahtar kelimesinden başlayıp, dmd içinde henüz deneysel kullanımda olan import ile c-programlama dilinin dosyalarının d-programlama dilinde çağırılması ve ilginç bir özellik olarak c-programlama dilinde olmayıp da d-programlama dilinde olan kavramların c-programlarında da kullanılabilmesi ve c-programlama dilindeki kaynak dosyaların çeşitli işlemlerden geçirilip doğrudan dmd ile derlenebilmesinden bahsedildi.

 Sohbetin toplam süresi molalar dahil 3.5 saat kadardı.

On 4/10/22 05:15, Salih Dincer wrote:

> Bu sefer çok dallanıp budaklandı

Karaladıklarımız şunlar:

/*

  DDili sohbet - 10 Nisan 2022

- const

- Delegate parametreleri (const)

- Parametre olarak 'in'  -

- D'ye yeni eklenmekte olan ImportC. Bir meetup için hazırladığım denemeleri gösteririm.

- D'nin aralıkları .save() ile ForwardRange olarak kullanıldığında işlemler beklenmedik biçimde birden fazla kere işletilebilir.
*/

/+
import ali.cached;
import std.stdio;
import std.algorithm;
import std.range;

void main() {
  size_t hesapAdedi = 0;

  auto r = iota(10)
           .map!((i) {
               // writeln(i, " için hesaplanıyor");
               ++hesapAdedi;
               return i;
             })
           .filter!(i => i % 2)
           .slide!(No.withPartial)(2);

  writefln("%-(%s%)", r);

  writeln("Hesap adedi: ", hesapAdedi);
}
+/





/+
import std.stdio;

static const int[1024] arr;

immutable double pi = 3.14;

int[] arr2;

static this() {
  arr2 = new int[1024];
}

void main() {
  auto s = "merhaba";
  auto s2 = s.dup;
  int i;

  writeln(arr.ptr, '\n', s.ptr, '\n', s2.ptr, '\n', &i);

  // foo();

  // char* p = cast(char*)s.ptr;
  // p[0] = 'M';

  auto a = [ 1, 2 ];
  writeln(toplam(a, 100));
  writeln(a);

  immutable(char)[] z = "dünya";
  string g = z[0..$/2];
  z ~= 'a';

  immutable(char[]) z2 = "dünya";
  // z2 ~= 'b';

  immutable string z3 = z;
  static assert (is (typeof(z2) == typeof(z3)));
}

import std.algorithm;

int refAlanİşlev(ref const(int) i) {
  return i;
}

int toplam(const(int)[] a, ref const(int) b) {
  return a.sum + b;

  // Performans sırası:
  //
  // ++i; i++;  ns
  // void foo() { int i; int j; } // Süper ucuz: SP -= 8;
  // ++i; ---> inc(SP + 8)
  // ++j; ---> inc(SP + 4)
  //
  // arr[0];   *(arr.ptr + 0)  (yavaş mı? hayır, şimşek hızında)
  // foreach (e; arr)  // çok çok hızlı
  // foreach_reverse   // çok çok hızlı
  //
  // foo(42);  işlev çağrısı
  //
  // arr ~= [ a, b ];
  //
  // arr.dup;   malloc  ms
  //
  // File("hello").işlem;  100 ms  OS, FS, aygıt (ölüm)
  //

  // for (int i = 0; i < 10; ++i) {
  // }

  // // int geçici = i;
  // // ++i;
  // // geçici; // D yazımı değil

  // bar(++i); // Pahalı

  // bar(i++); // Ucuz
  // bar(i);
  // ++i;

  // for (int i = 0; i < 10; i++) {
  // }
}

void foo() {
  int i;
  // writeln(&i);

  foo();
}
+/







/+
void main() {
  const i = 42;
  foo(i);
  foo(i + 1);

  int j;
  bar(j);
  bar(1000);

  S s;
  zar(s);
}

int foo(in const(int) i) {
  return i + 1;
}

// in: 'scope const'
void bar(in int i) {
  // i += 100;
}
+/






/+
import std.stdio;

void main() {
  auto i = int(42);  // Kurucu (constructor)
  auto j = i;        // Kopyalayıcı (copy constructor)
  j = 42;            // Atama (assignment)

  // Yaşamı sonlanınca
  // __dtor(i);         Sonlandırıcı (destructor)

  // shallow copy
  auto b = foo();
  writeln("foo() sonra ", &b, ' ', b.ptr);

  foo();
}

string foo() {
  string result;
  writeln("x'ten önce  ", &result, ' ', result.ptr);
  result ~= 'x';
  writeln("x'ten sonra ", &result, ' ', result.ptr);
  // ...
  return result;
}

struct __string(T) {
  size_t length;
  immutable(T) * ptr;
}
+/





/+
struct S {
  int i;
  int[] arr;

  // kurucu
  // arr'i sahiplenir
  this(int i, int[] arr) {
    this.i = i;
    this.arr = arr;
  }
/+
  // post-blit (kopyalayıcıyı ezer)
  this(this) {
    writeln("post-blit");

    // Shallow copy ile başlar işlemeye
    // this.i = that.i;
    // auto kopya = that.arr;

    arr = arr.dup;
  }
+/
  // kopyalayıcı (post-blit tanımlanmışsa kullanılmaz)
  this(ref return scope const(S) that) {
    import std.stdio;
    writeln("S kopyalanıyor");


    // Derleyicinin shallow copy'sinin aynısı:
    this.i = that.i;
    auto kopya = that.arr.dup;
    this.arr = kopya;

    writefln!"%s --> %s"(that.arr.ptr, kopya.ptr);
  }

  ~this() {
    writeln(arr.ptr, " sonlanıyor");
  }
}

import std.stdio;

void main() {
  auto s = S(42, [ 1, 2 ]);
  writeln("önce  ", s);

  auto s2 = s;
  s2.arr[0] = 100;

  writeln("sonra s  ", s);
  writeln("sonra s2 ", s2);
}
+/





/+
// pragma(inline)
// int foo(int i) {
//   return i * 2;
// }

int main(string[] args) {
  const int a = 2;

  auto f = (int i) const {
    // const a_ = a;
    // a_ = 42;

    // a = 42;
    return i * a;
  };

  auto bir_sey = true;
  const d = {
    if (bir_sey) {
      return 100;

    } else {
      import std.stdio;
      writeln("else");
      return cast(int)(args.length) + 3;
    }
  }();

  const e = (bool b) => b ? 3 : 7;
  const g = e(bir_sey);
  assert(g == 3);

  pragma(msg, typeof(f));
  return f(0);
}
+/







// import std.stdio;
extern(C)
int printf(const scope char*, ...);

struct FILE {
  // ..
}

// htod
// dstep
// vs.

// c_kutuphanesi.h ->
// c_kutuphanesi.i    (C preprocessed)
import c_kutuphanesi;

void main() {
  printf("%s %d\n", "merhaba".ptr, 42);
}

Ali