มีกลยุทธ์การออกแบบเฉพาะที่สามารถนำไปใช้แก้ปัญหาไก่และไข่ส่วนใหญ่ในขณะที่ใช้วัตถุที่ไม่เปลี่ยนรูปแบบได้หรือไม่?

มาจากพื้นหลัง OOP (Java) ฉันกำลังเรียน Scala ด้วยตัวเอง ในขณะที่ฉันสามารถเห็นข้อดีของการใช้วัตถุที่ไม่เปลี่ยนรูปแบบรายบุคคล แต่ฉันมีเวลายากที่จะเห็นว่าใครสามารถออกแบบแอปพลิเคชันทั้งหมดเช่นนั้นได้ ฉันจะให้ตัวอย่าง:

ว่าฉันมีวัตถุที่แสดงถึง "วัสดุ" และคุณสมบัติของพวกเขา (ฉันกำลังออกแบบเกมดังนั้นจริง ๆ แล้วฉันมีปัญหานั้น) เช่นน้ำและน้ำแข็ง ฉันจะมี "ผู้จัดการ" ที่เป็นเจ้าของอินสแตนซ์ของวัสดุดังกล่าวทั้งหมด หนึ่งคุณสมบัติจะเป็นจุดเยือกแข็งและจุดหลอมเหลวและสิ่งที่วัสดุค้างหรือละลาย

[แก้ไข] ทุกกรณีวัสดุคือ "ซิงเกิลตัน" เช่นเดียวกับ Java Enum

ฉันต้องการให้ "น้ำ" บอกว่าค้างเป็น "น้ำแข็ง" ที่ 0C และ "น้ำแข็ง" เพื่อบอกว่ามันละลายเป็น "น้ำ" ที่ 1C แต่ถ้าน้ำและน้ำแข็งไม่เปลี่ยนรูปพวกเขาไม่สามารถรับค่าอ้างอิงซึ่งกันและกันเป็นพารามิเตอร์ตัวสร้างได้เนื่องจากจะต้องสร้างอย่างใดอย่างหนึ่งก่อนและไม่สามารถรับการอ้างอิงถึงพารามิเตอร์อื่น ๆ ที่ยังไม่ได้มีอยู่เป็นพารามิเตอร์ตัวสร้างได้ ฉันสามารถแก้ปัญหานี้ได้โดยให้ทั้งคู่อ้างอิงถึงผู้จัดการเพื่อให้พวกเขาสามารถสอบถามเพื่อค้นหาอินสแตนซ์วัสดุอื่น ๆ ที่พวกเขาต้องการทุกครั้งที่พวกเขาถูกถามถึงคุณสมบัติการแช่แข็ง / การหลอมเหลวของพวกเขา แต่แล้วฉันก็พบปัญหาเดียวกันระหว่างผู้จัดการ และวัสดุที่พวกเขาต้องการการอ้างอิงถึงแต่ละอื่น ๆ แต่มันสามารถให้ไว้ในตัวสร้างสำหรับหนึ่งในพวกเขาดังนั้นผู้จัดการหรือวัสดุที่ไม่สามารถเปลี่ยนไม่ได้

พวกเขาไม่มีทางแก้ไขปัญหานี้หรือฉันจำเป็นต้องใช้เทคนิคการเขียนโปรแกรม "ฟังก์ชั่น" หรือรูปแบบอื่น ๆ เพื่อแก้ไขหรือไม่

ทางออกคือการโกงนิดหน่อย โดยเฉพาะ:

• สร้าง A แต่ปล่อยให้การอ้างอิงถึง B ไม่มีการกำหนดค่าเริ่มต้น (เนื่องจาก B ยังไม่มีอยู่)

• สร้าง B และให้มันชี้ไปที่ A

• อัปเดต A เพื่อชี้ไปที่ B อย่าอัปเดต A หรือ B หลังจากนี้

สิ่งนี้สามารถทำได้อย่างชัดเจน (ตัวอย่างใน C ++):

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;
}

หรือโดยนัย (ตัวอย่างใน Haskell):

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

