การติดตาเป็นภาษาที่ใช้งานได้จริงเพียงใด?

รูปแบบของการใช้ตัวจัดการคำสั่งในการจัดการกับการคงอยู่ของภาษาที่ใช้งานได้อย่างแท้จริงซึ่งเราต้องการทำให้โค้ดที่เกี่ยวข้องกับ IO มีความบางที่สุด

เมื่อใช้การออกแบบที่ขับเคลื่อนด้วยโดเมนในภาษาเชิงวัตถุเป็นเรื่องปกติที่จะใช้รูปแบบคำสั่ง / ตัวจัดการเพื่อดำเนินการเปลี่ยนแปลงสถานะ ในการออกแบบตัวจัดการคำสั่งจะอยู่ด้านบนของวัตถุโดเมนของคุณและรับผิดชอบต่อตรรกะที่เกี่ยวข้องกับการคงอยู่ที่น่าเบื่อเช่นการใช้ที่เก็บข้อมูลและการเผยแพร่กิจกรรมโดเมน ตัวจัดการเป็นหน้าสาธารณะของโมเดลโดเมนของคุณ รหัสแอปพลิเคชันเช่น UI เรียกตัวจัดการเมื่อจำเป็นต้องเปลี่ยนสถานะของวัตถุโดเมน

ร่างใน C #:

public class DiscardDraftDocumentCommandHandler : CommandHandler<DiscardDraftDocument>
{
    IDraftDocumentRepository _repo;
    IEventPublisher _publisher;

    public DiscardDraftCommandHandler(IDraftDocumentRepository repo, IEventPublisher publisher)
    {
        _repo = repo;
        _publisher = publisher;
    }

    public override void Handle(DiscardDraftDocument command)
    {
        var document = _repo.Get(command.DocumentId);
        document.Discard(command.UserId);
        _publisher.Publish(document.NewEvents);
    }
}

documentวัตถุโดเมนเป็นผู้รับผิดชอบในการใช้กฎระเบียบทางธุรกิจ (เช่น "ผู้ใช้ควรได้รับอนุญาตให้ยกเลิกเอกสาร" หรือ "คุณไม่สามารถทิ้งเอกสารที่ได้รับแล้วทิ้ง") และสำหรับการสร้างเหตุการณ์โดเมนที่เราต้องการที่จะเผยแพร่ ( document.NewEventsจะ เป็นIEnumerable<Event>และอาจจะมีDocumentDiscardedเหตุการณ์)

นี่คือการออกแบบที่ดี - ง่ายต่อการขยาย (คุณสามารถเพิ่มกรณีการใช้งานใหม่โดยไม่ต้องเปลี่ยนรูปแบบโดเมนของคุณโดยเพิ่มตัวจัดการคำสั่งใหม่) และไม่เชื่อเรื่องวิธีการเก็บวัตถุ (คุณสามารถสลับพื้นที่เก็บข้อมูล NHibernate สำหรับ Mongo ได้อย่างง่ายดาย พื้นที่เก็บข้อมูลหรือแลกเปลี่ยนผู้เผยแพร่ RabbitMQ สำหรับผู้เผยแพร่ EventStore) ซึ่งทำให้ง่ายต่อการทดสอบโดยใช้ fakes และ mocks นอกจากนี้ยังเป็นไปตามรูปแบบ / การแยกมุมมอง - ตัวจัดการคำสั่งไม่ทราบว่ากำลังถูกใช้โดยงานแบ็ตช์, GUI หรือ REST API

ในภาษาที่ใช้งานได้จริงอย่าง Haskell คุณอาจทำตัวเป็นตัวจัดการคำสั่งอย่างคร่าวๆดังนี้:

newtype CommandHandler = CommandHandler {handleCommand :: Command -> IO Result)
data Result a = Success a | Failure Reason
type Reason = String

discardDraftDocumentCommandHandler = CommandHandler handle
    where handle (DiscardDraftDocument documentID userID) = do
              document <- loadDocument documentID
              let result = discard document userID :: Result [Event]
              case result of
                   Success events -> publishEvents events >> return result
                   -- in an event-sourced model, there's no extra step to save the document
                   Failure _ -> return result
          handle _ = return $ Failure "I expected a DiscardDraftDocument command"

