Thread overview
Programlamadaki Yeni Konseptleri Açıklayalım
Jul 11, 2022
dunecourser
Jul 11, 2022
dunecourser
Jul 11, 2022
Ali Çehreli
Jul 11, 2022
dunecourser
Jul 11, 2022
Ali Çehreli
Jul 11, 2022
dunecourser
Jul 12, 2022
Ali Çehreli
Jul 11, 2022
Salih Dincer
July 11, 2022
D'nin ne olduğu belli, her türlü paradigmadan az da olsa çok da olsa içinde barındırıyor. Biz de bugün az olanları konuşalım.

Anlatılmasını istediğim özellikler:

1. Optional ve Nullable
2. Ownership ve Borrowing, dolayısıyla @live da
3. Pattern Matching
4. Sum Type
5. Algebraic Data Types
6. while (auto n = expression)
7. Async/Await

<defer>

İfadelerin kendi bağlamsal sınırlarından çıkmadan hemen önce işletilicek ifadeleri temsil eder. Alt alta yazılan defer'ler stack gibi çalışır. Sadece betterC ile @live için değil, standart D kodu için dahi çok işe yararlı olurdu diye düşünüyorum.

-----
struct Yapı @betterc
{
    const(char)[] isim;

    auto kur()
    {
    	import allocator;

        auto yapı = allocator.Allocator.kur(Yapı);
        defer allocator.destroy(yapı);

        yapı.isim = "Yapı";
        defer allocator.free(yapı.isim);

        return yapı;
    }
}
-----

Bunun eşdeğeri şudur:

-----
auto kur()
{
    auto yapı = allocator.Allocator.kur(Yapı);
    yapı.isim = "Yapı";

    defer allocator.free(yapı.isim);
    defer allocator.destroy(yapı);

    return yapı;
}
-----
July 11, 2022
On Monday, 11 July 2022 at 04:39:34 UTC, dunecourser wrote:
> Bunun eşdeğeri şudur:
>
> -----
> auto kur()
> {
>     auto yapı = allocator.Allocator.kur(Yapı);
>     yapı.isim = "Yapı";
>
>     defer allocator.free(yapı.isim);
>     defer allocator.destroy(yapı);
>
>     return yapı;
> }
> -----

Şu kısım defer'siz...
July 10, 2022
On 7/10/22 21:39, dunecourser wrote:

> 1. Optional ve Nullable

İkisi de dil olanağı değil. Nullable, standart kütüphanede var:

  https://dlang.org/library/std/typecons/nullable.html

Optinal yazan da olmuş:

  https://code.dlang.org/packages/optional

> 2. Ownership ve Borrowing, dolayısıyla @live da

D'de yok. Walter @live ile halledilebileceğini düşünüyor; bunun hiçbir zaman işlemeyeceğini savunan sağlam D'ciler var. Konu belirsiz... :)

> 3. Pattern Matching

Dil olanağı değil ama benzer şeyler yapılabiliyor. Örneğin, std.concurrency.receive, mesajın türüne uyan kodu işletir:

  https://dlang.org/library/std/concurrency/receive.html

> 4. Sum Type

Yine dil olanağı değil. Geçen sohbetlerimizin birinde üzerinden geçmiştik. Bana çok kullanışlı geliyor ve 'pattern matching'e çok daha benziyor:

  https://dlang.org/phobos/std_sumtype.html

