Değişmez nesneleri kullanırken çoğu tavuk ve yumurta problemini çözmek için uygulanabilecek belirli bir tasarım stratejisi var mı?

Bir OOP geçmişinden (Java) geliyor, kendi başıma Scala öğreniyorum. Değişken nesneleri tek tek kullanmanın avantajlarını kolayca görebilsem de, birinin böyle bir uygulamanın tamamını nasıl tasarlayabildiğini görmekte zorlanıyorum. Bir örnek vereceğim:

Diyelim ki su ve buz gibi "materyalleri" ve onların özelliklerini temsil eden nesnelerim var (bir oyun tasarlıyorum, bu yüzden gerçekten bu problemim var). Tüm bu malzeme örneklerine sahip bir "yönetici" olurdu. Bir özellik donma ve erime noktası ve malzemenin donma veya erime noktasıdır.

[EDIT] Tüm maddi örnekler "singleton" dur, Java Enum gibi.

0C'de "buz" a donmasını söylemek için "su" ve 1C'de "suya" erir demek için "buz" demek istiyorum. Ancak su ve buz değişmezse, yapıcı parametreleri olarak birbirlerine referans alamazlar, çünkü bunlardan biri önce yaratılmalıdır ve biri henüz mevcut olmayan diğerine yapıcı parametresi olarak referans alamaz. Her ikisini de donma / eritme özellikleri istendiğinde ihtiyaç duydukları diğer malzeme örneğini bulmak için sorgulayabilmeleri için yöneticiye bir referans vererek bunu çözebilirim, ancak daha sonra yönetici arasında aynı sorunu alıyorum ve birbirlerine referansta bulunmaları gereken materyaller, fakat sadece bunlardan biri için yapıcıda sağlanabilir, böylece yönetici veya malzeme değişmez olamaz.

Bu sorun etrafında sadece bir yolu yok, ya da "fonksiyonel" programlama teknikleri ya da çözmek için başka bir desen kullanmam gerekiyor mu?

Çözüm biraz hile yapmaktır. özellikle:

• A oluşturun, ancak B referansını başlatılmamış olarak bırakın (B henüz mevcut olmadığından).

• B'yi oluşturun ve A'yı işaret etmesini sağlayın.

• A'yı B'yi işaret edecek şekilde güncelleyin. Bundan sonra A veya B'yi güncellemeyin.

Bu açıkça yapılabilir (örnek C ++ ile):

struct List {
    int n;
    List *next;

    List(int n, List *next)
        : n(n), next(next);
};

// Return a list containing [0,1,0,1,...].
List *binary(void)
{
    List *a = new List(0, NULL);
    List *b = new List(1, a);
    a->next = b; // Evil, but necessary.
    return a;
}

veya dolaylı olarak (Haskell'de örnek):

binary :: [Int]
binary = a where
    a = 0 : b
    b = 1 : a

Haskell örneği, karşılıklı bağımlı değişmez değerler yanılsamasını elde etmek için tembel değerlendirme kullanır. Değerler şu şekilde başlar:

a = 0 : <thunk>
b = 1 : a

ave bher ikisi de bağımsız olarak geçerli baş-normal formlarıdır . Her eksileri, diğer değişkenin nihai değerine ihtiyaç duyulmadan oluşturulabilir. Gövde değerlendirildiğinde, aynı veriyi bişaret eder.

Bu nedenle, iki değişmez değerin birbirine işaret etmesini istiyorsanız, ikincisini oluşturduktan sonra ilkini güncellemeniz veya bunu yapmak için daha üst düzey bir mekanizma kullanmanız gerekir.

Özel örneğinizde, Haskell'de şöyle ifade edebilirim:

data Material = Water {temperature :: Double}
              | Ice   {temperature :: Double}

setTemperature :: Double -> Material -> Material
setTemperature newTemp (Water _) | newTemp <= 0.0 = Ice newTemp
                                 | otherwise      = Water newTemp
setTemperature newTemp (Ice _)   | newTemp >= 1.0 = Water newTemp
                                 | otherwise      = Ice newTemp

Ancak, bu konuya bir adım atıyorum. Her kurucunun sonucuna bir setTemperatureyöntemin eklendiği nesne yönelimli bir yaklaşımda, Materialkurucuları birbirine yöneltmeniz gerektiğini düşünürdüm. Yapıcılara değişmez değerler olarak davranılırsa, yukarıda özetlenen yaklaşımı kullanabilirsiniz.

Örneğinizde, geçerli nesneyi değiştirmeye çalışmak yerine ApplyTransform()döndüren bir yöntem gibi bir şey kullanmak için bir nesneye dönüşüm uyguluyorsunuz BlockBase.

Örneğin, bir ısı bloğu uygulayarak bir IceBlock'u bir WaterBlock'a değiştirmek için,

BlockBase currentBlock = new IceBlock();
currentBlock = currentBlock.ApplyTemperature(1); 
// currentBlock is now a WaterBlock 

ve IceBlock.ApplyTemperature()yöntem şöyle görünecektir:

public class IceBlock() : BlockBase
{
    public BlockBase ApplyTemperature(int temp)
    {
        return (temp > 0 ? new WaterBlock((BlockBase)this) : this);
    }
}

Döngüyü kırmanın bir başka yolu, malzeme ve dönüşüm kaygılarını, bazı telafi dillerinde ayırmaktır:

water = new Block("water");
ice = new Block("ice");

transitions = new Transitions([
    new transitions.temperature.Below(0.0, water, ice),
    new transitions.temperature.Above(0.0, ice, water),
]);

İşlevsel bir dil kullanacaksanız ve değişmezliğin faydalarını gerçekleştirmek istiyorsanız, o zaman soruna akılda yaklaşmalısınız. Bir dizi sıcaklığı destekleyebilen bir nesne türü "buz" veya "su" tanımlamaya çalışıyorsunuz - değişmezliği desteklemek için, sıcaklık her değiştiğinde yeni bir nesne oluşturmanız gerekir, bu da israftır. Bu yüzden blok tipi ve sıcaklık kavramlarını daha bağımsız hale getirmeye çalışın. Scala'yı bilmiyorum (benim öğrenme listemde :-)), ama Joey Adams'tan borçlanma Haskell'den cevap , şöyle bir şey öneriyorum:

data Material = Water | Ice

blockForTemperature :: Double -> Material
blockForTemperature x = 
  if x < 0 then Ice else Water

ya da belki:

transitionForTemperature :: Material -> Double -> Material
transitionForTemperature oldMaterial newTemp = 
  case (oldMaterial, newTemp) of
    (Ice, _) | newTemp > 0 -> Water
    (Water, _) | newTemp <= 0 -> Ice

(Not: Bunu çalıştırmayı denemedim ve Haskell'in biraz paslı.) Şimdi, geçiş mantığı malzeme türünden ayrıldı, bu yüzden çok fazla bellek harcamıyor ve (bence) oldukça biraz daha işlevsel odaklı.