นี่คือส่วนที่ฉันพยายามเข้าใจ โดยทั่วไปจะมีรหัส 'งานนำเสนอ' บางประเภทที่เรียกใช้ตัวจัดการคำสั่งเช่น GUI หรือ REST API ดังนั้นตอนนี้เรามีสองเลเยอร์ในโปรแกรมของเราซึ่งจำเป็นต้องทำ IO - ตัวจัดการคำสั่งและมุมมอง - ซึ่งเป็นสิ่งที่ไม่มีความใหญ่ใน Haskell

เท่าที่ฉันจะทำได้มีกองกำลังต่อต้านอยู่สองอย่างที่นี่: หนึ่งคือการแยกแบบ / มุมมองและอื่น ๆ คือความต้องการที่จะคงรูปแบบ ต้องมีรหัส IO เพื่อคงรูปแบบไว้ที่ใดที่หนึ่งแต่การแยกโมเดล / มุมมองบอกว่าเราไม่สามารถใส่มันในเลเยอร์การนำเสนอพร้อมกับรหัส IO อื่นทั้งหมด

แน่นอนในภาษา "ปกติ" IO สามารถ (และไม่) เกิดขึ้นได้ทุกที่ การออกแบบที่ดีนั้นกำหนดว่า IO ชนิดต่าง ๆ จะแยกกัน แต่คอมไพเลอร์ไม่บังคับใช้

ดังนั้น: เราจะกระทบยอดการแยกโมเดล / มุมมองด้วยความปรารถนาที่จะผลักดันรหัส IO ไปยังขอบสุดของโปรแกรมได้อย่างไรเมื่อโมเดลนั้นต้องคงอยู่? เราจะแยก IO สองประเภทที่ต่างกันได้อย่างไร แต่ยังคงอยู่ห่างจากรหัสบริสุทธิ์ทั้งหมด?

อัปเดต : เงินรางวัลจะหมดอายุในเวลาน้อยกว่า 24 ชั่วโมง ฉันไม่รู้สึกว่าคำตอบอย่างใดอย่างหนึ่งในปัจจุบันได้ตอบคำถามของฉันเลย @ ความคิดเห็นของ Flame Ptharien เกี่ยวกับacid-stateดูเหมือนว่าจะมีแนวโน้ม แต่มันไม่ได้คำตอบและมันไม่มีรายละเอียด ฉันจะเกลียดจุดเหล่านี้เสียเปล่า!

วิธีทั่วไปในการแยกส่วนประกอบใน Haskell คือผ่านกองหม้อแปลง monad ฉันอธิบายรายละเอียดด้านล่างนี้

ลองนึกภาพเรากำลังสร้างระบบที่มีส่วนประกอบขนาดใหญ่หลายแห่ง:

• ส่วนประกอบที่พูดคุยกับดิสก์หรือฐานข้อมูล(submodel)
• ส่วนประกอบที่เปลี่ยนแปลงบนโดเมนของเรา(โมเดล)
• ส่วนประกอบที่โต้ตอบกับผู้ใช้(ดู)
• ส่วนประกอบที่อธิบายการเชื่อมต่อระหว่างมุมมองแบบจำลองและแบบจำลองย่อย(ตัวควบคุม)
• ส่วนประกอบที่เริ่มต้นทั้งระบบ(ไดรเวอร์)

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

ดังนั้นเราจึงเขียนรหัสส่วนประกอบของเราแต่ละแบบที่หลากหลายโดยใช้คลาส MTL ต่างๆเพื่อเป็นแนวทางให้เรา:

• ทุกฟังก์ชั่นใน submodel นั้นเป็นประเภท MonadState DataState m => Foo -> Bar -> ... -> m Baz
  • DataState เป็นตัวแทนที่แท้จริงของภาพรวมของสถานะของฐานข้อมูลหรือการจัดเก็บของเรา
• ฟังก์ชั่นทุกอย่างในรุ่นล้วนบริสุทธิ์
• ทุกฟังก์ชั่นในมุมมองเป็นประเภท MonadState UIState m => Foo -> Bar -> ... -> m Baz
  • UIState เป็นการแสดงภาพรวมของสถานะส่วนต่อประสานผู้ใช้ของเราอย่างแท้จริง