(Not: Bir kaç hafta sonraki DConf konuşmamda SumType'ın nasıl gerçekleştirilmiş olduğunu anlatmaya çalışacağım. Tabii önce öğrenmem gerekiyor. :-O )

> 5. Algebraic Data Types

O konu beni aşıyor çünkü ben SumType'ın başka ismi sanabiliyorum ama fonksiyonel programlamada başka anlamı olduğunu da biliyorum.

> 6. while (auto n = expression)

Çok nadir ihtiyaç duyduğum ama ara sıra istenen bir olanak. 'if' ile birlikte yeni eklenmiş olmalı:

void main(string[] args) {
  if (auto a = args.length) {
    while (auto b = args.length == 42) {
      // ...
    }
  }
}

> 7. Async/Await

Vision belgesinde gelecekte eklenebileceği söyleniyor:

  https://github.com/dlang/vision-document

>
> <defer>
>
> İfadelerin kendi bağlamsal sınırlarından çıkmadan hemen önce işletilicek
> ifadeleri temsil eder. Alt alta yazılan defer'ler stack gibi çalışır.
> Sadece betterC ile @live için değil, standart D kodu için dahi çok işe
> yararlı olurdu diye düşünüyorum.

defer'den bazı farkları olabilir ama D'de üç ayrı durumda işletilecek biçimde şunlar var:

  scope(exit)
  scope(success)
  scope(failure)

Orada şunun İngilizcesi'ne de bağlantı vermişler:

  http://ddili.org/ders/d/scope.html

Ali

July 11, 2022
On Monday, 11 July 2022 at 06:01:49 UTC, Ali Çehreli wrote:
> On 7/10/22 21:39, dunecourser wrote:
>

Aslında bu kavramların D'de olup olmadığını değil ya da hangi durumlarda D'de kullandıldığını değil, örnekler vererek ne işe yaradıklarını, ne olduklarını ve nasıl kullanabileceğimizi yazalım demiştim. Siz de o listeye bir şeyler ekleyebilirsiniz ama ana amaç şu: while (n = expression) ifadesini anlamıyorum ya da nerede kullanacağımı kestiremiyorum diyelim, senaryo bol, onun üzerine D'yi kullanrak tartışabilmek. O yüzden defer'i kendim yazdım.


July 10, 2022
On 7/10/22 23:12, dunecourser wrote:
> On Monday, 11 July 2022 at 06:01:49 UTC, Ali Çehreli wrote:
>> On 7/10/22 21:39, dunecourser wrote:
>>
>
> Aslında bu kavramların D'de olup olmadığını değil

Ben de yanlış anladığımdan şüphelenerek yazmıştım zaten. ;)

> Siz de o listeye bir şeyler ekleyebilirsiniz

İlerisi için konu listesiyse tamam. Yoksa hepsini aynı başlık altında geçersek birbirine karışır ve konu çok uzun olur. Örnek olsun diye ;) while konusuna burada devam ediyorum.

Ben tanım içerin while kullanımını anlamıyorum. Bence yarardan çok zarar getirir çünkü normal while'da parantezin içi her döngüde işletildiği halde değişken tanımlandığında tek kere mi işletilir. Herhalde öyle olmaz ama değişken mi tek kere ilklenir?

Denedim: Hayır, değişken her döngüde tekrar atanıyor. Yani tek yararı şu mu:


// Şunun yerine:

  while (args.length > 10) {
    foo(true);
  }

// Şunu mu yazmak istiyoruz?

  while (const dahaArgVar = args.length > 42) {
    foo(dahaArgVar);  // <-- TEK FARK
  }

while'a girdiğimize göre dahaArgVar'ın değeri 'true'dur zaten. Değer mi?

Galiba anlıyorum: bool dışında bir şeyse uzun ifadeye bir isim verebiliyoruz:

void main(string[] args) {
  while (const birİfade = args.length * 2) {
    foo(birİfade);
  }
}

auto foo(size_t falanca) {
}

O programda anlamlı çünkü bu sefer birİfade 'bool' değil. Anladım ama bence değmezmiş. :/

> ama ana amaç şu: while (n =
> expression) ifadesini anlamıyorum ya da nerede kullanacağımı
> kestiremiyorum diyelim, senaryo bol, onun üzerine D'yi kullanrak
> tartışabilmek.

Tamam, aklımıza gelen sorular vs. için yeni konu açabiliriz.

Ben yanlış anladım çünkü "D'yi tanımak istiyorum, şu olanakların durumu nedir" diye anladım ve hızlıca bir durum özeti verdim.

> O yüzden defer'i kendim yazdım.

Yani, "defer olsaydı şöyle kullanırdık; ama yok; o yüzden şöyle yapmalıyız" gibi mi?

