April 04
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

April 04
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 :)
April 04
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
April 04
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

April 08

On Sunday, 3 April 2022 at 23:18:45 UTC, Ali Çehreli wrote:

>

[...]

  • D'nin aralıkları .save() ile ForwardRange olarak kullanıldığında işlemler beklenmedik biçimde birden fazla kere işletilebilir.
import std.stdio;
import std.algorithm;
import std.range;

void main() {
  size_t hesapAdedi = 0;

  auto r = iota(5)
           .map!((i) {
               // writeln(i, " için hesaplanıyor");
               ++hesapAdedi;
               return i;
             })
           .slide(2);

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

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

Yukarıdaki programdaki .slide(2), "sliding window" anlamına geliyor ve elemanları bu örnekte ikişer ikişer gezmeye yarıyor. Elemanlar 0..4 aralığında olduğundan, genişliği 2 olan kayan pencereler şu elemanları gösterecekler: önce 0 ve 1, sonra 1 ve 2, vs. Bu pencereleri programın çıktısında görüyoruz:

[0, 1][1, 2][2, 3][3, 4]
Hesap adedi: 8

[...]

Konuların üzerinden geçmeyi sabırsızlıkla bekliyorum. Ama önce kendim implement etmek istedim (en azından ikili versiyonunu). Görünüşe bakılırsa bir benzeri chunks(2) ile yapılabiliyor:

import std;

enum { x = 18, y = 2 }

void main() {
  int[y][] dizi;
  10.iota(x).chunks(y).array
    .each!( (i, ref a) {
          if(i) dizi ~= [
            dizi[$-1][1],
                    a[0]
          ];
          dizi ~= [
            a[0], a[1]
          ];//*/
    });
  dizi.writefln!"%(%s\n%)";
}

Sevgiler, saygılar...

April 08
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

April 10
 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ı.
April 10

On Sunday, 10 April 2022 at 11:22:31 UTC, İsmail Emre ARIKAN wrote:

>

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

Evet, yaklaşık 3 saat su gibi geçti diyebilirim. Geçmişte "eee,başka ne konuşsak?" dediğimizi hatırlar gibiyim. Bu sefer çok dallanıp budaklandı diye içinden çıkamadığımız bir an bile oldu :)

Hemen kıvrak bir hareketle, D'nin herşeyi kapsayan /+ +/ comment işaretleri ile bir çırpıda yeni konuya geçtik. Toplamda 2 ya da 3 konu vardı sanırım, ama bunları recursive işlettiğinize 2, 4, 8, 12 ... artık saymakta zorlandığımız bir seviyeye ulaştı...

Ali hocaya aşırı yük bindiğini fark ettim. O yüzden, konuları aramıza paylaşma fikiri aklıma geldi şimdi. Tabi bunu hemen sonraki aya değil Haziran ortalarında (sanırım ayın 12'si 2. pazara) denk getirebiliriz. Aktarmalı yöntem ideal olabilir mi? Örneğin:

Mayıs ayı için konuları önden yüklemeli biriktiririz. Yani kesinlikle tek günde bitmeyecek adette (5-8 konu) başlıklarımız olur. Sonrasında kalanları kim talipse ev ödevi gibi üstlenir. Zaten ilk yüklemeyi yapınca her seferinde sonraki aya konu kalacak ve bir süre sonra herkesin söz alacağı güzel bir ortam oluşabilir.

Eee bir de artık kayıt mı etsek, başkaları da faydalansın?

Başarılar...

April 10
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

April 13

On Monday, 11 April 2022 at 02:58:15 UTC, Ali Çehreli wrote:

>

Karaladıklarımız şunlar:

// htod
// dstep
// vs.

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

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

Ali

Ali hocanın bahsettiği importC özelliği için henüz yapım aşamasında olan bir tanıtım sayfası oluşturulmuş: https://dlang.org/spec/importc.html

Next ›   Last »
1 2