• ทุกฟังก์ชั่นในคอนโทรลเลอร์เป็นชนิด MonadState (DataState, UIState) m => Foo -> Bar -> ... -> m Baz
  • ขอให้สังเกตว่าตัวควบคุมมีการเข้าถึงทั้งสถานะของมุมมองและสถานะของการสร้างใหม่
• คนขับมีคำจำกัดความเพียงคำเดียวmain :: IO ()ซึ่งทำงานได้เล็กน้อยในการรวมส่วนประกอบอื่น ๆ ไว้ในระบบเดียว
  • มุมมองและแบบจำลองย่อยจะต้องถูกยกให้อยู่ในประเภทรัฐเดียวกับตัวควบคุมที่ใช้zoomหรือ combinator ที่คล้ายกัน
  • โมเดลนั้นบริสุทธิ์และสามารถใช้งานได้โดยไม่มีข้อ จำกัด
  • ในท้ายที่สุดแล้วทุกอย่างในชีวิต (ชนิดที่เข้ากันได้กับ) ซึ่งดำเนินการแล้วกับเนื้อหาที่แท้จริงของฐานข้อมูลหรือจัดเก็บข้อมูลเพื่อการผลิตStateT (DataState, UIState) IOIO

ดังนั้น: เราจะกระทบยอดการแยกโมเดล / มุมมองด้วยความปรารถนาที่จะผลักดันรหัส IO ไปยังขอบสุดของโปรแกรมได้อย่างไรเมื่อโมเดลนั้นต้องคงอยู่?

โมเดลควรจะต้องคงอยู่หรือไม่? ในหลาย ๆ โปรแกรมจำเป็นต้องบันทึกโมเดลเนื่องจากสถานะไม่แน่นอนการดำเนินการใด ๆ สามารถกลายพันธุ์โมเดลในทางใดทางหนึ่งดังนั้นวิธีเดียวที่จะทราบสถานะของโมเดลคือเข้าถึงโดยตรง

หากในสถานการณ์ของคุณลำดับของเหตุการณ์ (คำสั่งที่ได้รับการตรวจสอบและได้รับการยอมรับ) สามารถสร้างสถานะได้ตลอดเวลาดังนั้นจึงเป็นเหตุการณ์ที่ต้องมีการยืนยันไม่จำเป็นต้องเป็นของรัฐ รัฐสามารถสร้างได้โดยการเล่นซ้ำเหตุการณ์

ต้องบอกว่าบ่อยครั้งที่รัฐจะถูกเก็บไว้ แต่เป็นสแน็ปช็อต / แคชเพื่อหลีกเลี่ยงการเล่นซ้ำคำสั่งไม่ใช่ข้อมูลโปรแกรมที่สำคัญ

ดังนั้นตอนนี้เรามีสองเลเยอร์ในโปรแกรมของเราซึ่งจำเป็นต้องทำ IO - ตัวจัดการคำสั่งและมุมมอง - ซึ่งเป็นสิ่งที่ไม่มีความใหญ่ใน Haskell

หลังจากคำสั่งได้รับการยอมรับเหตุการณ์จะถูกสื่อสารไปยังสองปลายทาง (หน่วยเก็บข้อมูลเหตุการณ์และระบบการรายงาน) แต่อยู่ที่เลเยอร์เดียวกันของโปรแกรม

ดูเพิ่มเติมการ
จัดหากิจกรรมการ
อ่านที่ได้รับมากระตือรือร้น

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

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

การนำเสนอและการคงอยู่เป็นส่วนประกอบของแอปทั้งหมดที่ฉันคิดว่าคุณกำลังอธิบายอยู่ที่นี่

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

ใกล้ที่สุดเท่าที่ฉันสามารถเข้าใจคำถามของคุณ (ซึ่งฉันอาจจะไม่ แต่คิดว่าฉันจะโยนใน 2 เซ็นต์ของฉัน) เนื่องจากคุณไม่จำเป็นต้องเข้าถึงวัตถุด้วยตนเองคุณจำเป็นต้องมีฐานข้อมูลวัตถุของคุณเองที่ - หมดอายุในช่วงเวลา)

โดยหลักการแล้ววัตถุนั้นสามารถปรับปรุงเพื่อจัดเก็บสถานะของพวกเขาดังนั้นเมื่อพวกเขาได้รับ "ส่งผ่าน" ตัวประมวลผลคำสั่งที่แตกต่างกันจะรู้ว่าพวกเขากำลังทำงานกับอะไร