Ali

July 11, 2022
On Monday, 11 July 2022 at 06:40:26 UTC, Ali Çehreli wrote:
> On 7/10/22 23:12, dunecourser wrote:
> > On Monday, 11 July 2022 at 06:01:49 UTC, Ali Çehreli wrote:


> O programda anlamlı çünkü bu sefer birİfade 'bool' değil. Anladım ama bence değmezmiş. :/

İşte, buna benzer bir yorumu Google'da aratsak bulamayız. Bu arada, bence de değmez. :)

> Tamam, aklımıza gelen sorular vs. için yeni konu açabiliriz.

Merak edilenler başlığı altında bu listenin toplanması daha iyi olur diye düşünüyorum. Olur da biri bu tür anlaması zor ya da zahmetli, hatta bunlar olmasına bile gerek yok, falanca üşendirici kavramlarla karşılaşırsa en azından elinde bir konusu ve birçok örneği olur. Zaten forumumuz konuların ismine göre değil anahtar kelimelere göre arama yapıyor. Ama daha detaylı anlatmak istersek tek tek konu açarız elbette. :)

Gene de ben aksi söylenmedikçe sizin önerdiğinizi uygulayacağım, sorun değil.

> Yani, "defer olsaydı şöyle kullanırdık; ama yok; o yüzden şöyle yapmalıyız" gibi mi?
>

Biraz öyle. Ama D'de tek bir yöntem yok. O yüzden tam olarak değil. Şöyle izah edeyim: D'nin modern olanaklar söz konusu olduğunda gerçekten de geri kaldığı yerler var, yok değil. Bu kavramların tanımlarını, diğer dillerde nasıl kullanıldıklarını, ne işe yaradıklarını tartışıp, şayet D'de olsalardı nasıl olurlardı, ama D'de yoklar o yüzden onlar yerine kullandığımız/kullanabileceğimiz olanaklar o kavramları temsil etmeye yetiyor mu, onu anlayalım. D'nin üstün değil zayıf yönlerini keskinleştirelim ki zamanı gelince kesilmesi gerekeni zahmetsizce kessin.

Örnek:

Zig dosyaları falanca built-in fonksiyonlar aracılığıyla derleme anında okuyormuş, işte efendim fazladan zahmete girmeksizin lokal importlar gerçekleştirebiliyormuş. Bir de isimsiz structları ve type türünü kullanarak fazladan bir syntax kullanmaksızın generics elde edebiliyormuş. Biz de yaparız, hatta daha iyisini.

a. Zigvari import'lar D'de olsaydı:

void modülOkut()
{
    immutable Module algorithm = static import!"std.algorithm";

    bool işlem = algorithm.any!(e => e < 5)([1, 2, 3, 4, 5]);
}

b. D'de yok, bunu syntax ve işlemleri mixinle uygulayabiliriz ama derleme süresini delicesine uzatır ve kullanışsız olurdu. Ama muhtemelen D'de de yapabiliriz:

void modülOkut()
{
    // Hayali örnek kod, detaylı olması şart değil
}

a. Zigvari generics D'de olsaydı:

type topla(type T, T[] sayılar)
{
    // Örnek kod
}

topla(ulong, [1, 2, 3, 4, 5]); yada ulong.topla([1, 2, 3, 4, 5]);

b. D'de nasıl bir benzerini yapabiliriz, gerçi bizim templatelerimiz bundan çok daha iyi, ama basit kalmak istediğimizi varsayalım, belki de betterC ile çalışıyoruzdur kim bilir.

auto topla(Type T, Type sayılar)
{
    // Örnek kod
}

topla(T: Type!ulong, sayılar: Type!(T)([1, 2, 3, 4, 5]));


Verdiğim örnekler çirkin, aceleci ve işe yaramaz ama bunu daha sonra başka bir başlıkta daha dikkatli yazarım. Şimdilik konu istediğim yere çekilse yeter de artar bile. :)
July 11, 2022

On Monday, 11 July 2022 at 04:39:34 UTC, dunecourser wrote:

>

