python - एक मिश्रण क्या है, और वे क्यों उपयोगी हैं?




oop multiple-inheritance (10)

" प्रोग्रामिंग पायथन " में, मार्क लुटज़ ने "मिक्सिन" का उल्लेख किया है। मैं एक सी / सी ++ / सी # पृष्ठभूमि से हूं और मैंने पहले शब्द नहीं सुना है। एक मिश्रण क्या है?

इस उदाहरण की रेखाओं के बीच पढ़ना (जिसे मैंने काफी समय से जोड़ा है), मुझे लगता है कि यह 'उचित' सबक्लासिंग के विपरीत एक वर्ग का विस्तार करने के लिए एकाधिक विरासत का उपयोग करने का मामला है। क्या यह सही है?

मैं नई कार्यक्षमता को सबक्लास में रखने के बजाए ऐसा क्यों करना चाहूंगा? उस मामले के लिए, मिश्रण का उपयोग करने से मिश्रण / एकाधिक विरासत दृष्टिकोण बेहतर क्यों होगा?

एक मिश्रण को एकाधिक विरासत से अलग करता है? क्या यह सिर्फ अर्थशास्त्र का मामला है?


एक मिश्रण को एकाधिक विरासत से अलग करता है? क्या यह सिर्फ अर्थशास्त्र का मामला है?

एक मिक्सीन एकाधिक विरासत का एक सीमित रूप है। कुछ भाषाओं में एक वर्ग में एक मिश्रण जोड़ने के लिए तंत्र विरासत की तुलना में थोड़ा अलग (वाक्यविन्यास के मामले में) है।

विशेष रूप से पायथन के संदर्भ में, एक मिश्रण एक अभिभावक वर्ग है जो उप-वर्गों को कार्यक्षमता प्रदान करता है लेकिन इसका उद्देश्य तत्काल नहीं होना चाहिए।

आपको क्या कहने का कारण हो सकता है, "यह केवल एक विरासत है, वास्तव में एक मिश्रण नहीं है" यह है कि यदि कक्षा को मिश्रण के लिए भ्रमित किया जा सकता है तो वास्तव में तत्काल और उपयोग किया जा सकता है - तो वास्तव में यह एक अर्थपूर्ण, और बहुत वास्तविक, अंतर है।

एकाधिक विरासत का उदाहरण

दस्तावेज से यह उदाहरण, एक ऑर्डर्ड काउंटर है:

class OrderedCounter(Counter, OrderedDict):
     'Counter that remembers the order elements are first encountered'

     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, OrderedDict(self))

     def __reduce__(self):
         return self.__class__, (OrderedDict(self),)

यह collections मॉड्यूल से Counter और OrderedDict दोनों को उप-वर्ग OrderedDict है।

Counter और OrderedDict दोनों को तत्काल और अपने आप इस्तेमाल करने का इरादा है। हालांकि, दोनों को subclassing करके, हम एक काउंटर हो सकता है कि आदेश दिया जाता है और प्रत्येक वस्तु में कोड का पुन: उपयोग करता है।

कोड का पुन: उपयोग करने का यह एक शक्तिशाली तरीका है, लेकिन यह समस्याग्रस्त भी हो सकता है। यदि यह पता चला है कि किसी ऑब्जेक्ट में कोई बग है, तो बिना देखभाल के इसे ठीक करने से सबक्लास में एक बग बन सकता है।

एक मिक्सिन का उदाहरण

मिश्रित आमतौर पर संभावित युग्मन मुद्दों के बिना कोड पुन: उपयोग करने के तरीके के रूप में प्रचारित किया जाता है जो ऑर्डरर्ड काउंटर की तरह सहकारी एकाधिक विरासत हो सकता है। जब आप मिक्स्सिन का उपयोग करते हैं, तो आप कार्यक्षमता का उपयोग करते हैं जो डेटा के साथ कसकर नहीं है।

उपर्युक्त उदाहरण के विपरीत, एक मिश्रण का उपयोग अपने आप पर नहीं किया जाना चाहिए। यह नई या अलग कार्यक्षमता प्रदान करता है।

