रिकॉर्ड अपडेट आंतरिक रूप से कैसे व्यवहार करते हैं?

Question

data Thing = Thing {a :: Int, b :: Int, c :: Int, (...) , z :: Int} deriving Show 

foo = Thing 1 2 3 4 5 (...) 26 
mkBar x = x { c = 30 } 

main = do print $ mkBar foo 

जब मैं इस तरह foo को mutate करता हूं तो क्या कॉपी किया जाता है? एक संरचना के हिस्से को सीधे उत्परिवर्तित करने के विरोध में।

Data Thing = Thing {a :: IORef Int, b :: IORef Int, (...) , z :: IORef Int} 
instance Show Thing where 
(...something something unsafePerformIO...) 

mkFoo = do a <- newIORef 1 
      (...) 
      z <- newIORef 26 
      return Thing a b (...) z 
mkBar x = writeIORef (c x) 30 

main = do foo <- mkFoo 
      mkBar foo 
      print foo 

अनुकूलन के साथ संकलन इस व्यवहार को बदलता है?

Answer 1

पहले उदाहरण में, अपरिवर्तित Int घटकों के पॉइंटर्स की प्रतिलिपि बनाई गई है (और कन्स्ट्रक्टर टैग, यदि आप ऐसा कहना चाहते हैं)। इससे कोई फर्क नहीं पड़ता कि Int या एक पॉइंटर की प्रतिलिपि बनाई गई है, लेकिन यदि घटक बड़े ढांचे थे, तो यह होगा।

चूंकि खेतों सख्त नहीं हैं, व्यवहार, ऑप्टिकल, अनुकूलन से स्वतंत्र है। यदि फ़ील्ड सख्त थे, तो अनुकूलन के साथ, उन्हें कन्स्ट्रक्टर में अनपॅक किया जा सकता है और फिर कच्चे Int# मानों की प्रतिलिपि बनाई जाएगी।

दूसरे उदाहरण में, कुछ भी कॉपी नहीं किया गया है, IORef की सामग्री ओवरराइट की गई है।

Answer 2

डैनियल जवाब पर विस्तार करने के लिए, आप के रूप में बस के बारे में एक ही रूप में

data Foo = Foo Int Int 
update (Foo a b) x = Foo x b 

Answer 3

यह शायद मामला पूरी संरचना को कॉपी में एक क्षेत्र परिणामों को अद्यतन करने कि

data Foo = Foo {a::Int, b::Int} 
update foo x = foo{a=x} 

के बारे में सोच सकते हैं। लेकिन अगर संकलक साबित कर सकता है कि संरचना का उपयोग एक थ्रेडेड तरीके से किया जाता है तो यह जगह में अपडेट कर सकता है। मुझे ऐसा कोई कार्यान्वयन नहीं पता है जो यह करता है, लेकिन आप इसे एक बिट संदर्भ संख्याओं के साथ करने की कल्पना कर सकते हैं।