On 10/20/22 12:23, Erdem Demir wrote:
> Niye exception modulunun içine koymuşlar acaba immutable yapmaklar
> exceptionların ne ilişkisi varki ?

Haklısın. Mutlaka bir ucundan mantıklı bir açıklaması vardır. :)

> 1 - Kodun ve datanın güvenirliği, bir değişken belli bir zaman sonra hiç
> değişmemek gibi bir özelliğe sahip olabilir.

Aslında çok karşılaşılan bir kavramdır. Hatta bazı programlama dillerinde değişmezlik varsayılır ve değiştirilebilen değişkenler örneğin 'mut' diye tanımlanır (mutable'ın kısası).

> 2 - Acaba immutable yaptığım diziyi derleme zamanında filan
> kullanabilirmiyim

Kullanabilirsin.

> ama ilk başta değişken bir diziyi immutable yaptığı
> için benim bu düşüncem mantıksız sanki.

O assumeUnique'in kullanımıyla ilgili. 'immutable' başka yollarla da ilklenebilir:

// Derleme zamanında ilklenen bir dizi
immutable int[] kareler = hesapla(10);

// Derleme zamanında ilklendiğinin kanıtı
// (pragma(msg), derleme zamanında yazar.)
pragma(msg, kareler[3]);

// Bu işlevin derleme zamanından haberi bile yok
pure
int[] hesapla(int adet) {
    import std.range : array, iota;
    import std.algorithm : map;

    return iota(adet).map!(i => i * i).array;
}

void main() {
    // hesapla()'nın tanımındaki 'pure' silinirse
    // aşağıdaki satır derlenemez.
    immutable imm = hesapla(20);
}

> Acaba benim düşünemediği gerçek hayatta başka kullanım örnekleri varmıdır?

immutable'ın bir başka kullanımı, iş parçacıkları (thread) arasında kilit gerekmeden gönderilebilmesidir. (immutable veri, otomatik olarak 'shared'dir.)

Ali

On Thursday, 20 October 2022 at 19:48:30 UTC, Ali Çehreli wrote:
> On 10/20/22 12:23, Erdem Demir wrote:

> O assumeUnique'in kullanımıyla ilgili. 'immutable' başka yollarla da ilklenebilir:
>
> // Derleme zamanında ilklenen bir dizi
> immutable int[] kareler = hesapla(10);
>
> // Derleme zamanında ilklendiğinin kanıtı
> // (pragma(msg), derleme zamanında yazar.)
> pragma(msg, kareler[3]);
>
> // Bu işlevin derleme zamanından haberi bile yok
> pure
> int[] hesapla(int adet) {
>     import std.range : array, iota;
>     import std.algorithm : map;
>
>     return iota(adet).map!(i => i * i).array;
> }
>
> void main() {
>     // hesapla()'nın tanımındaki 'pure' silinirse
>     // aşağıdaki satır derlenemez.
>     immutable imm = hesapla(20);
> }
>
> > Acaba benim düşünemediği gerçek hayatta başka kullanım
> örnekleri varmıdır?
>
> immutable'ın bir başka kullanımı, iş parçacıkları (thread) arasında kilit gerekmeden gönderilebilmesidir. (immutable veri, otomatik olarak 'shared'dir.)
>
> Ali

Ali Abi ben assumeUnique()'in kullanimini merak ediyordum senin cevabin bir kismi biraz daha immutable degiskenlerin nerede kullanildiklari hakkinda olmus sanki ben guzel soramadim herhalde sorumu. Immutable degiskenlerin onemi ve kullanim yerleri konusunda hemfikirim fakat insan assumeUnique()' e niye ihtiyac duysunki gibi bir sorun belirdi kafamda.

Aklima gelen tek kullanimda belirli bir sure mutable olan bir degisken belli bir zaman veya olay sonrasi yasaminin geri kalaninda immutable olmasi oldu acaba varsayimim dogru mu diye sormak istedim.

Bu arada immutable verinin shared oldugunu bilmiyordum cok guzel birsey ogrendim tesekkur ederim.

Erdemdem

On 10/21/22 04:28, Erdem wrote:

> assumeUnique()' e niye ihtiyac duysunki gibi bir sorun belirdi kafamda.

Salih "kaynağı `null` yapıp bağını koparıyor" diye açıkladı diye düşünmüştüm.

> Aklima gelen tek kullanimda belirli bir sure mutable olan bir degisken
> belli bir zaman veya olay sonrasi yasaminin geri kalaninda immutable
> olmasi oldu acaba varsayimim dogru mu diye sormak istedim.

Aynı değişken immutable olamaz çünkü o değişkene başka bir yerden erişilip erişilmemekte olduğu ve o başka yer tarafından da immutable olacağı bilinemez ve belirlenemez. Tabii dinamik bir dilde belirlenebilir ama D gibi diller böyle "acaba artık immutable mı" diye bilgileri çalışma zamanında bilmeye çalışmazlar.

void foo() {
  int[] dizi = [ 1, 2 ];
  bar(dizi);  // Ya, bar() bir kenara bir referans koyduysa

  artıkImmutableOlsun(dizi);  // Böyle bir işlem olabilseydi
  // dizi[0] = 42; derlenemezdi; güzel...

  // Ama belki de elemanlar bar()'ın sakladığı referans yoluyla
  // değiştirebilirlerdi
  // ...
}

O yüzden, aynı değişkeni immutable yapamıyoruz ama onu "cast ederek" yeni bir değişken elde edebiliyoruz. Bu, zaten dilde var:

void main() {
    int[] dizi = [ 1, 2 ];

    auto değişmez = cast(immutable)dizi;

    // Bunlar derlenemez; güzel:
    // değişmez[0] = 42;
    // değişmez = [ 3, 4 ];

    // Ama bu, 'değişmez'i de değiştirir:
    dizi[0] = 43;
    assert(değişmez[0] == 43);
}

Ne oldu? Kendimizi kandırdık. assumeUnique biraz daha güvenli: Var olan bir diziyi immutable diye cast ediyor ama yanlışlıkla değiştiremeyelim diye var olan diziyi null yapıyor:

import std.exception : assumeUnique;

void main() {
    int[] dizi = [ 1, 2 ];

    auto değişmez = assumeUnique(dizi);

    // Bunlar derlenemez; güzel:
    // değişmez[0] = 42;
    // değişmez = [ 3, 4 ];

    // Artık bu da DERLENEMEZ:
    // dizi[0] = 43;
}

Bu basit kavramdan başka bir şey değil. :)

> Bu arada immutable verinin shared oldugunu bilmiyordum cok guzel birsey
> ogrendim tesekkur ederim.

Olaya bir de çöp toplayıcı karışınca veriler iki thread arasında immutable olarak geçerler ve kimse ne kiliklemek için performans düşürür ne de birbirine "işim bitti; artık bana verdiğin veriyi geri verebilirsin" diye mesaj göndermek zorunda kalmaz. Aslında çok büyük kolaylıktır ama bunları da D'ciler olarak pek satamıyoruz. :/

Ali

On 10/21/22 07:37, Ali Çehreli wrote:

>      // Artık bu da DERLENEMEZ:
>      // dizi[0] = 43;

Onu yanlış söyledim: Derlenebilir ama program çalışma zamanında hatayla sonlanır (segmentation fault?).

Ali