उदाहरण के लिए, मानक लाइब्रेरी में socketserver लाइब्रेरी में कुछ socketserver

इन मिश्रण-वर्गों का उपयोग करके प्रत्येक प्रकार के सर्वर के फोर्किंग और थ्रेडिंग संस्करणों का निर्माण किया जा सकता है। उदाहरण के लिए, ThreadingUDPServer निम्नानुसार बनाया गया है:

class ThreadingUDPServer(ThreadingMixIn, UDPServer):
    pass

मिक्स-इन क्लास पहले आता है, क्योंकि यह UDPServer में परिभाषित विधि को ओवरराइड करता है। विभिन्न विशेषताओं को सेट करने से अंतर्निहित सर्वर तंत्र का व्यवहार भी बदल जाता है।

इस मामले में, UDPServer विधियों को UDPServer अनुमति देने के लिए UDPServer ऑब्जेक्ट परिभाषा में विधियों को ओवरराइड करें।

ओवरराइड विधि process_request प्रतीत होती है और यह एक और विधि, process_request_thread भी प्रदान process_request_thread । यहां यह स्रोत कोड से है :

class ThreadingMixIn:
        """Mix-in class to handle each request in a new thread."""

        # Decides how threads will act upon termination of the
        # main process
        daemon_threads = False

        def process_request_thread(self, request, client_address):
            """Same as in BaseServer but as a thread.
            In addition, exception handling is done here.
            """
            try:
                self.finish_request(request, client_address)
            except Exception:
                self.handle_error(request, client_address)
            finally:
                self.shutdown_request(request)

        def process_request(self, request, client_address):
            """Start a new thread to process the request."""
            t = threading.Thread(target = self.process_request_thread,
                                 args = (request, client_address))
            t.daemon = self.daemon_threads
            t.start()

एक संक्रमित उदाहरण

यह एक मिश्रण है जो ज्यादातर प्रदर्शन उद्देश्यों के लिए होता है - अधिकांश वस्तुएं इस repr की उपयोगिता से परे विकसित हो जाएंगी:

class SimpleInitReprMixin(object):
    """mixin, don't instantiate - useful for classes instantiable
    by keyword arguments to their __init__ method.
    """
    __slots__ = () # allow subclasses to use __slots__ to prevent __dict__
    def __repr__(self):
        kwarg_strings = []
        d = getattr(self, '__dict__', None)
        if d is not None:
            for k, v in d.items():
                kwarg_strings.append('{k}={v}'.format(k=k, v=repr(v)))
        slots = getattr(self, '__slots__', None)
        if slots is not None:
            for k in slots:
                v = getattr(self, k, None)
                kwarg_strings.append('{k}={v}'.format(k=k, v=repr(v)))
        return '{name}({kwargs})'.format(
          name=type(self).__name__,
          kwargs=', '.join(kwarg_strings)
          )

और उपयोग होगा:

class Foo(SimpleInitReprMixin): # add other mixins and/or extend another class here
    __slots__ = 'foo',
    def __init__(self, foo=None):
        self.foo = foo
        super(Foo, self).__init__()

और उपयोग:

>>> f1 = Foo('bar')
>>> f2 = Foo()
>>> f1
Foo(foo='bar')
>>> f2
Foo(foo=None)

इस उत्तर का उद्देश्य मिश्रणों को उदाहरणों के साथ समझा देना है जो हैं:

  • आत्मनिर्भर : संक्षेप में, उदाहरण को समझने के लिए किसी भी पुस्तकालय को जानने की आवश्यकता नहीं है।

  • पायथन में , अन्य भाषाओं में नहीं।

    यह समझ में आता है कि रुबी जैसे अन्य भाषाओं के उदाहरण थे क्योंकि शब्द उन भाषाओं में अधिक आम है, लेकिन यह एक पायथन धागा है।

यह विवादास्पद प्रश्न पर भी विचार करेगा:

क्या एकाधिक विरासत आवश्यक है या मिश्रित विशेषता नहीं है?

परिभाषाएं