หากเป็นไปไม่ได้ (icky icky) วิธีเดียวคือมีคีย์เหมือน DB ทั่วไปที่คุณสามารถใช้เพื่อเก็บข้อมูลในร้านค้าที่ตั้งค่าไว้เพื่อให้สามารถแชร์ได้ระหว่างคำสั่งที่ต่างกัน - และหวังว่า "open up" ส่วนต่อประสานและ / หรือรหัสเพื่อให้ผู้เขียนคำสั่งอื่น ๆ จะใช้ส่วนต่อประสานของคุณในการบันทึกและประมวลผลข้อมูลเมตา

ในพื้นที่ของไฟล์เซิร์ฟเวอร์แซมบ้ามีวิธีการจัดเก็บสิ่งต่าง ๆ เช่นรายการเข้าถึงและสตรีมข้อมูลสำรองขึ้นอยู่กับสิ่งที่โฮสต์ระบบปฏิบัติการจัดให้ โดยหลักการแล้วแซมบ้ากำลังโฮสต์อยู่บนระบบไฟล์ที่มีคุณสมบัติเพิ่มเติมในไฟล์ ตัวอย่าง 'xfs' บน 'linux' - คำสั่งเพิ่มเติมกำลังคัดลอกแอ็ตทริบิวต์ส่วนขยายพร้อมกับไฟล์ (โดยค่าเริ่มต้น utils ส่วนใหญ่บน linux "โตขึ้น" w / o คิดเหมือนแอ็ตทริบิวต์เพิ่มเติม)

ทางเลือกอื่น - ใช้งานได้กับหลายกระบวนการของ samba จากผู้ใช้ต่าง ๆ ที่ทำงานกับไฟล์ทั่วไป (วัตถุ) คือถ้าระบบไฟล์ไม่รองรับการแนบทรัพยากรโดยตรงกับไฟล์เช่นเดียวกับแอตทริบิวต์เพิ่มเติมใช้โมดูลที่ใช้งาน เลเยอร์ระบบไฟล์เสมือนเพื่อจำลองคุณลักษณะเพิ่มเติมสำหรับกระบวนการ samba มีเพียงแซมบ้าเท่านั้นที่รู้เรื่องนี้ แต่มันมีข้อได้เปรียบในการทำงานเมื่อรูปแบบวัตถุไม่รองรับ แต่ก็ยังทำงานได้กับผู้ใช้ samba ที่หลากหลาย (ตัวประมวลผลคำสั่ง cf. ) ซึ่งทำงานกับไฟล์ตามสถานะก่อนหน้านี้ มันจะเก็บข้อมูลเมตาในฐานข้อมูลทั่วไปสำหรับระบบไฟล์ซึ่งช่วยในการควบคุมขนาดของฐานข้อมูล (และไม่ '

มันอาจจะไม่เป็นประโยชน์กับคุณหากคุณต้องการข้อมูลเพิ่มเติมเฉพาะสำหรับการใช้งานที่คุณกำลังทำอยู่ แต่แนวคิดในทางทฤษฎีอาจนำทฤษฎีเดียวกันมาใช้กับชุดปัญหาทั้งสองได้ ดังนั้นหากคุณกำลังมองหาอัลกอริทึมและวิธีการทำสิ่งที่คุณต้องการนั่นอาจช่วยได้ หากคุณต้องการความรู้ที่เฉพาะเจาะจงมากขึ้นในกรอบงานที่เฉพาะเจาะจงบางอย่างอาจไม่เป็นประโยชน์ ... ;-)

BTW - เหตุผลที่ฉันพูดถึง 'การหมดอายุด้วยตนเอง' - ก็คือมันไม่ชัดเจนหากคุณรู้ว่ามีวัตถุอะไรอยู่ที่นั่นและนานแค่ไหนที่พวกเขายังคงอยู่ หากคุณไม่มีทางรู้ได้เลยว่าเมื่อใดที่วัตถุถูกลบคุณจะต้องตัดแต่ง metaDB ของคุณเองเพื่อป้องกันไม่ให้กรอกข้อมูล meta เก่าหรือเก่าแก่ที่ผู้ใช้มีความยาวตั้งแต่ลบวัตถุสำหรับ

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

ไชโย!