राकू में एक मॉड्यूल में हकलेल जैसे प्रीस्कूल मॉड्यूल का उपयोग करें

Question

मैं कुछ हिस्सों के साथ एक ड्राइंग पैकेज लिख रहा हूं, और मेरे पास ऑपरेटर और डेटा प्रकार बिखरे हुए हैं। हालाँकि, मैं नहीं चाहता कि उपयोगकर्ता हर बार इसी मॉड्यूल को जोड़े, क्योंकि यह काफी गन्दा होगा, उदाहरण के लिए मेरे पास एक Pointवर्ग, एक Monoidभूमिका और Styleविभिन्न रास्तों में एक वर्ग होगा जैसे

unit module Package::Data::Monoid;
# $?FILE = lib/Package/Data/Monoid.pm6

role Monoid {...}

unit module Package::Data::Point;
# $?FILE = lib/Package/Data/Point.pm6

class Point {...}

unit module Package::Data::Style;
# $?FILE = lib/Package/Data/Style.pm6

class Style {...}

मैं एक करना चाहते हैं haskellमें प्रस्तावना की तरह lib/Package/Prelude.pm6 है कि मैं इस तरह के स्क्रिप्ट लिख सकते हैं प्रभाव के साथ

use Package::Prelude;

# I can use Point right away, Style etc...

करने के बजाय

use Package::Data::Style;
use Package::Data::Point;
use Package::Data::Monoid;

# I can too use point right away, but for users not knowing the
# inner workings it's too overwhelming

मैंने कई चीजों की कोशिश की है:

• यह संस्करण मुझे सही प्रभाव नहीं देता है, मुझे पूरे मार्ग को इंगित करने के लिए टाइप करना होगा, अर्थात Package::Data::Point...

unit module Package::Prelude;
# $?FILE = lib/Package/Prelude.pm6
use Package::Data::Style;
use Package::Data::Point;
use Package::Data::Monoid;

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

# $?FILE = lib/Package/Prelude.pm6
use Package::Data::Style;
use Package::Data::Point;
use Package::Data::Monoid;

sub EXPORT {
  hash <Point> => Point
     , <Style> => Style
     , <mappend> => &mappend
     ...
}

क्या आप लोगों को इस तरह की प्रील्यूड जैसी फाइल पाने का एक बेहतर और त्वरित तरीका पता है?

Comments

आप उपयोग कर सकते हैं unit class Package::Data::Point। आप का उपयोग करने की जरूरत नहीं है module।

— ब्रैड गिल्बर्ट

Answer 1

उपयोग करना EXPORTसही दिशा में है। जानने के लिए महत्वपूर्ण बातें हैं:

• आयात शाब्दिक हैं
• हम वर्तमान लेक्सिकल दायरे में प्रतीकों को प्राप्त करने और उन तक पहुंचने के लिए आत्मनिरीक्षण का उपयोग कर सकते हैं

तो नुस्खा है:

• use अंदर के सभी मॉड्यूल EXPORT
• फिर सभी आयातित प्रतीकों को निकालें और परिणाम के रूप में उन्हें वापस करें EXPORT

एक उदाहरण के रूप में, मैं Foo::Pointएक ऑपरेटर और एक वर्ग सहित एक मॉड्यूल बनाता हूं :

unit module Foo::Point;

class Point is export {
    has ($.x, $.y);
}

multi infix:<+>(Point $a, Point $b) is export {
    Point.new(x => $a.x + $b.x, y => $a.y + $b.y)
}

और, बस इसे प्रदर्शित करने के लिए कई मॉड्यूल के साथ काम कर सकते हैं, एक भी Foo::Monad:

unit module Foo::Monad;

class Monad is export {
    method explain() { say "Just think of a burrito..." }
}

यह काम करना लक्ष्य है:

use Foo::Prelude;
say Point.new(x => 2, y => 4) + Point.new(x => 3, y => 5);
Monad.explain;

Foo::Preludeजिसमें एक लिखकर हासिल किया जा सकता है :

sub EXPORT() {
    {
        use Foo::Point;
        use Foo::Monad;
        return ::.pairs.grep(*.key ne '$_').Map;
    }
}

समझाने के लिए यहाँ कुछ विषमताएँ हैं:

1. एक subके अंतर्निहित घोषणाओं है $_, $/, और $!। इनका निर्यात करने पर कंपाइल-टाइम सिंबल क्लैश एरर आएगा, जब मॉड्यूल use'd' होगा। एक ब्लॉक में केवल एक निहित है $_। इस प्रकार हम एक नंगे नंगे ब्लॉक के साथ अपने जीवन को आसान बनाते हैं।
2. यह grepसुनिश्चित करना है कि हम अपने अनुमानित रूप से घोषित $_प्रतीक को निर्यात न करें (नेस्टेड ब्लॉक के लिए धन्यवाद, यह केवल एक है जिसे हमें ध्यान रखना है)।
3. ::वर्तमान स्कोप को संदर्भित करने का एक तरीका है (व्युत्पत्ति: ::पैकेज विभाजक है)। ::.pairsइस प्रकार Pairवर्तमान क्षेत्र में प्रत्येक प्रतीक के लिए वस्तुओं को प्राप्त करता है ।

एक अनुमानित पुन: निर्यात तंत्र है जो भविष्य की Raku भाषा रिलीज में दिखाई दे सकता है जो इस बिट बॉयलरप्लेट की आवश्यकता को समाप्त कर देगा।

Comments

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

— मार्गोलारी