D'nin ne olduğu belli, her türlü paradigmadan az da olsa çok da olsa içinde barındırıyor. Biz de bugün az olanları konuşalım.

Anlatılmasını istediğim özellikler:

  1. Optional ve Nullable
  2. Ownership ve Borrowing, dolayısıyla @live da
  3. Pattern Matching
  4. Sum Type
  5. Algebraic Data Types
  6. while (auto n = expression)
  7. Async/Await

defer>

Bu başlıkta D ile alakası olmayan (defer vb.) şeyler vardır! Üstelik forum ile doğrudan alakalı olmadığı için D öğrenmeye çalışanları etkileyebilir/kafasını karıştırabilir. Ama amaç 2 dili karşılaştırmaksa gözlerin aşina olmadığı değişik while() ile başlayalım :)

Ziglang'da (C'yi geliştirmekten çok dağınık olmuş) iki parçaya bölünerek yapılan döngü, birçok programlama dilinde (tabii ki D'de) daha basit yapılabilirdi:

var i: i32 = 0;
while (i < lines_to_fill) : (i += 1) {
  insertGarbageRowAtBottom(t);
}

Hem 6. soruya cevap olsun hem de D'de while() döngüsü C ile ne kadar uyumlu olduğunu görelim. Çünkü bu yaptıklarımızı gerekirse C ile derlenecek şekilde yazabilirdik:

import std.stdio;

int sesliMi(immutable(char) c)
{
  switch(c)
  {
    case 'a', 'e', 'i', 'o', 'u': return 3;
    case 'A', 'E', 'I', 'O', 'U': return 2;
    default: return 1;
  }
}

void main()
{
  string str = "Kuzey Amerika Devletleri: CAN, USA, MEX";
  size_t b = 0; //başlangıç

  while(int sonuç = str[b].sesliMi)
  {
    if(sonuç > 1)
    {
      if(sonuç == 2) write(':');/*
      if(sonuç == 3) write('.');//*/
    }
    else str[b].write;

    if(++b == str.length) break;
  }
  writeln;
} /* ÇIKTISI:
Kzy :mrk Dvltlr: C:N, :S:, M:X
*/

Önce bir lexer yazdığınızı hayal edin. Ahh, şu döngüyü devam ettiren koşulun ne olduğunu biri bana söylese diyeceksinizdir. Aslında bu örneği, basit bir foreach() içine switch case bloğunu yerleştirerek de yapabilirdik. Ama belki amacınız sadece sesli harfler elemek değildir ve 1'den büyük döngüyü devam ettirebilecek bir çok durum vardır.

Yukardaki kodları kurcalayarak, bu durumları (örneğin ben büyük sesliler yerine : işareti basmasını istedim) görebilir ve hatta yenilerini (örn. noktalama işaretleri, sessiz harfler vb.) elemeyi sağlayabilirsiniz.

Dip Not: Elbbette bu sadece bir örnek. Yani amaç, ne "sidik yarışı" ne de D gibi güçlü bir dilde daha basit yapılabilecek işin zorunu göstermek. Ziglang ise konumuz dışı kalmasını salık veririm. O yüzden daha fazla uzatmıyorum.

Başarılar...

July 12, 2022
On 7/11/22 10:16, dunecourser wrote:

> Merak edilenler başlığı altında bu listenin toplanması daha iyi olur
> diye düşünüyorum.

Eskiden (ddili.org/forum'da iken) çok sayıda forum başlığımız vardı. Zamanla bunun pek yarar getirmediğini düşünmeye başladım. O yüzden, eski forumu buraya aktarırken forumları ikiye indirdim. (Ama yaptığım hatalar nedeniyle eski mesajlar yanlış yerlere gittiler. Olsun... :) )

> elinde bir konusu ve birçok örneği olur.

Bence forumun amacı dışında kalıyor. Onlar için bir yazı veya kitap yazılabilir.

> D'nin üstün değil zayıf yönlerini
> keskinleştirelim ki zamanı gelince kesilmesi gerekeni zahmetsizce kessin.

Mantıklı.

Ali