ตัวอย่าง Haskell ใช้การประเมินแบบสันหลังยาวเพื่อให้ได้มายาของค่าที่ไม่เปลี่ยนรูปได้ซึ่งกันและกัน ค่าเริ่มต้นจาก:

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

aและbเป็นทั้งแบบฟอร์ม head-normal ที่ถูกต้องโดยอิสระ ข้อเสียแต่ละข้อสามารถสร้างได้โดยไม่ต้องใช้ค่าสุดท้ายของตัวแปรอื่น เมื่อประเมินค่า thunk แล้วมันจะชี้ไปที่bจุดข้อมูลเดียวกันกับ

ดังนั้นหากคุณต้องการให้ค่าที่เปลี่ยนไม่ได้สองค่าให้ชี้ไปที่ค่าอื่นคุณต้องอัปเดตค่าแรกหลังจากสร้างค่าที่สองหรือใช้กลไกระดับสูงกว่าเพื่อทำสิ่งเดียวกัน

ในตัวอย่างของคุณโดยเฉพาะฉันอาจแสดงเป็น Haskell เป็น:

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

อย่างไรก็ตามฉันก้าวไปข้างหน้าปัญหา ฉันจินตนาการว่าในวิธีการเชิงวัตถุที่setTemperatureวิธีการเชื่อมต่อกับผลลัพธ์ของตัวMaterialสร้างแต่ละตัวคุณจะต้องให้ตัวสร้างชี้ไปที่ซึ่งกันและกัน หากตัวสร้างได้รับการปฏิบัติเหมือนเป็นค่าที่ไม่เปลี่ยนรูปคุณสามารถใช้วิธีการที่อธิบายไว้ข้างต้น

ในตัวอย่างของคุณคุณใช้การแปลงกับวัตถุดังนั้นฉันจะใช้บางอย่างเช่นApplyTransform()วิธีการส่งกลับBlockBaseแทนที่จะพยายามเปลี่ยนวัตถุปัจจุบัน

ตัวอย่างเช่นในการเปลี่ยน IceBlock เป็น WaterBlock ด้วยการใช้ความร้อนฉันจะเรียกมันว่า

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

และIceBlock.ApplyTemperature()วิธีการจะมีลักษณะเช่นนี้:

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

อีกวิธีหนึ่งในการทำลายวงจรคือการแยกความกังวลของเนื้อหาและการแปลงเสียงในบางภาษาที่ทำขึ้น:

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),
]);

หากคุณกำลังจะใช้ภาษาที่ใช้งานได้และคุณต้องการตระหนักถึงประโยชน์ของความไม่สามารถเปลี่ยนแปลงได้คุณควรเข้าหาปัญหาโดยคำนึงถึงสิ่งนั้น คุณกำลังพยายามกำหนดประเภทของวัตถุ "น้ำแข็ง" หรือ "น้ำ" ที่สามารถรองรับช่วงอุณหภูมิ - เพื่อรองรับการเปลี่ยนแปลงไม่ได้คุณต้องสร้างวัตถุใหม่ทุกครั้งที่อุณหภูมิเปลี่ยนแปลงซึ่งสิ้นเปลือง ดังนั้นพยายามทำให้แนวคิดของประเภทบล็อกและอุณหภูมิเป็นอิสระมากขึ้น ฉันไม่รู้ Scala (อยู่ในรายการเรียนรู้ของฉัน :-)) แต่ยืมมาจาก Joey Adams คำตอบใน Haskellฉันขอแนะนำบางอย่างเช่น:

data Material = Water | Ice

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

หรืออาจจะ:

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

(หมายเหตุ: ฉันไม่ได้พยายามเรียกใช้สิ่งนี้และ Haskell ของฉันมีสนิมเล็กน้อย) ตอนนี้ตรรกะการเปลี่ยนแปลงถูกแยกออกจากประเภทวัสดุดังนั้นจึงไม่เสียความทรงจำมากและ (ในความคิดของฉัน) มันค่อนข้าง เน้นฟังก์ชั่นอีกเล็กน้อย