हास्केल - अंकगणित ऑपरेटरों को छिपाने (छिपाने)

Question

मैं उन्हें अधिक एक्स्टेंसिबल और जेनेरिक बनाने के लिए हास्केल में कई अंकगणितीय ऑपरेटरों को फिर से परिभाषित करना चाहता हूं।

उदा।

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

यह

import Prelude hiding ((*)) 

मानक * ऑपरेटर छुपा के साथ संयोजन में काम करने के लिए लगता है। लेकिन निश्चित रूप से सभी सामान्य गुणा के साथ-साथ काम करना है, तो मैं

instance (Num t) => Mul t t t where 
    (*) = ?? 

मैं कैसे उपयोग कर सकते हैं मूल * ऑपरेटर (Prelude.(*) काम नहीं करता है) की तरह कुछ को परिभाषित करना होगा यहाँ और मैं कैसे करना है उदाहरण प्रकार को परिभाषित करें कि 1 * 1मोनोमोर्पिज्म प्रतिबंध के साथ संघर्ष नहीं करता है?

---

संपादित -

import qualified 

एक अच्छा टिप, धन्यवाद है।

लेकिन दुर्भाग्य से इसने मुझे सभी मानक तरीकों को स्पष्ट रूप से दायरे में लाने के लिए मजबूर किया। मैं सिर्फ कुछ अपरिवर्तित छोड़कर कुछ बाइंडिंग को फिर से परिभाषित करने की संभावना चाहता हूं।

तो क्या दोनों का संयोजन है? कुछ

import Prelude qualified ((*)) 

Answer 1

संपादित प्रश्न का उत्तर देना:

आप

import Prelude hiding ((*)) 
import qualified Prelude as P 

P उपसर्ग के माध्यम से हमेशा की तरह और (*) को (*) को छोड़कर सभी प्रस्तावना कार्यों के लिए पहुँच प्राप्त करने के कर सकते हैं:

x = 5 + 3 -- works 
y = 5 P.* 3 -- works 
z = 5 * 3 -- complains about * not being in scope 

Answer 2

इस तरह की चीजों को करने के कुछ प्रयास किए गए हैं।

सबसे पहले,

मैं मूल * ऑपरेटर कैसे पहुंच सकते हैं (। प्रस्तावना (*) काम नहीं करता है)

आप की आवश्यकता होगी करने के लिए:

import qualified Prelude 

अब आप उदाहरण का उपयोग कर सकते हैं (प्रस्तावना। *)। यह "LANGUAGE NoImplicitPrelude" से कम आक्रामक है जो आपकी परिभाषाओं के लिए रीबाउंड होने के लिए >> = और इसी तरह के स्थानीय उपयोग भी करेगा।

यहाँ अन्य लोगों के विकल्प preludes के उदाहरण हैं:

• http://hackage.haskell.org/package/prelude-plus - एक सरल प्रस्तावना
• http://hackage.haskell.org/package/numeric-prelude - एक विकल्प संख्यात्मक पदानुक्रम (?)।

Answer 3

मैं पहले प्रश्न का उत्तर दे सकता हूं। (*) ऑपरेटर को छुपाकर वास्तव में इसे छुपाता है, इसलिए आप इसे प्राप्त नहीं कर सकते हैं। हालांकि, आप प्रीलूड योग्यता आयात कर सकते हैं:

import qualified Prelude as P 

foo = 3 P.* 14 -- == 42 

मुझे लगता है कि यह वही करता है जो आप चाहते हैं।

Answer 4

उदाहरण

instance (Num t) => Mul t t t where 
    (*) = ?? 

को अनुमति देने के लिए एक्सटेंशन का दुरुपयोग किए बिना, पहले स्थान पर Mul t t t परिभाषित करने के उद्देश्य को काफी हद तक हरा देगा।

दुर्भाग्य से 'सही' यदि दर्दनाक जवाब उदाहरण से उदाहरण के माध्यम से जाने के लिए और

import Prelude hiding ((*)) 
import qualified Prelude 

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

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


instance Mul Int Double Double where 
    ... 

instance Mul (Complex Float) (Complex Double) (Complex Double) 
    ... 

अन्यथा तरीका है कि उदाहरण के सिर (कोई बैक ट्रैकिंग किया जाता है) शायद अपने उपन्यास कर देगा संकलक में हल करने के लिए है जब आप वास्तव में उनका उपयोग करने के लिए जाते हैं तो उदाहरण संकलन को उड़ाते हैं।

जिसके अनुसार, आप कम से कम उदाहरण के लिए दर्द के बारे में सोच नहीं था कम कर सकते हैं:

newtype Other a = Other a 

instance Num a => Mul (Other a) (Other a) (Other a) where 
    Other a * Other b = Other (a Prelude.* b) 

यह कम से कम अगर वे जाने के लिए नहीं करना चाहते हैं उन्हें सिर्फ अपने newtype आवरण का उपयोग करने देगा और Mul और अपने सभी अन्य वर्गों को खुद परिभाषित करें।