प्रकार का अनुमान + अतिभार

Question

मैं एक ऐसी भाषा के लिए एक प्रकार का अनुमान एल्गोरिथ्म खोज रहा हूं, जिसे मैं विकसित कर रहा हूं, लेकिन मुझे वह नहीं मिला, जो मेरी आवश्यकताओं के अनुरूप हो, क्योंकि वे आमतौर पर हैं:

• एक ला हास्केल, बहुरूपता के साथ, लेकिन कोई तदर्थ ओवरलोडिंग नहीं
• A la C ++ (ऑटो) जिसमें आपके पास तदर्थ ओवरलोडिंग है लेकिन फ़ंक्शन मोनोमोर्फिक हैं

विशेष रूप से मेरी टाइप प्रणाली है (सरलीकृत) (मैं हास्केलिश सिंटैक्स का उपयोग कर रहा हूं लेकिन यह भाषा अज्ञेय है):

data Type = Int | Double | Matrix Type | Function Type Type

और मुझे एक ऑपरेटर मिला है * जिसे काफी कुछ अधिभार मिला है:

Int -> Int -> Int
(Function Int Int) -> Int -> Int
Int -> (Function Int Int) -> (Function Int Int)
(Function Int Int) -> (Function Int Int) -> (Function Int Int)
Int -> Matrix Int -> Matrix Int
Matrix Int -> Matrix Int -> Matrix Int
(Function (Matrix Int) (Matrix Int)) -> Matrix Int -> Matrix Int

आदि...

और मैं इसके लिए संभावित प्रकारों का पता लगाना चाहता हूं

(2*(x => 2*x))*6
(2*(x => 2*x))*{{1,2},{3,4}}

पहला है Int, दूसरा Matrix Int।

उदाहरण (जो काम नहीं करता है):

{-# LANGUAGE OverlappingInstances, MultiParamTypeClasses,
  FunctionalDependencies, FlexibleContexts,
  FlexibleInstances, UndecidableInstances #-}

import qualified Prelude
import Prelude hiding ((+), (*))
import qualified Prelude

newtype WInt = WInt { unwrap :: Int }

liftW f a b = WInt $ f (unwrap a) (unwrap b)

class Times a b c | a b -> c where
(*) :: a -> b -> c

instance Times WInt WInt WInt where
(*) = liftW (Prelude.*)

instance (Times a b c) => Times a (r -> b) (r -> c) where
x * g = \v -> x * g v

instance Times (a -> b) a b where
f * y = f y

two = WInt 2
six = WInt 6

test :: WInt
test = (two*(\x -> two*x))*six

main = undefined

Comments

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

— थॉमस ओवेन्स

Answer 1

मेरा सुझाव है कि जियोफ्री सीवर स्मिथ के शोध प्रबंध को देखना

जैसा कि आप शायद पहले से ही जानते हैं, जिस तरह से सामान्य प्रकार के अनुमान एल्गोरिदम काम करते हैं, वह यह है कि वे वाक्यविन्यास के पेड़ को पार करते हैं और प्रत्येक उपप्रकार के लिए वे एक प्रकार की बाधा उत्पन्न करते हैं। फिर, वे इस बाधा को लेते हैं, उनके बीच संयोजन मानते हैं, और उन्हें हल करते हैं (आमतौर पर सबसे सामान्य समाधान की तलाश में)।

जब आपके पास ओवरलोडिंग होती है, जब एक ओवरलोड ऑपरेटर का विश्लेषण करते हैं, तो आप एक के बजाय कई प्रकार की बाधाएं उत्पन्न करते हैं, और यदि ओवरलोडिंग बाध्य होती है, तो उनके बीच विवाद को मान लें। क्योंकि आप अनिवार्य रूप से कह रहे हैं कि ऑपरेटर के पास `` या तो यह, या वह प्रकार हो सकता है। ”यदि यह अनबाउंड है, तो किसी को पॉलीमॉर्फिक प्रकारों के साथ, बल्कि अतिरिक्त बाधाओं के साथ सार्वभौमिक मात्रा का सहारा लेने की आवश्यकता है, लेकिन वास्तविक बाधा। ओवरलोडिंग प्रकार। पेपर I संदर्भ इन विषयों को अधिक गहराई से कवर करता है।

Comments

बहुत-बहुत धन्यवाद, यह वह उत्तर है जिसकी मुझे तलाश थी

— लघु

Answer 2

ताज्जुब है, हास्केल अपने आप में लगभग पूरी तरह से आपके उदाहरण के लिए सक्षम है; हिंडले-मिलनर ओवरलोडिंग के साथ पूरी तरह से ठीक है, इसलिए जब तक यह अच्छी तरह से बंधे नहीं है:

{-# LANGUAGE OverlappingInstances, MultiParamTypeClasses,
             FunctionalDependencies, FlexibleContexts,
             FlexibleInstances #-}
import Prelude hiding ((*))

class Times a b c | a b -> c where
    (*) :: a -> b -> c

instance Times Int Int Int where
    (*) = (Prelude.*)

instance Times Double Double Double where
    (*) = (Prelude.*)

instance (Times a b c) => Times (r -> a) (r -> b) (r -> c) where
    f * g = \v -> f v * g v

instance (Times a b c) => Times a (r -> b) (r -> c) where
    x * g = \v -> x * g v

instance (Times a b c) => Times (r -> a) b (r -> c) where
    f * y = \v -> f v * y

type Matrix a = (Int, Int) -> a

हो गया! ठीक है, सिवाय इसके कि आपको डिफ़ॉल्ट करने की आवश्यकता है। यदि आपकी भाषा Timesकक्षा को Int(और तब Double) डिफॉल्ट करने की अनुमति देती है , तो आपके उदाहरण बिल्कुल बताए गए अनुसार काम करेंगे। इसे ठीक करने का दूसरा तरीका, ज़ाहिर है, स्वचालित रूप से बढ़ावा नहीं देना Intहै Double, या केवल तुरंत आवश्यक होने पर इसे करना है, और केवल के Intरूप में शाब्दिक का उपयोग करना है Int(फिर से, केवल आवश्यक होने पर ही प्रचार करना); यह समाधान भी काम करेगा।

Comments

आपका बहुत बहुत धन्यवाद! (हालांकि एक्सटेंशन की संख्या 9k से अधिक है)

— miniBill

Ideone.com/s9rSi7

— miniBill

यह एक डिफ़ॉल्ट समस्या नहीं है: ideone.com/LrfEjX

— miniBill

ओह, क्षमा करें, मैंने आपको तब गलत समझा। खैर, मैं डिफॉल्ट नहीं करना चाहता (मुझे लगता है) ..

— मिनीबेल

क्या आप एक उदाहरण प्रस्तुत करने का प्रयास कर सकते हैं जो संकलन करता है?

— मिनीबेल