मुझे अभी तक एक "आधिकारिक" स्रोत से उद्धरण नहीं दिख रहा है जो स्पष्ट रूप से कह रहा है कि पायथन में एक मिश्रण क्या है।

मैंने मिक्सीन की 2 संभावित परिभाषाएं देखी हैं (यदि उन्हें सार तत्वों जैसे अन्य समान अवधारणाओं से अलग माना जाता है), और लोग पूरी तरह सहमत नहीं हैं कि कौन सा सही है।

विभिन्न भाषाओं के बीच सर्वसम्मति भिन्न हो सकती है।

परिभाषा 1: कोई विरासत नहीं

एक मिश्रण एक वर्ग है जैसे वर्ग की कुछ विधि एक विधि का उपयोग करती है जिसे कक्षा में परिभाषित नहीं किया जाता है।

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

एक बाधा जो कुछ स्रोत जोड़ती है वह यह है कि कक्षा में डेटा, केवल विधियां नहीं हो सकती हैं, लेकिन मुझे नहीं लगता कि यह आवश्यक क्यों है। अभ्यास में हालांकि, कई उपयोगी मिश्रणों में कोई डेटा नहीं होता है, और बिना डेटा के बेस क्लास का उपयोग करना आसान होता है।

एक क्लासिक उदाहरण सभी तुलना ऑपरेटर का कार्यान्वयन केवल <= और == :

class ComparableMixin(object):
    """This class has methods which use `<=` and `==`,
    but this class does NOT implement those methods."""
    def __ne__(self, other):
        return not (self == other)
    def __lt__(self, other):
        return self <= other and (self != other)
    def __gt__(self, other):
        return not self <= other
    def __ge__(self, other):
        return self == other or self > other

class Integer(ComparableMixin):
    def __init__(self, i):
        self.i = i
    def __le__(self, other):
        return self.i <= other.i
    def __eq__(self, other):
        return self.i == other.i

assert Integer(0) <  Integer(1)
assert Integer(0) != Integer(1)
assert Integer(1) >  Integer(0)
assert Integer(1) >= Integer(1)

# It is possible to instantiate a mixin:
o = ComparableMixin()
# but one of its methods raise an exception:
#o != o 

यह विशेष उदाहरण functools.total_ordering() सजावट के माध्यम से हासिल किया जा सकता था, लेकिन यहां गेम पहिया को फिर से शुरू करना था:

import functools

@functools.total_ordering
class Integer(object):
    def __init__(self, i):
        self.i = i
    def __le__(self, other):
        return self.i <= other.i
    def __eq__(self, other):
        return self.i == other.i

assert Integer(0) < Integer(1)
assert Integer(0) != Integer(1)
assert Integer(1) > Integer(0)
assert Integer(1) >= Integer(1)

परिभाषा 2: एकाधिक विरासत

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

मिक्स्ड क्लास शब्द बेस क्लास को संदर्भित करता है जिसका उद्देश्य उस डिजाइन पैटर्न में उपयोग किया जाना है (विधि का उपयोग करने वाले TODO, या इसे लागू करने वाले लोग?)

यह तय करना आसान नहीं है कि दिया गया वर्ग मिश्रित है या नहीं: विधि को व्युत्पन्न वर्ग पर अभी लागू किया जा सकता है, इस मामले में हम परिभाषा 1 पर वापस आ गए हैं। आपको लेखक के इरादे पर विचार करना होगा।

यह पैटर्न दिलचस्प है क्योंकि आधार वर्गों के विभिन्न विकल्पों के साथ कार्यक्षमताओं को पुन: संयोजित करना संभव है:

class HasMethod1(object):
    def method(self):
        return 1

class HasMethod2(object):
    def method(self):
        return 2

class UsesMethod10(object):
    def usesMethod(self):
        return self.method() + 10

class UsesMethod20(object):
    def usesMethod(self):
        return self.method() + 20

class C1_10(HasMethod1, UsesMethod10): pass
class C1_20(HasMethod1, UsesMethod20): pass
class C2_10(HasMethod2, UsesMethod10): pass
class C2_20(HasMethod2, UsesMethod20): pass

