compiler construction - असुरक्षित जबरदस्त और अधिक कुशल एग्डा कोड(-फ्रिस्ट-आई-आईएम-एग्डा)



compiler-construction haskell (1)

एग्डा मेलिंग सूची में, कॉनर मैकब्राइड ने पूछा:

क्या कृत्रिम रूप से संचालन को पकड़ने के लिए कोई रास्ता नहीं है

   trustFromJust :: Maybe x -> x

जो वास्तव में जस्ट और गोज्स गलत की जांच नहीं करता है (मिल्नेर के अर्थ में) यदि कुछ खिलाया जाता है तो?

अगदा शायद एक == सिर्फ 1 ए साबित हो सकता है, और राशि प्रकार के लिए मध्यवर्ती निर्माता का सफाया हो सकता है।

मैं असुरक्षित कॉरर्स # या अनपैक क्लोजर # के उपयोग के तरीकों के बारे में सोच सकता हूं, लेकिन क्या किसी और के पास कोई विचार है?

import GHC.Prim

trustFromJust :: Maybe x -> x
trustFromJust x = y
    where Just1 y = unsafeCoerce# x

data Just1 a = Just1 a

हालांकि इस segfaults (एकल कन्स्ट्रक्टर प्रकार कुछ ओवरहेड बंद कर सकते हैं)। कोर हालांकि ठीक दिखता है:

main2 =
  case (Data.Maybe.Just @ Type.Integer main3)
       `cast`
       (CoUnsafe
         (Data.Maybe.Maybe Type.Integer)
         (Just1 Type.Integer)
               :: Data.Maybe.Maybe Type.Integer
                    ~
                  Just1 Type.Integer)
  of _ { Just1 y_aeb ->
  $wshowsPrec 0 y_aeb ([] @ Char)

चूंकि यह एक शोध प्रश्न है, हमारे पास कुछ संभव तरीके हैं, लेकिन ये सभी नीचे आते हैं:

  • हो सकता है कि टैग बिट्स के पीछे चालें चलाएं




agda