assert C1_10().usesMethod() == 11
assert C1_20().usesMethod() == 21
assert C2_10().usesMethod() == 12
assert C2_20().usesMethod() == 22

# Nothing prevents implementing the method
# on the base class like in Definition 1:

class C3_10(UsesMethod10):
    def method(self):
        return 3

assert C3_10().usesMethod() == 13

आधिकारिक पायथन घटनाएं

संग्रह.एबीसी के लिए आधिकारिक दस्तावेज पर दस्तावेज स्पष्ट रूप से मिक्सिन विधि शब्द का उपयोग करता है।

यह बताता है कि यदि एक वर्ग:

  • कार्यान्वयन __next__
  • एक एकल कक्षा Iterator से विरासत

तो कक्षा को मुफ्त में __iter__ विधि __iter__

इसलिए कम से कम प्रलेखन के इस बिंदु पर, मिश्रण को एकाधिक विरासत की आवश्यकता नहीं होती है , और परिभाषा 1 के साथ सुसंगत है।

दस्तावेज निश्चित रूप से विभिन्न बिंदुओं पर विरोधाभासी हो सकता है, और अन्य महत्वपूर्ण पायथन पुस्तकालय उनके दस्तावेज़ीकरण में अन्य परिभाषा का उपयोग कर सकते हैं।

यह पृष्ठ Set mixin शब्द का भी उपयोग करता है, जो स्पष्ट रूप से सुझाव देता है कि Set और Iterator जैसी कक्षाओं को मिक्सिन क्लास कहा जा सकता है।

अन्य भाषाओं में

  • रुबी: स्पष्ट रूप से मिश्रण के लिए एकाधिक विरासत की आवश्यकता नहीं है, जैसा कि प्रोग्रामिंग रूबी और रूबी प्रोग्रामिंग भाषा जैसी प्रमुख संदर्भ पुस्तकों में उल्लिखित है

  • सी ++: लागू की गई विधि एक शुद्ध आभासी विधि है।

    परिभाषा 1 एक अमूर्त वर्ग (एक वर्ग जिसमें शुद्ध आभासी विधि है) की परिभाषा के साथ मेल खाता है। उस वर्ग को तत्काल नहीं किया जा सकता है।

    वर्चुअल विरासत के साथ परिभाषा 2 संभव है: दो व्युत्पन्न कक्षाओं से एकाधिक विरासत


ओपी ने उल्लेख किया कि उसने सी ++ में मिश्रित के बारे में कभी नहीं सुना है, शायद ऐसा इसलिए है क्योंकि उन्हें सी ++ में उत्सुकता से आवर्ती टेम्पलेट पैटर्न (सीआरटीपी) कहा जाता है। इसके अलावा, @ सीरो संतिली ने उल्लेख किया कि मिश्रण + सी ++ में सार आधार वर्ग के माध्यम से लागू किया गया है। जबकि मिश्रित बेस क्लास का उपयोग मिक्स्लिन को लागू करने के लिए किया जा सकता है, यह एक ओवरकिल है क्योंकि रन-टाइम पर आभासी फ़ंक्शन लुकअप के ओवरहेड के बिना संकलन समय पर टेम्पलेट का उपयोग करके रन-टाइम पर टेम्पलेट का उपयोग करके हासिल किया जा सकता है।

सीआरटीपी पैटर्न का वर्णन here विस्तार से किया गया here

मैंने पाइथन उदाहरण को @Ciro Santilli के उत्तर में सी ++ में नीचे टेम्पलेट वर्ग का उपयोग करके परिवर्तित कर दिया है:

#include <iostream>
#include <assert.h>

template <class T>
class ComparableMixin {
public:
    bool operator !=(ComparableMixin &other) {
        return ~(*static_cast<T*>(this) == static_cast<T&>(other));
    }
    bool operator <(ComparableMixin &other) {
        return ((*(this) != other) && (*static_cast<T*>(this) <= static_cast<T&>(other)));
    }
    bool operator >(ComparableMixin &other) {
        return ~(*static_cast<T*>(this) <= static_cast<T&>(other));
    }
    bool operator >=(ComparableMixin &other) {
        return ((*static_cast<T*>(this) == static_cast<T&>(other)) || (*(this) > other));
    }
};

class Integer: public ComparableMixin<Integer> {
public:
 Integer(int i) {
     this->i = i;
 }
 int i;
 bool operator <=(Integer &other) {
     return (this->i <= other.i);
 }
 bool operator ==(Integer &other) {
     return (this->i == other.i);
 }
};

int main() {

    Integer i(0) ;
    Integer j(1) ;

    assert (i < j );
    assert (i != j);
    assert (j >  i);
    assert (j >= i);

    return 0;
}

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

मैंने मिक्सिन की मूल बातें समझने के लिए इस वीडियो को http://www.youtube.com/watch?v=v_uKI2NOLEM देखा। शुरुआती के लिए मिश्रक की मूल बातें और वे कैसे काम करते हैं और उन्हें लागू करने में आपको जिन समस्याओं का सामना करना पड़ सकता है, उन्हें समझना बहुत उपयोगी है।

विकिपीडिया अभी भी सबसे अच्छा है: http://en.wikipedia.org/wiki/Mixin


मुझे लगता है कि यहां कुछ अच्छी व्याख्याएं हुई हैं लेकिन मैं एक और परिप्रेक्ष्य प्रदान करना चाहता था।

स्कैला में, आप यहां वर्णित मिश्रणों को कर सकते हैं लेकिन बहुत दिलचस्प बात यह है कि मिश्रणों को वास्तव में 'नए' प्रकार के वर्ग बनाने के लिए एक साथ मिलकर बनाया जाता है। संक्षेप में, आप कई वर्गों / मिश्रणों से प्राप्त नहीं होते हैं, बल्कि इसके बजाय, मिश्रण के सभी गुणों के साथ एक नई तरह की कक्षा उत्पन्न करते हैं। यह समझ में आता है क्योंकि स्कैला JVM पर आधारित है जहां एकाधिक-विरासत वर्तमान में समर्थित नहीं है (जावा 8 के रूप में)। इस मिश्रित वर्ग के प्रकार, वैसे, एक विशेष प्रकार है जिसे स्काला में एक विशेषता कहा जाता है।

यह एक कक्षा परिभाषित करने के तरीके पर संकेत दिया गया है: क्लास न्यूक्लास तीसरे मैक्सिन के साथ थर्डमैक्सिन के साथ फर्स्टमैक्सिन का विस्तार करता है ...

मुझे यकीन नहीं है कि क्या सीपीथन दुभाषिया वही करता है (मिश्रित वर्ग-रचना) लेकिन मैं आश्चर्यचकित नहीं होगा। साथ ही, एक सी ++ पृष्ठभूमि से आ रहा है, मैं एक एबीसी या 'इंटरफ़ेस' को मिश्रित के बराबर नहीं कहूंगा - यह एक समान अवधारणा है लेकिन उपयोग और कार्यान्वयन में अलग है।


मैं उनके बारे में कई विरासतों का उपयोग करने के अनुशासित तरीके के रूप में सोचता हूं - क्योंकि आखिरकार एक मिश्रण एक और अजगर वर्ग है जो (संभवतः) मिश्रित नामक कक्षाओं के सम्मेलनों का पालन कर सकता है।

उन सम्मेलनों की मेरी समझ जो कुछ आप नियंत्रित करते हैं, आप मिक्सिन कहेंगे, एक मिक्सिन:

  • विधियों को जोड़ता है लेकिन उदाहरण चर नहीं (वर्ग स्थिरांक ठीक हैं)
  • केवल object से प्राप्त होता object (पायथन में)

इस तरह यह एकाधिक विरासत की संभावित जटिलता को सीमित करता है, और इसे देखने के लिए अपने कार्यक्रम के प्रवाह को ट्रैक करना उचित रूप से आसान बनाता है जहां आपको देखना है (पूर्ण एकाधिक विरासत की तुलना में)। वे रूबी मॉड्यूल के समान हैं।

अगर मैं आवृत्ति चर जोड़ना चाहता हूं (एकल विरासत के लिए अनुमति से अधिक लचीलापन के साथ) तो मैं संरचना के लिए जाना जाता हूं।

ऐसा कहकर, मैंने XYZMixin नामक कक्षाएं देखी हैं जिनमें आवृत्ति चर है।


मैंने पढ़ा है कि आपके पास एसी # पृष्ठभूमि है। तो एक अच्छा प्रारंभिक बिंदु .NET के लिए एक मिश्रण कार्यान्वयन हो सकता है।

आप http://remix.codeplex.com/ पर कोडप्लेक्स प्रोजेक्ट को देखना चाहेंगे

एक सिंहावलोकन प्राप्त करने के लिए lang.net संगोष्ठी लिंक देखें। कोडप्लेक्स पेज पर प्रलेखन पर अभी भी और कुछ है।

स्टीफन का सम्मान करता है


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

तो, आप एक असम्बद्ध मिल्टर एप्लिकेशन लेते हैं, जैसे स्पैमिल्टर, और मिश्रित टेस्टबेस, इस तरह:

class TestMilter(TestBase,spfmilter.spfMilter):
  def __init__(self):
    TestBase.__init__(self)
    spfmilter.config = spfmilter.Config()
    spfmilter.config.access_file = 'test/access.db'
    spfmilter.spfMilter.__init__(self)

फिर, बाजरा आवेदन के लिए परीक्षण मामलों में TestMilter का उपयोग करें:

def testPass(self):
  milter = TestMilter()
  rc = milter.connect('mail.example.com',ip='192.0.2.1')
  self.assertEqual(rc,Milter.CONTINUE)
  rc = milter.feedMsg('test1',sender='[email protected]')
  self.assertEqual(rc,Milter.CONTINUE)
  milter.close()

http://pymilter.cvs.sourceforge.net/viewvc/pymilter/pymilter/Milter/test.py?revision=1.6&view=markup


शायद कुछ उदाहरण मदद करेंगे।

यदि आप कक्षा बना रहे हैं और आप इसे एक शब्दकोश की तरह कार्य करना चाहते हैं, तो आप आवश्यक सभी विभिन्न __ __ विधियों को परिभाषित कर सकते हैं। लेकिन यह दर्द का थोड़ा सा है। एक विकल्प के रूप में, आप केवल कुछ परिभाषित कर सकते हैं, और UserDict.DictMixin से collections.DictMixin (किसी भी अन्य विरासत के अलावा) ( collections.DictMixin में स्थानांतरित हो गए हैं। Py3k मेंDictMixin)। इसका स्वचालित रूप से सभी शेष शब्दकोश एपीआई को परिभाषित करने का असर होगा।

दूसरा उदाहरण: जीयूआई टूलकिट wxPython आपको कई कॉलम (जैसे, विंडोज एक्सप्लोरर में फ़ाइल डिस्प्ले) के साथ सूची नियंत्रण करने की अनुमति देता है। डिफ़ॉल्ट रूप से, ये सूचियां काफी मूल हैं। आप ListCtrl से विरासत में और उचित मिश्रित जोड़कर कॉलम हेडर पर क्लिक करके किसी विशेष कॉलम द्वारा सूची को क्रमबद्ध करने की क्षमता जैसे अतिरिक्त कार्यक्षमता जोड़ सकते हैं।


शायद रूबी से एक उदाहरण मदद कर सकते हैं:

आप मिश्रित Comparable को शामिल कर सकते हैं और एक फ़ंक्शन को परिभाषित कर सकते हैं "<=>(other)" , मिश्रण इन सभी कार्यों को प्रदान करता है:

<(other)
>(other)
==(other)
<=(other)
>=(other)
between?(other)

यह <=>(other) आह्वान करके और सही परिणाम देने के द्वारा करता है।

"instance <=> other" 0 देता है यदि दोनों ऑब्जेक्ट बराबर हैं, 0 से कम यदि instance other से बड़ा है और 0 से अधिक बड़ा है तो other बड़ा है।





mixins