Fable: कल्पित के लिए पायथन समर्थन

यह बहुत अच्छा काम है @dbrattli! Fable के साथ मेरा मूल विचार F# को अन्य भाषाओं में आसानी से संकलित करने का एक तरीका प्रदान करना था। बेहतर या बदतर के लिए, Fable जेएस के साथ इसके मुख्य फोकस के रूप में विकसित हुआ है, इसलिए इसे और अधिक भाषा अज्ञेय बनाने के लिए कुछ काम की आवश्यकता होगी लेकिन मैं इसके लिए खुला रहूंगा। आपके प्रश्नों पर कुछ टिप्पणियाँ:

• वही या अलग रेपो? मैं जितना संभव हो उतना सामान्य कोड रखने के पक्ष में रहूंगा। अलग-अलग रेपो का उपयोग करने से वे काफी तेजी से अलग हो जाएंगे (उद्धरण समर्थन के साथ शाखा को सिंक में रखना पहले से ही मुश्किल है) लेकिन हमें कोड को मॉड्यूलर बनाने की भी आवश्यकता है ताकि लक्ष्य भाषा के आधार पर हमारे पास हर जगह स्थितियां न हों। एक मध्यवर्ती समाधान एक कल्पित "न्यूक्लियस" (हम कोर का उपयोग नहीं कर सकते हैं) के लिए जितना संभव हो उतना कोड निकालने का प्रयास करना होगा और फिर भाषा कार्यान्वयन के लिए अलग-अलग रेपो होंगे।

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

  • एक्सप्रेशन-आधारित एएसटी से एक्सप्रेशन/स्टेटमेंट एएसटी पर जाएं। जेएस के लिए, इसमें कई आईआईएफई से बचने के लिए आवश्यक होने पर फ़ंक्शन के शीर्ष पर परिवर्तनीय घोषणाएं शामिल हैं। मुझे लगता है कि यह पायथन के साथ कुछ ऐसा ही होगा।
  • पैटर्न मिलान (डिसीजनट्री) को अगर/स्विच स्टेटमेंट में बदलना।
  • पूंछ-कॉल अनुकूलन। यह जेएस लेबल वाले लूप का उपयोग करके किया जाता है। पायथन में हमें यह सुनिश्चित करने के लिए एक और तकनीक का उपयोग करने की आवश्यकता होगी कि हम नेस्टेड लूप से न टूटें।
  • आयात को विशिष्ट पहचानकर्ताओं में परिवर्तित करना (यदि आवश्यक हो तो इसे सीधे Fable AST में किया जा सकता है)।

• एफ # अधिक पाइथोनिक बनाएं? Fable के साथ मैंने हमेशा एक संतुलन खोजने की कोशिश की जहां ओवरहेड से बचने के लिए कभी-कभी .NET शब्दार्थ का त्याग किया जाता है। उदाहरण के लिए, हम केवल JS नंबर का उपयोग करते हैं, न कि एक विशिष्ट प्रकार के ints के लिए (हालाँकि हम इसे लंबे समय तक करते हैं), यह Python int लागू होगा जो मुझे लगता है। हालांकि, अप्रत्याशित परिणामों से बचने के लिए विशिष्ट बिंदुओं पर .NET शब्दार्थ का सम्मान करने के लिए कई योगदान किए गए हैं, उदाहरण के लिए पूर्णांक विभाजन या स्पष्ट संख्यात्मक रूपांतरण।
  वैसे भी, जब आप "अधिक पाइथोनिक" कहते हैं तो आपका मतलब कोड शैली या देशी एपीआई है? Fable अधिकांश .NET BCL का समर्थन करने की कोशिश नहीं करता है, लेकिन अंत में हमें सामान्य फ़ंक्शन/ऑपरेटरों का समर्थन करने की आवश्यकता होती है क्योंकि देवों का उपयोग किया जाता है (यहां तक ​​​​कि नवागंतुक, क्योंकि वे ट्यूटोरियल में पाएंगे)। किसी भी मामले में देशी एपीआई का उपयोग करने का विकल्प देना अच्छा है ( Fable.Extras उस अर्थ में एक अच्छा कदम है)। उदाहरण के लिए JS.console.log आमतौर पर printfn तुलना में वस्तुओं को अधिक अच्छी तरह से प्रारूपित करता है, लेकिन हमें बाद वाले का समर्थन करने की आवश्यकता है क्योंकि यह वही है जो देव सबसे अधिक उपयोग करते हैं।

मुझे यह विचार पसंद है। विशेष रूप से मैं एफ # में पायथन पुस्तकालयों का उपयोग करने की उम्मीद कर रहा हूं। आदर्श रूप से हमारे पास शुद्ध पायथन पुस्तकालयों या SciSharp का उपभोग करने का विकल्प होना चाहिए - उनके पास लगभग सटीक एपीआई पायथन के रूप में होता है (पायथन या .NET संदर्भ में समान एफ # कोड चलाया जाता है!)

इस तरह के F# कोड को Fable in Python के साथ संकलित किया जा सकता है और फिर नोटबुक कर्नेल (Jupyter या .NET इंटरएक्टिव) के भीतर उपयोग किया जा सकता है, जिससे एनालिटिक्स वर्कफ़्लो वास्तविक डोमेन-चालित सुविधा बन जाता है (मैं इसे "हत्या की सुविधा" के रूप में मान सकता था)।

.NET इंटरएक्टिव बहुत एक्स्टेंसिबल है, F# कर्नेल के अंदर Fable चलाना बहुत आसान है (मेरे पास PoC काम कर रहा है)।

एक और बात यह है कि मैं भविष्यवाणी करता हूं कि एमएस जल्द ही पूरे .NET के लिए कुछ इसी तरह की शांति प्रकट करेगा (भविष्यवाणी केवल गतिविधियों और लक्ष्यों पर आधारित है। नेट इंटरएक्टिव टैकल इसलिए मैं गलत हो सकता हूं)। यहां तक ​​​​कि अगर वे करते हैं तो भी हम चाहते हैं कि एक कार्यात्मक दुनिया में जेएस/एफ #/पायथन शस्त्रागार को पूरा करने के लिए फैबल को अलग से रखा जाए। एमएस दृष्टिकोण ब्लेज़र-स्वाद (मुझे लगता है) की तरह अधिक होगा।

धन्यवाद, यह बहुत अच्छी प्रतिक्रिया है @alfonsogarciacaro , @PawelStadnicki । मेरा मतलब यह था कि अगर हम प्रोग्रामर को .NET को फिर से लागू करने की कोशिश करने के बजाय अधिक पायथन मानक पुस्तकालय को उजागर करके "पायथन" महसूस करने देना चाहते हैं (तब उन्हें शायद इसके बजाय .NET का उपयोग करना चाहिए)।

मुझे लगता है कि हम दोनों दुनिया से सर्वश्रेष्ठ प्राप्त कर सकते हैं, और उपयोगकर्ता को यह तय करना है कि क्या आयात करना है या नहीं (उदाहरण के लिए पायथन से datetime या .NET से DateTime )। इसलिए निर्णय लेने की कोई आवश्यकता नहीं है, लेकिन केवल वही लागू करें जो हम सबसे अधिक (ऑन-डिमांड) चाहते हैं। लेकिन मुझे संदेह है कि वही समस्या Fable JS के लिए प्रासंगिक है। आप जानते हैं कि आप एक वेब ऐप लागू कर रहे हैं, और शायद सभी .NET उपलब्ध होने की उम्मीद नहीं करते हैं। इसके बजाय आपके पास JS पारिस्थितिकी तंत्र तक बेहतर पहुंच होगी।

इसलिए पहले से निर्णय लेने की जरूरत नहीं है। आइए आगे बढ़ते हैं और आगे बढ़ते हैं Fable का हिस्सा बनना और इस मुद्दे को रास्ते में प्रश्न पूछने के लिए बहुत अच्छा होगा, उदाहरण के लिए परिवर्तन आदि के बारे में। सीखने के लिए बहुत कुछ है।

पीएस: अभिव्यक्ति बीटीडब्ल्यू में एक पूंछ-कॉल सजावटी भी है जिसका हम उपयोग कर सकते हैं (सिंक और एसिंक दोनों)। यहाँ aioreactive में एक उदाहरण उपयोग है।

मुझे #1601 के बारे में सोचता है।

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

हम बैबेल एएसटी को अधिक सामान्य (और टाइप किया हुआ) बनाने की कोशिश कर सकते हैं ताकि इसे आसानी से सी-जैसी भाषाओं में रूपांतरित/मुद्रित किया जा सके। हालाँकि, अगर मैंने Fable को विकसित करते समय कुछ सीखा है, तो यह है कि एक साधारण F#-से-अन्य-भाषा संकलक लिखना (अधिक या कम) आसान है, लेकिन एक अच्छा विकास अनुभव और एकीकरण प्रदान करता है, इसलिए F# के लाभ के साथ घर्षण को घटाता है विदेशी पारिस्थितिकी तंत्र मूल भाषा में विकसित होने से अधिक वजन का काफी कठिन है।

@alfonsogarciacaro ने क्या कहा। उस चुनौती का एक हिस्सा F# में अधिक Fable BCL कार्यान्वयन को माइग्रेट करना है, इसलिए इसे हर भाषा के लिए फिर से लिखने की आवश्यकता नहीं है, जबकि जनरेट किए गए कोड के लिए स्वीकार्य मूल प्रदर्शन को बनाए रखते हुए, कुछ ऐसा जो जावास्क्रिप्ट के साथ भी गैर-तुच्छ है।

दिलचस्प। मुझे नहीं पता था कि फैबल बीसीएल कार्यान्वयन के महत्वपूर्ण हिस्से (संभवतः) जावास्क्रिप्ट में लिखे गए थे। मुझे लगता है कि यह पहले से ही अधिक एफ # होगा। मुझे इसमें कोई संदेह नहीं है कि इसका कोई अच्छा कारण है - यह इस तरह से आसान क्यों हो गया?

@jwosty (इतना छोटा नहीं) उत्तर है: प्रदर्शन कारणों से, और F # प्रकार बनाम प्रकार के बीच अंतर को पाटने के लिए जो मूल रूप से ब्राउज़र द्वारा समर्थित है, और जावास्क्रिप्ट पारिस्थितिकी तंत्र के भीतर उत्पन्न कोड के बेहतर एकीकरण के लिए।

इसके अलावा .NET BCL में FSharp.Core शीर्ष पर एक बहुत बड़ी एपीआई सतह है, इसलिए एक बड़ी टीम के बिना इस प्रयास को बनाए रखना मुश्किल है (हालांकि @alfonsogarciacaro किसी भी तरह इसे मुख्य रूप से बनाए रखने और विकसित करने का प्रबंधन करता है, जो अद्भुत और प्रशंसनीय है)।

मुझे लगता है कि मैं जो कहना चाह रहा हूं वह यह है कि योगदान (और विचार) का बहुत स्वागत और सराहना की जाती है।

(इतना छोटा नहीं) उत्तर है: प्रदर्शन कारणों से, और F # प्रकार बनाम प्रकार के बीच अंतर को पाटने के लिए जो मूल रूप से ब्राउज़र द्वारा समर्थित है, और जावास्क्रिप्ट पारिस्थितिकी तंत्र के भीतर उत्पन्न कोड के बेहतर एकीकरण के लिए।

मैं देख सकता हु।

मुझे लगता है कि मैं जो कहना चाह रहा हूं वह यह है कि योगदान (और विचार) का बहुत स्वागत और सराहना की जाती है।

पक्का! मैं समझता हूं कि इस तरह की बड़ी और महत्वपूर्ण परियोजनाओं को बनाए रखने में कितना प्रयास किया जाता है, और मैं वास्तव में आपके खून के पसीने और आँसू की सराहना करता हूं जो आप लोगों ने इसमें डाला है। निश्चित रूप से योगदान करने के स्थानों के लिए अपनी आँखें खुली रख रहा हूँ, क्योंकि कल्पित कहानी हाल ही में मेरे लिए बहुत उपयोगी रही है और मुझे वापस देना अच्छा लगेगा।

मैं थोड़ी मदद का उपयोग कर सकता था। मैं वर्तमान में विकास के लिए QuickTest प्रोजेक्ट का उपयोग कर रहा हूं (यानी dotnet fsi build.fsx quicktest )। विकसित करते समय मैं बैबेल एएसटी को कैसे प्रिंट करूं? ( अपडेट करें : मुझे ASTViewer मिला)।

मेरी वर्तमान समस्या यह है कि पायथन मल्टीलाइन लैम्ब्डा (एरो फ़ंक्शंस) का समर्थन नहीं करता है, इसलिए लैम्ब्डा को एक नामित फ़ंक्शन में बदलने और निकालने की आवश्यकता है और इसके बजाय उस फ़ंक्शन को कॉल करें। यहां किसी भी सुझाव की सराहना की जाएगी। जैसे:

let fn args cont  =
    cont args

let b = fn 10 (fun a ->
    a + 1
)

में बदलने की आवश्यकता होगी:

let fn args cont  =
    cont args

let cont a =
    a + 1
let b = fn 10 cont

एक कॉल एक्सप्रेशन को कई स्टेटमेंट्स के साथ बदलते समय मुझे कैसे सोचना चाहिए क्योंकि फंक्शन कॉल को आर्ग्स के साथ बदलने के बाद मुझे इसे उच्च स्तर पर बदलने की जरूरत है, या किसी प्रकार के ब्लॉक स्टेटमेंट का उपयोग करना चाहिए जैसे if true then ... कोई विचार?

@dbrattli यह प्रिंटर भी देखें, जो कुछ गुणों को भी प्रिंट करता है।

मुझे नहीं पता था कि फैबल बीसीएल कार्यान्वयन के महत्वपूर्ण हिस्से (संभवतः) जावास्क्रिप्ट में लिखे गए थे। मुझे लगता है कि यह पहले से ही अधिक एफ # होगा। मुझे इसमें कोई संदेह नहीं है कि इसका एक अच्छा कारण है - यह इस तरह से आसान क्यों हो गया?

हां, जैसा कि @ncave ने कहा, मुख्य कारण अधिक मानक JS उत्पन्न करना था। उदाहरण के लिए, फ़नस्क्रिप्ट में सभी FSharp.Core प्रतिस्थापन F# में लिखे गए थे, लेकिन Fable के साथ जब भी संभव हो मैं JS मानकों के साथ एकीकृत करना चाहता था (उदाहरण के लिए .NET IEnumerable के बजाय JS इटरेटर्स का उपयोग करना) जिससे कई चिकन-और-अंडे की समस्याएं आईं शुरुआत में इसे JS/टाइपस्क्रिप्ट में लिखना आसान था। शुरुआत में मुझे फैब-लाइब्रेरी को एक अलग पैकेज के रूप में प्रकाशित करने का भी विचार था जिसे जेएस परियोजनाओं में इस्तेमाल किया जा सकता था, लेकिन मैंने इसे जल्दी से त्याग दिया।

Fable 2 में हमने कुछ मॉड्यूल्स को F# में पोर्ट करने का प्रयास शुरू किया। यह बहुत फायदेमंद रहा है क्योंकि यह डॉगफूडिंग को बढ़ाता है और हमें आसानी से FSharp.Core में सुधारों का पुन: उपयोग करने देता है (जैसा कि हाल ही में नक्शे और सेट के साथ)। हालांकि, चिकन और अंडे के मुद्दों के आसपास काम करने के लिए यहां और वहां कुछ हैक अभी भी हैं। और चलो बड़े राक्षस के बारे में बात नहीं करते हैं जो कि रिप्लेसमेंट मॉड्यूल है :)

जैसा कि @ncave कहते हैं, इस पुस्तकालय को बनाए रखना एक बहुत बड़ा उपक्रम है, इसलिए मैं रखरखाव सतह को कम करने के लिए बीसीएल के लिए समर्थन बढ़ाने के लिए हमेशा अनिच्छुक हूं, लेकिन मैं बहुत भाग्यशाली रहा हूं कि पुस्तकालय में कई महान योगदान रहे हैं बिल्कुल शुरू से।

@dbrattli एएसटी को प्रिंट करने के बारे में, यह कुछ समय हो गया है कि मैंने Fable रेपो में ASTViewer टूल का उपयोग नहीं किया है। बेहतर विकल्प @ncave या विज़ुअलाइज़र द्वारा इंगित किए गए हैं, जो कि मैं हाल ही में उपयोग करता हूं जब मुझे एफ # एएसटी का निरीक्षण करने की आवश्यकता होती है (बस टाइप किए गए एएसटी का चयन करना सुनिश्चित करें)। दुर्भाग्य से हमारे पास अभी तक Fable या Bable AST के लिए विशिष्ट प्रिंटर नहीं हैं। फैबल एएसटी के मामले में, क्योंकि यह सिर्फ यूनियन है और एक साधारण printfn "%A" काम करता है, हालांकि स्थान की जानकारी थोड़ी शोर है।

लैम्ब्डा निकालने के बारे में। यह संभव है लेकिन कुछ काम की आवश्यकता है। मुझे लगता है कि हम आयात के समान कुछ कर सकते हैं, यानी, एएसटी को पार करते समय उन्हें एकत्रित करना , और उन्हें एक अद्वितीय पहचानकर्ता असाइन करना। बाद में हम केवल फ़ाइल के शीर्ष पर फ़ंक्शन घोषित कर सकते हैं। मुख्य चुनौती संभावित रूप से कैप्चर किए गए मान होंगे, मुझे याद नहीं है कि एफ # एएसटी के पास इस बारे में जानकारी है, लेकिन अगर उसके पास भी है, तो दुर्भाग्य से हम इसे एएसटी में नहीं रखते हैं, इसलिए मुझे लगता है कि हमें करना होगा लैम्ब्डा बॉडी में उपयोग किए गए सभी पहचानों को ढूंढें जो तर्कों (या लैम्ब्डा के भीतर बाइंडिंग) के अनुरूप नहीं हैं और उन्हें लैम्ब्डा के अतिरिक्त तर्कों में परिवर्तित करते हैं (और मुझे लगता है कि उन्हें करी में हस्तक्षेप से बचने के लिए शुरुआत में जाना चाहिए)।

बढ़िया जानकारी के लिए धन्यवाद @alfonsogarciacaro , मेरा पहला PoC सिर्फ Babel.fs / Fable2Babel.fs , BabelPrinter.fs आदि को बदल रहा था। अब मैंने एक अलग पायथन एएसटी यानी Python.fs साथ शुरुआत से शुरुआत की है। PythonPrinter.fs । फिर मैं Babel2Python.fs को जोड़ने का प्रयास करूँगा ताकि Babel AST से Python AST में रूपांतरित किया जा सके क्योंकि यह Fable AST से परिवर्तित होने से आसान हो सकता है (लेकिन Fable2Python.fs साथ भी संभव है यदि Babel से कनवर्ट करना समाप्त हो जाता है) कठिन)। इस तरह मैं मौजूदा कोड बेस को बहुत ज्यादा नहीं छूऊंगा, और मेरा अपना परिवर्तन होगा जहां मैं लैम्ब्डा को फिर से लिखने की कोशिश करूंगा।

यह समझ आता है। एक कठिनाई यह है कि बेबेल एएसटी डीयू से नहीं बना है, इसलिए पैटर्न मिलान के साथ इसे पार करना थोड़ा अधिक कठिन है। शायद #2158 मदद कर सकता है?

@alfonsogarciacaro मुझे लगता है कि मैं तीर-फ़ंक्शंस और फ़ंक्शन-एक्सप्रेशन के पुनर्लेखन को इस तरह से ठीक करने में कामयाब रहा हूं कि मुझे लगता है (आशा) वास्तव में काम कर सकता है। विचार यह है कि प्रत्येक अभिव्यक्ति ( TransformAsExpr ) भी बयानों की एक सूची देता है (जिसे संयोजित करने और बयानों की अंतिम सूची (अंतिम-कथन-स्तर) तक सभी तरह से पारित करने की आवश्यकता होती है। फिर सभी लौटाए गए बयान (func-def) को ऊपर और ऊपर उठाया जाएगा और अन्य बयानों के सामने लिखा जाएगा। तो एक तीर- या फ़ंक्शन-एक्सप्रेशन बस name-expression, [statement ] लौटाएगा जहां तीर/फ़ंक्शन-एक्सप्रेशन को फिर से लिखा जाता है बयान और नाम-अभिव्यक्ति के साथ लौटा। इसका मतलब है कि:

module QuickTest

let fn args cont  =
    cont args

let b = fn 10 (fun a ->
    printfn "test"
    a + 1
)

निम्नलिखित जेएस उत्पन्न करता है:

import { printf, toConsole } from "./.fable/fable-library.3.1.1/String.js";

export function fn(args, cont) {
    return cont(args);
}

export const b = fn(10, (a) => {
    toConsole(printf("test"));
    return (a + 1) | 0;
});

जो बदले में निम्नलिखित पायथन उत्पन्न करता है:

from expression.fable.string import (printf, toConsole)

def fn(args, cont):
    return cont(args)


def lifted_5094(a):
    toConsole(printf("test"))
    return (a + 1) | 0


b = fn(10, lifted_5094)

मैंने सोचा कि मुझे क्लोजर को संभालने में समस्या हो सकती है, लेकिन अधिकांश (सभी?) मामलों में क्लोजर को भी हटा दिया जाता है जैसे:

module QuickTest

let add(a, b, cont) =
    cont(a + b)

let square(x, cont) =
    cont(x * x)

let sqrt(x, cont) =
    cont(sqrt(x))

let pythagoras(a, b, cont) =
    square(a, (fun aa ->
        printfn "1"
        square(b, (fun bb ->
            printfn "2"
            add(aa, bb, (fun aabb ->
                printfn "3"
                sqrt(aabb, (fun result ->
                    cont(result)
                ))
            ))
        ))
    ))

को फिर से लिखा जाएगा:

from expression.fable.string import (printf, toConsole)

def add(a, b, cont):
    return cont(a + b)


def square(x, cont):
    return cont(x * x)


def sqrt(x, cont):
    return cont(math.sqrt(x))


def pythagoras(a, b, cont):
    def lifted_1569(aa):
        toConsole(printf("1"))
        def lifted_790(bb):
            toConsole(printf("2"))
            def lifted_6359(aabb):
                toConsole(printf("3"))
                return sqrt(aabb, lambda result: cont(result))

            return add(aa, bb, lifted_6359)

        return square(b, lifted_790)

    return square(a, lifted_1569)

वैसे भी, यह अच्छी शुरुआत है 😄

मैंने PHP के लिए काफी कुछ किया, (और यह BGA पर CrazyFarmers चला रहा है) तो शायद हम यहां प्रयास को जोड़ सकें?

https://github.com/thinkbeforecoding/peeble

@ncave क्या आपके पास जुपिटर नोटबुक जैसे इंटरैक्टिव उपयोग के लिए Fable का उपयोग करने के बारे में कोई सुझाव है? समस्या यह है कि जुपिटर आपको एक कोड खंड (सेल) देगा और कर्नेल को इस टुकड़े को पिछले बयानों से किसी भी मौजूदा स्थानीय घोषणा के साथ संकलित करने की आवश्यकता है।

Fable इसके लिए इष्टतम नहीं है, लेकिन मैंने एक PoC बनाया है जहाँ मैं पिछले कथनों/घोषणाओं (चलो, टाइप करें, खुला) का एक आदेशित शब्दकोश रखता हूँ और अंतिम कोड खंड के साथ क्रम में उनका उपयोग करके एक वैध F# प्रोग्राम बनाता हूँ। कोड खंड में किसी भी घोषणा को निष्पादन से पहले ताना से हटा दिया जाता है और बाद में जोड़ा जाता है। ऐसा लगता है, लेकिन मैं सोच रहा हूं कि शायद कोई बेहतर तरीका है या नहीं?

स्रोत: https://github.com/dbrattli/Fable.Jupyter/blob/main/fable/kernel.py#L85

तब मेरे पास पृष्ठभूमि में चलने वाली एक Fable cli है जो जब भी Fable.fs को अपडेट किया जाता है, तब उसे पुन: संकलित करता है।

dotnet watch -p src/Fable.Cli run -- watch --cwd /Users/dbrattli/Developer/GitHub/Fable.Jupyter --exclude Fable.Core --forcePkgs --python

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

केवल FYI करें, यदि आपको अधिक नियंत्रण की आवश्यकता है, तो आप Fable को एक पुस्तकालय के रूप में भी उपयोग कर सकते हैं, न कि केवल CLI (देखें fable-standalone , और एक उपयोग उदाहरण )।

1) मेरी एक समस्या यह है कि Fable AST में थ्रो/राइज नहीं है। तो इसे एक एमिट अभिव्यक्ति में बनाया जाएगा जो मेरे लिए पार्स करने के लिए कठिन (एर) है। या कम से कम यह अनावश्यक लगता है जब बेबेल के पास थ्रोस्टेटमेंट होता है। क्या इसका कोई अच्छा कारण है कि इसका उपयोग नहीं किया जा रहा है, या क्या मुझे इसे ठीक करने का प्रयास करना चाहिए? @alfonsogarciacaro

let divide1 x y =
   try
      Some (x / y)
   with
      | :? System.DivideByZeroException -> printfn "Division by zero!"; None

let result1 = divide1 100 0

उत्पन्न करता है:

export function divide1(x, y) {
    try {
        return ~(~(x / y));
    }
    catch (matchValue) {
        throw matchValue;
    }
}

export const result1 = divide1(100, 0);

जहां throw matchValue एक EmitExpression ।

2) क्या हमें Fable AST में ThisExpr जोड़ना चाहिए, ताकि मैं यह पहचान सकूं कि this का उपयोग इस कीवर्ड के रूप में किया जा रहा है या नहीं। मुझे यकीन नहीं हो रहा है कि Fable.IdentExpr को this सेट किया गया है यदि यह यह-कीवर्ड है या नहीं, क्योंकि उन्हें पायथन में self में अनुवादित करने की आवश्यकता है।
https://github.com/fable-compiler/Fable/blob/nagareyama/src/Fable.Transforms/Fable2Babel.fs#L792

यह मज़ेदार है, थ्रो वास्तव में Fable 2 AST में था लेकिन मैंने AST को सरल बनाने के प्रयास में Fable 3 के लिए इसे हटा दिया क्योंकि इसका उपयोग केवल एक ही स्थान पर किया गया था, लेकिन मुझे लगता है कि हम इसे फिर से जोड़ सकते हैं।

"इस" के बारे में, यह मुश्किल है। मुझे इसे फिर से जांचने की ज़रूरत है क्योंकि एफ # एएसटी में इसे कन्स्ट्रक्टर या विधियों में अलग-अलग प्रतिनिधित्व किया जाता है (कोड के माध्यम से बिखरे हुए इस बारे में कुछ टिप्पणियां हैं)। Fable AST में पहचानकर्ताओं के लिए IsThisArgument प्रॉपर्टी है, लेकिन मुझे यह जांचने दें कि क्या यह केवल अलग सदस्यों के पहले तर्क के लिए है या यह "वास्तविक इस" के लिए भी काम करता है या नहीं।

@alfonsogarciacaro मैं "आंतरिक" बनाम "उपयोगकर्ता" संकलित कोड को संभालने के तरीके के साथ थोड़ी मदद का उपयोग कर सकता हूं उदाहरण के लिए अपवाद .message , लेकिन मुझे इसका अनुवाद कैसे करना चाहिए? क्या मैं यह सुनिश्चित कर सकता हूं कि उपयोगकर्ता संकलित कोड में कभी भी .message होगा और हमेशा के रूप में समाप्त होगा जैसे Test__Message_229D3F39(x, e) ताकि वे कभी हस्तक्षेप न करें? या क्या मुझे उदाहरण के लिए JsException ऑब्जेक्ट के भीतर एक कैच'एड अपवाद लपेटना है और सुनिश्चित करने के लिए .message संपत्ति जोड़ना है? Fable इसे F# से Babel तक कैसे करते हैं? क्या आप प्रकारों का ट्रैक रखते हैं, या?

उदाहरण के लिए: कैसे करता है ex.Message.StartsWith एफ में # बन ex.message.indexOf जे एस में? मुझे इसे पायथन में str(ex).index में अनुवाद करना होगा (या वस्तुओं को लपेटना होगा)।

असल में हमारे पास एफ # अपवादों के साथ एक समस्या है (जैसा कि: int * int के अपवाद फू) मैंने Fable 3 रिलीज से पहले ठीक नहीं किया था System.Exception को जेएस त्रुटि के रूप में अनुवादित किया गया है, इसलिए उनके पास एक .message फ़ील्ड है। लेकिन एफ # अपवाद प्रदर्शन कारणों से जेएस त्रुटि से प्राप्त नहीं हो रहे हैं (मुझे लगता है कि अभी तक पहुंचने का प्रयास कर रहा है। संदेश बस विफल रहता है)। इसको लेकर कहीं चर्चा है। आपके मामले के लिए और सामान्य अपवाद के लिए मुझे लगता है कि आप अभी के लिए मान सकते हैं कि Fable .message और .stack गुणों तक पहुंचता है।

हम कैसे चाहते हैं कि भाषा का चयन Fable में हो? आज हम --typescript का उपयोग करके उदाहरण के लिए टाइपस्क्रिप्ट का चयन कर सकते हैं। इसलिए हम --python का उपयोग करके पायथन का चयन कर सकते हैं। लेकिन क्या हमें तब .js उत्पन्न करना बंद कर देना चाहिए? हमें शायद ऐसा करना चाहिए क्योंकि उत्पन्न जेएस मान्य नहीं हो सकता है उदाहरण के लिए एमिट का उपयोग किया जाता है। लेकिन कभी-कभी हम जेएस देखना चाहते हैं। क्या हमारे पास --javascript विकल्प होना चाहिए, या क्या हमें जावास्क्रिप्ट प्राप्त करने के लिए उपयोगकर्ता को --python बिना चलाने की आवश्यकता होनी चाहिए? @alfonsogarciacaro

@dbrattli --typescript केवल .ts फाइलें जेनरेट करता है, .py यदि आप चाहें तो --python सिर्फ .py फाइलें जेनरेट कर सकते हैं।
लेकिन तकनीकी रूप से वे सब परस्पर अनन्य हैं, तो हम बजाय एक नया परिचय चाहिए --language स्विच, मूल्यों के साथ JavaScript/TypeScript/Python ?

@ncave हां, मुझे लगता है कि यह एक अच्छा विचार है जैसे [-lang|--language {"JavaScript"|"TypeScript"|"Python"}] जहां JavaScript डिफ़ॉल्ट हो सकता है। मैंने पहले ही कंपाइलर के लिए एक भाषा गुण जोड़ना शुरू कर दिया है, इसलिए मैं कमांड लाइन विकल्पों को भी ठीक करने का प्रयास कर सकता हूं? https://github.com/fable-compiler/Fable/pull/2345/files#diff -9cb94477ca17c7556e6f79d71ed20b71740376f7f3b00ee0ac3fdd7e519ac577R12

कुछ स्थिति। पायथन समर्थन बेहतर हो रहा है। कई भाषा सुविधाएँ अब जगह में हैं। विशाल शेष कार्य कल्पित-पुस्तकालय को पोर्ट करना है। इसे आसान बनाने के लिए पायथन के लिए फैबल-लाइब्रेरी को रेपो में स्थानांतरित कर दिया गया है, इसलिए हम कई फ़ेबल-लाइब्रेरी .fs फ़ाइलों को पायथन में परिवर्तित और पुन: उपयोग कर सकते हैं। हालांकि, उनमें से कई में जेएस उत्सर्जित कोड होता है जिसे "मैन्युअल रूप से" इंटरसेप्ट और हैंडल करने की आवश्यकता होती है। पायथन के लिए एक परीक्षण सेटअप (पाइटेस्ट पर आधारित) वर्तमान में 43 परीक्षण पास करने के साथ है, इसलिए इससे नई सुविधाओं को विकसित करना और जोड़ना बहुत आसान हो जाता है (और दिखाता है कि क्या काम कर रहा है)।

पायथन के लिए फैबल-लाइब्रेरी बनाएँ: dotnet fsi build.fsx library-py
पायथन परीक्षण चलाएँ: dotnet fsi build.fsx test-py

@dbrattli
आदर्श रूप से हमें अधिक से अधिक fable-library को F# में बदलने का प्रयास करना चाहिए। List और Seq पहले से मौजूद हैं, Array कम संख्या में देशी तरीकों का उपयोग करता है, शायद उन्हें अलग किया जा सकता है।

थोड़े अलग विषय पर, आपकी राय में, सीधे Fable AST के बजाय Babel AST से एक नया भाषा कोडजन लागू करने के मुख्य लाभ क्या हैं?

@ncave पायथन और जावास्क्रिप्ट काफी करीब हैं (आईएमओ) इसलिए बेबेल एएसटी को फिर से लिखना अपेक्षाकृत आसान है। मैंने पहले कुछ JS को Python में पोर्ट किया है जैसे RxJS से RxPY। हमें "अपस्ट्रीम" किए जा रहे सभी (बग-) फिक्स का भी लाभ मिलता है। जैसा कि कहा गया है, हम में से ज्यादातर के पुन: उपयोग कर सकता है Fable2Babel.fs और एक का उपयोग कर अजगर को सीधे बदलने Fable2Python.fs कि जोड़ती / गिर Fable2Babel.fs और Babel2Python.fs । मैंने वास्तव में आज पहले इसके बारे में सोचा था। यह तब एक कांटा की तरह हो जाता है और दोनों जगहों पर बगफिक्स को लागू करने की सबसे अधिक आवश्यकता होगी। अभी के लिए मुझे लगता है कि बैबेल एएसटी को बदलना ठीक है, लेकिन अंततः हम फैबल एएसटी को सीधे बदलना चाहते हैं।

यह बहुत अच्छा है @dbrattli! आपके सभी कामों के लिए बहुत-बहुत धन्यवाद। असल में, मेरे मन में जो कुछ था वह लाइब्रेरी में अधिकांश Fable कोड डाल रहा था और अलग-अलग कार्यान्वयन को स्वतंत्र डॉटनेट टूल्स के रूप में रिलीज़ कर रहा था: fable (-js), fable-py (या कोई अन्य नाम)। हो सकता है कि यह हमें रिलीज चक्र में अधिक स्वतंत्रता देता है, लेकिन मैं एक एकल डॉटनेट टूल के साथ भी पूरी तरह से ठीक हूं जो दोनों भाषाओं को संकलित कर सकता है। यह आसान हो सकता है, खासकर शुरुआत में।

फैबल-लाइब्रेरी के बारे में, हाँ, यदि संभव हो तो पाइथन में वर्तमान .ts फाइलों को फिर से लिखने के बजाय, उन्हें इसके बजाय F# पर पोर्ट करना अच्छा होगा। हमें Emit का उपयोग करके भागों को अलग करने का प्रयास करना चाहिए और #if का उपयोग करके उन्हें पायथन में अनुकूलित करना चाहिए:

#if FABLE_COMPILER_PYTHON
    [<Emit("print($0)")>]
    let log(x: obj) = ()

　// Other native methods ...
#else
    [<Emit("console.log($0)")>]
    let log(x: obj) = ()

    // ...
#endif

या हम एक नया "बहु-भाषा" एमिट विशेषता जोड़ सकते हैं:

type EmitLangAttribute(macros: string[]) =
    inherit Attribute()

[<EmitLang([|"js:console.log($0)"; "py:print($0)"|])>]
let log(x: obj) = ()

धन्यवाद @alfonsogarciacaro और @ncave , ये बहुत अच्छे विचार हैं। मैं उन्हें यह देखने की कोशिश करूंगा कि क्या काम करता है। मुझे Fable-Library को F# में अनुवाद करने का लाभ दिखाई देता है, इसलिए मैं यहां मदद करने की कोशिश करूंगा जब एक बार पाइथन कंपाइलर वहां फाइलों को संभालने के लिए पर्याप्त हो। #if का उपयोग करने से बहुत मदद मिलनी चाहिए, और हम शायद भाषा विशिष्ट पुस्तकालय फ़ाइलों में उत्सर्जन को स्थानांतरित करके #if s से बच सकते हैं (क्योंकि मेरे पास पायथन के लिए एक अलग .fsproj फ़ाइल है।

@alfonsogarciacaro इसके बजाय दो उत्सर्जन गुण क्यों नहीं हैं? JS के लिए Emit और Python के लिए EmitPy। जब जेएस आदि के लिए उत्सर्जन का सामना करना पड़ता है तो पाइथन ट्रांसपिलर को कमजोर होने की रिपोर्ट करनी चाहिए।

मेरे 2 सेंट के लिए, मुझे एक एकल एमिट विशेषता होने का वर्तमान कम संज्ञानात्मक भार पसंद है जो बस उत्सर्जित होता है। इमो जो @dbrattli अभी कर रहा है वह समझ में आता है (प्रत्येक fable-library भाषा संस्करण के लिए अलग प्रोजेक्ट फ़ाइल)। हम अलग-अलग भाषा के उत्सर्जन को अपनी फाइलों में अलग कर सकते हैं, जो अच्छी तरह से परिभाषित इंटरफेस (या मॉड्यूल) को लागू करते हैं जिन्हें बाद में सामान्य एफ # कार्यान्वयन से बुलाया जाएगा।

एक अच्छा उदाहरण Array.Helpers को एक इंटरफ़ेस में परिवर्तित करना हो सकता है (या इसे केवल मॉड्यूल के रूप में छोड़ दें) जिसे प्रत्येक लक्ष्य भाषा के लिए लागू किया जा सकता है। शायद fable-library से अधिक F# (साथ ही --language कंपाइलर विकल्प) में माइग्रेट करने का यह प्रयास इस से एक अलग पीआर में जा सकता है, इसलिए यह तेजी से जा सकता है और इसमें अधिक आसानी से योगदान दिया जा सकता है .

यह एक अच्छा विचार है @ncave :+1: वास्तव में हम पहले से ही ऐसा कर रहे हैं जब मल्टीप्लेटफार्म फैबल प्रोजेक्ट्स (.net और js) में मूल कोड को अलग कर रहे हैं। चीजों को सरल बनाने के लिए मैं शायद Fable.Library में एक नई Native.fs फ़ाइल जोड़ूंगा और आवश्यकतानुसार वहां सबमॉड्यूल रखूंगा, जैसे:

namespace Fable.Library.Native            # or just Native

module Array = ..
module Map = ..

हमें वहां कुछ भी स्थानांतरित करना चाहिए जो Emit या Fable.Core.JS से मूल्यों का उपयोग करता है।

एसिंक्स पर काम करना मैं Async.ts और AsyncBuilder.ts को F# यानी Async.fs और AsyncBuilder.fs पोर्ट करने की कोशिश कर रहा हूं। लेकिन अब मुझे समस्या है कि कोड के साथ मेरी टेस्ट फाइल:

async { return () }
|> Async.StartImmediate

पायथन उत्पन्न करता है (जेएस कोड बहुत समान होना चाहिए) कोड:

startImmediate(singleton.Delay(lambda _=None: singleton.Return()))

AsyncBuilder में हालांकि कोई विधि नहीं है लेकिन AsyncBuilder__Delay_458C1ECD । तो मुझे विशेषता त्रुटि मिलती है: 'AsyncBuilder' ऑब्जेक्ट में कोई विशेषता नहीं है 'विलंब'।

class AsyncBuilder:
    def __init__(self):
        namedtuple("object", [])()

def AsyncBuilder__ctor():
    return AsyncBuilder()

def AsyncBuilder__Delay_458C1ECD(x, generator):
    def lifted_17(ctx_1):
        def lifted_16(ctx):
            generator(None, ctx)

        protectedCont(lifted_16, ctx_1)

    return lifted_17
...

मैं इससे कैसे निपट सकता हूं इस पर कोई संकेत? @ncave @alfonsogarciacaro। वहाँ एक तरह से मैं कर सकते हैं एफ # वर्गों के तरीकों के साथ कक्षाओं उत्पन्न, या मेरे परीक्षण कोड उत्पन्न है कि का उपयोग करता है स्थिर AsyncBuilder__Delay_458C1ECD के बजाय .Delay() ?

@dbrattli आमतौर पर डी- उलझन में नहीं डालना चाहते हैं।
संबंधित नोट पर, async उन सुविधाओं में से एक का समर्थन करता है जो मूल पायथन asyncio अनुवाद के लिए शायद बेहतर अनुकूल हैं?

@ncave ठीक है, तो यह इस तरह काम करता है अंतर्दृष्टि के लिए धन्यवाद। मैं बिल्डर को एक इंटरफेस के पीछे रखने की कोशिश करूंगा और देख सकता हूं कि यह मदद करता है (भले ही एफ # बिल्डर्स इंटरफेस न हों, इसे शायद ठीक काम करना चाहिए)। async लिए योजना देशी पायथन एसिंक्सियो ( यहां देखें ) का उपयोग करने की थी, लेकिन python cannot reuse already awaited coroutine साथ समस्याएं मिलीं, इसलिए मुझे उन्हें एक समारोह के पीछे आलसी बनाना होगा। वैसे भी मुझे लगा कि मैं पाइथन देशी प्रतीक्षा के लिए task या asyncio बिल्डर का भी उपयोग कर सकता हूं। AsyncBuilder.ts सरलीकरण ने मुझे इसे F# पर पोर्ट करने का प्रयास करने के लिए आकर्षित किया।

मैंगलिंग से बचने के लिए एक इंटरफ़ेस का उपयोग करना चाहिए जैसा कि

• NoOverloadSuffix विशेषता: यह Fable को अधिभार प्रत्यय जोड़ने से रोकता है। जाहिर है इस मामले में ओवरलोड काम नहीं करेगा।

https://github.com/fable-compiler/Fable/blob/caa715f1156be29c8dd9b866a03031a1852b3186/src/fable-library/Map.fs#L524 -L527

फिर हम Naming.buildNameWithoutSanitation का उपयोग करके विधियों का संदर्भ दे सकते हैं:

https://github.com/fable-compiler/Fable/blob/caa715f1156be29c8dd9b866a03031a1852b3186/src/Fable.Transforms/Replacements.fs#L1956 -L1963

• लेकिन उसके बाद @ncave ने जैसा कि src/fable-library/System.Text.fs :

https://github.com/fable-compiler/Fable/blob/caa715f1156be29c8dd9b866a03031a1852b3186/src/Fable.Transforms/Replacements.fs#L1314 -L1326

उस स्थिति में आपको कक्षा को केवल replacedModules शब्दकोश में जोड़ना होगा:

https://github.com/fable-compiler/Fable/blob/caa715f1156be29c8dd9b866a03031a1852b3186/src/Fable.Transforms/Replacements.fs#L3075

इसलिए दुर्भाग्य से Replacements से F# में लिखे गए कल्पित-पुस्तकालय कोड से लिंक करने के लिए अभी तक कोई सुसंगत दृष्टिकोण नहीं है। हो सकता है कि हम इस अवसर का उपयोग अभी किसी एक पर सहमत होने के लिए करें।

बहुत ही रोचक जानकारी @ncave और @alfonsogarciacaro के लिए धन्यवाद। इंटरफेस के साथ मैं एक और मुद्दे पर ठोकर खाई। पायथन में unit से कैसे निपटें? मेरा इंटरफ़ेस इस तरह दिखता है:

type IAsyncBuilder =
    abstract member Bind<'T, 'U> : IAsync<'T> * ('T -> IAsync<'U>) -> IAsync<'U>
    abstract member Combine<'T> : IAsync<unit> * IAsync<'T> -> IAsync<'T>
    abstract member Delay<'T> : (unit -> IAsync<'T>) -> IAsync<'T>
    abstract member Return<'T> : value: 'T -> IAsync<'T>
   ...

समस्या यह है कि Return उत्पन्न करता है:

class AsyncBuilder:
    def Return(self, value):
        return protectedReturn(value)
    ....

यह अच्छा लग रहा है और शायद जेएस के लिए अच्छा है, लेकिन यदि फ़ंक्शन तर्क लेता है तो पायथन में आपको एक तर्क देना होगा। इस प्रकार यदि आप x.Return() कॉल करते हैं तो आपको एक त्रुटि मिलेगी जब 'T unit । मेरी पहली प्रतिक्रिया एक अधिभार बनाना था:

abstract member Return : unit -> IAsync<unit>

लेकिन इसकी अपनी समस्याएं हैं। मेरा वर्तमान समाधान (जो बदसूरत दिखता है):

abstract member Return<'T> : [<ParamArray>] value: 'T [] -> IAsync<'T>

...

member this.Return<'T>([<ParamArray>] values: 'T []) : IAsync<'T> =
    if Array.isEmpty values then
        protectedReturn (unbox null)
    else
        protectedReturn values.[0]

लेकिन इसके लिए मुझे प्रत्येक सामान्य एकल तर्क समारोह के लिए कस्टम हैंडलिंग की आवश्यकता है। शायद मुझे इसके बजाय प्रत्येक एकल-तर्क फ़ंक्शन को इनपुट के रूप में शून्य (पायथन में कोई नहीं) स्वीकार करना चाहिए। जैसे:

class AsyncBuilder:
    def Return(self, value=None):
        return protectedReturn(value)
    ....

इस समस्या से निपटने का सही तरीका क्या होगा?

आईआईआरसी, unit -> X हस्ताक्षर वाले तरीकों के लिए कॉल में कोई तर्क नहीं है (जैसा कि एफ # एएसटी में है) लेकिन लैम्ब्डा के लिए या इस मामले में unit कॉल/एप्लिकेशन से भरे सामान्य तर्कों में unit Fable AST में transformCallArgs सहायक में यह तर्क हटा दिया जाता है। हो सकता है कि हम वहां एक शर्त जोड़ सकें और लक्ष्य भाषा अजगर होने पर इकाई तर्क छोड़ दें:

https://github.com/fable-compiler/Fable/blob/caa715f1156be29c8dd9b866a03031a1852b3186/src/Fable.Transforms/Fable2Babel.fs#L1083 -L1086

हाय @ncave , @alfonsogarciacaro , मैं [<Inject>] पैरामीटर के संचालन पर कुछ इनपुट का उपयोग कर सकता हूं। यह Php @thinkbeforecoding में कैसे किया जाता है? जैसे कार्य (में Array.fs ):

let map (f: 'T -> 'U) (source: 'T[]) ([<Inject>] cons: Cons<'U>): 'U[] =
    let len = source.Length
    let target = allocateArrayFromCons cons len
    for i = 0 to (len - 1) do
        target.[i] <- f source.[i]
    target

मेरा कोड cons पैरामीटर उत्पन्न नहीं कर रहा है और यह पायथन के लिए आवश्यक है।

map(fn ar)

क्या यह जेएस के लिए वैकल्पिक है? मैं कोड में विशेषता का पता कैसे लगा सकता हूं और इसे वैकल्पिक बना सकता हूं? उदाहरण के लिए

def map(f, source, cons=None):
    ...

वैकल्पिक पैरामीटर पर PHP भी स्पष्ट है। मुझे तर्क मॉडल पर एक वैकल्पिक ध्वज जोड़ना पड़ा।

Fable में Inject विशेषता के दो उपयोग हैं। एक मुख्य रूप से प्रायोगिक है (किसी तरह टाइपक्लास का अनुकरण करने के लिए और सामान्य प्रकार की जानकारी को हल करने के लिए किसी फ़ंक्शन को इनलाइन करने से बचने के लिए) और आपको इसके बारे में बहुत अधिक परवाह नहीं करनी चाहिए।

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

• एक सरणी बनाने वाले कार्यों को यह जानने की जरूरत है कि यह एक जेएस गतिशील या टाइप की गई सरणी है या नहीं।
• कंस्ट्रक्टर और अन्य हेल्पर्स को सेट और मैप करें जिन्हें यह जानने के लिए एक तुलनाकर्ता प्राप्त करने की आवश्यकता है कि एक प्रकार की तुलना कैसे की जानी चाहिए (कुछ औसत गणना करने वाले कार्यों के समान)।

हालांकि, इन कार्यों को सीधे नहीं कहा जाता है, इसलिए Fable Inject विशेषता को "देख नहीं सकता"। इस कारण से, हम ReplacementsInject.fs फ़ाइल का उपयोग करते हैं जो कहती है कि लाइब्रेरी में किन कार्यों को इंजेक्शन की आवश्यकता होती है। देखें कि इसका उपयोग कैसे किया जाता है: https://github.com/fable-compiler/Fable/blob/522f6aad211102271538798aeb90f4aed1f77dd6/src/Fable.Transforms/Replacements.fs#L988-L1019

यह फ़ाइल इस स्क्रिप्ट के साथ शुरुआत में स्वचालित रूप से बनाई गई थी जो यह पता लगाती है कि Fable.Library में कौन से कार्य करता है, जिसमें अंतिम तर्क Inject सजाया गया है। लेकिन मुझे लगता है कि एक बिंदु पर हमने अपडेट करना बंद कर दिया और IIRC ने रिप्लेसमेंटइंजेक्ट्स के अंतिम अपडेट को अपडेट कर दिया। फ़ाइल मैन्युअल रूप से की गई है।

यह जानकर, मैं शायद IsOptional जानकारी से छुटकारा पा सकता हूँ... मैं जाँच करूँगा

@alfonsogarciacaro कोड के लिए injectArg के साथ कोई समस्या प्रतीत होती है जैसे कि:

type Id = Id of string

let inline replaceById< ^t when ^t : (member Id : Id)> (newItem : ^t) (ar: ^t[]) =
    Array.map (fun (x: ^t) -> if (^t : (member Id : Id) newItem) = (^t : (member Id : Id) x) then newItem else x) ar

let ar = [| {|Id=Id"foo"; Name="Sarah"|}; {|Id=Id"bar"; Name="James"|} |]
replaceById {|Id=Id"ja"; Name="Voll"|} ar |> Seq.head |> fun x -> equal "Sarah" x.Name
replaceById {|Id=Id"foo"; Name="Anna"|} ar |> Seq.head |> fun x -> equal "Anna" x.Name

यहां Array.map को कंस्ट्रक्टर इंजेक्शन नहीं मिलेगा। कोड बिना किसी इंजेक्शन के JS को ट्रांसपाइल करेगा:

return map((x) => (equals(newItem.Id, x.Id) ? newItem : x), ar);

क्या यह एक बग है? यह कोड जेएस में काम करेगा (भाग्य से?) लेकिन पायथन के लिए नहीं।

आह क्षमा करें! इस बारे में पूरी तरह से भूल गए लेकिन हमारे पास एक "अनुकूलन" है जहां सरणी निर्माता को "मानक" जेएस सरणी के लिए इंजेक्शन नहीं दिया गया है: https://github.com/fable-compiler/Fable/blob/4ecab5549ab6fcaf317ab9484143420671ded43b/src/Fable.Transforms/ रिप्लेसमेंट.fs#L1005 -L1009

हम तब वैश्विक Array लिए डिफ़ॉल्ट होते हैं जब कुछ भी पारित नहीं होता है: https://github.com/fable-compiler/Fable/blob/4ecab5549ab6fcaf317ab9484143420671ded43b/src/fable-library/Array.fs#L25 -L28

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

ठीक है धन्यवाद। मैं यह देखने की कोशिश करूंगा कि क्या मैं यह काम कर सकता हूं। मुझे नहीं लगता कि हमें इसे बंद करने की आवश्यकता है, हमें तीसरे तर्क के लिए केवल एक खाली (शून्य) मान उत्पन्न करने की आवश्यकता है ताकि पायथन चकित न हो। अर्थात:

            | Types.arrayCons ->
                match genArg with
                | Number(numberKind,_) when com.Options.TypedArrays ->
                    args @ [getTypedArrayName com numberKind |> makeIdentExpr]
                | _ -> args @ [ Expr.Value(ValueKind.Null genArg, None) ]

जेएस के लिए यह तब उत्पन्न होगा:

map((x_3) => (equals(newItem_1.Id, x_3.Id) ? newItem_1 : x_3), ar, null))).Name);

और पायथन के लिए:

def lifted_53(x_2):
    return newItem_1 if (equals(newItem_1["Id"], x_2["Id"])) else (x_2)

return map(lifted_53, ar, None)

क्या ऐसा कुछ स्वीकार्य फिक्स होगा?

यह काम करना चाहिए। शायद हम इसके बजाय None उपयोग कर सकते हैं। एक बिंदु पर हम Fable2Babel में अंतिम स्थिति में None args हटा रहे थे, ऐसा लगता है कि हम अब FSharp2Fable में ऐसा कर रहे हैं, लेकिन हम यहां एक अतिरिक्त जांच जोड़ सकते हैं: https://github.com/fable-compiler/ Fable/blob/c54668b42b46c0538374b6bb2e283af41a6e5762/src/Fable.Transforms/Fable2Babel.fs#L1082 -L1095

BTW, क्षमा करें, मैंने इस PR की गहराई से जाँच नहीं की है लेकिन अगर यह परीक्षण नहीं तोड़ रहा है, तो हम इसे जल्द ही POC के रूप में विलय कर सकते हैं जैसा कि हमने PHP के साथ किया था। ऐसा इसलिए है क्योंकि मैं फ़ेबल के साथ कई भाषाओं को लक्षित करना आसान बनाने के लिए कुछ रिफैक्टरिंग करने की योजना (समय की अनुमति) दे रहा हूं, और यदि पाइथन पहले से ही next शाखा में है तो यह शायद आसान होगा। हम बहुत सी अलग-अलग शाखाओं को सिंक (मुख्य, अगला, पायथन) में रखने से भी बचते हैं।

ठीक है @alfonsogarciacaro , मैं देखूंगा कि क्या मैं शून्य के बजाय कोई नहीं उत्पन्न कर सकता हूं। हम इसे जल्द ही मर्ज कर सकते हैं। यह अभी भी कुछ मौजूदा पायथन परीक्षणों को तोड़ रहा है, लेकिन अभी कुछ ही बचे हैं और मुझे इसे एक या एक सप्ताह के भीतर ठीक करना चाहिए। आवश्यक उत्सर्जन के साथ Fable.Core.PY.fs बनाने की भी आवश्यकता है। Babel2Python -> Fable2Python से पुनर्लेखन मेरी अपेक्षा से अधिक कठिन था लेकिन मैं अंत में फिर से पटरी पर आने के करीब पहुंच रहा हूं। मैं पीआर को थोड़ा साफ कर दूंगा और इसे मर्ज करने के लिए तैयार कर दूंगा।

@alfonsogarciacaro मैंने एक को छोड़कर सभी परीक्षणों को ठीक कर दिया है। हालाँकि यह उसी पुराने मुद्दे से संबंधित है जो मेरे पास बैबेल के साथ था 😱 मुझे यह जानने का एक तरीका चाहिए कि क्या Fable.Get का उपयोग AnonymousRecord प्रकार पर किया जाता है क्योंकि वे पायथन डिक्टेट में बदल जाते हैं, और मुझे सबस्क्रिप्ट का उपयोग करने की आवश्यकता है यानी [] पहुंच और .dotted । समस्या यह है कि बाईं ओर कुछ भी हो सकता है, ऑब्जेक्ट, फ़ंक्शन कॉल, ... इसलिए यह जानना मुश्किल है। क्या कोई बेहतर तरीका है। क्या हमारे पास अनाम रिकॉर्ड के लिए एक और GetKind होना चाहिए, या ऐसा करने का सबसे अच्छा तरीका क्या है?

मैं इसे FSharp2Fable में देखता हूं। मुझे बाद में कैसे पता चलेगा कि फील्डगेट AnonRecord द्वारा उत्पन्न किया गया था?

    // Getters and Setters
    | FSharpExprPatterns.AnonRecordGet(callee, calleeType, fieldIndex) ->
        let r = makeRangeFrom fsExpr
        let! callee = transformExpr com ctx callee
        let fieldName = calleeType.AnonRecordTypeDetails.SortedFieldNames.[fieldIndex]
        let typ = makeType ctx.GenericArgs fsExpr.Type
        return Fable.Get(callee, Fable.FieldGet(fieldName, false), typ, r)

जैसा कि हमने डिस्कॉर्ड @dbrattli में बात की थी, मुझे लगता है कि आप कैली के प्रकार की जांच कर सकते हैं कि यह एक अनाम रिकॉर्ड है या नहीं। लेकिन अगर आपको अधिक व्यवस्थित दृष्टिकोण की आवश्यकता है तो FieldGet में अधिक जानकारी जोड़ना ठीक होना चाहिए, हालांकि इस बिंदु पर हमें शायद ब्रेकिंग परिवर्तनों को कम करने और अन्य बूलियन फ़ील्ड के साथ भ्रम से बचने के लिए एक अलग रिकॉर्ड घोषित करना चाहिए (एफ # होना चाहिए अधिक सख्त यूनियन केस फील्ड नाम बीटीडब्ल्यू):

type FieldGetInfo =
    { Name: string
      IsMutable: bool
      IsAnonymousRecord: bool }

type GetKind =
    | FieldGet of info: FieldGetInfo
    | ...

धन्यवाद @alfonsogarciacaro। वह काम किया! मैं

अगला मसला:

testCase "Map.IsEmpty works" <| fun () ->
    let xs = Map.empty<int, int>
    xs.IsEmpty |> equal true
    let ys = Map [1,1; 2,2]
    ys.IsEmpty |> equal false

जेएस के लिए यह संकलित करता है:

Testing_testCase("Map.isEmpty works", () => {
    Testing_equal(true, isEmpty_1(ofSeq([], {
        Compare: (x_1, y_1) => compare(x_1, y_1),
    })));
    Testing_equal(false, isEmpty_1(ofSeq([[1, 1]], {
        Compare: (x_2, y_2) => comparePrimitives(x_2, y_2),
    })));
})

ध्यान दें कि ofSeq को दो तर्कों के साथ बुलाया जाता है। हालांकि, ofSeq केवल एक तर्क लेता है:

let ofSeq elements =
    Map<_, _>.Create elements

export function ofSeq(elements) {
    return FSharpMap_Create(elements);
}

Compare साथ उस ऑब्जेक्ट एक्सप्रेशन को क्यों जोड़ा जाता है जब ofSeq कहा जाता है?

हम्म, मुझे इस पर गौर करने की ज़रूरत है। एक बग की तरह दिखता है, ofSeq को एक तुलनित्र स्वीकार करना चाहिए ( MapTree.ofSeq और Set.ofSeq जैसे समान कार्य)। सेटअप थोड़ा जटिल है इसलिए हो सकता है कि किसी बिंदु पर चीजें सिंक से बाहर हो गईं: हमारे पास रिप्लेसमेंटइंजेक्ट.fs नाम की एक फाइल है जिसका उपयोग रिप्लेसमेंट द्वारा यह इंगित करने के लिए किया जाता है कि किन तरीकों को तर्क इंजेक्शन की आवश्यकता है। इस फ़ाइल को स्वचालित रूप से उत्पन्न करने के लिए कहीं न कहीं एक स्क्रिप्ट है, लेकिन कुछ समय हो गया है कि हमने इसका उपयोग नहीं किया है और मुझे यकीन नहीं है कि यह नवीनतम FCS संस्करण के साथ काम करता है। मैं जांच करूंगा, इसे इंगित करने के लिए धन्यवाद!

मैंने एक अस्थायी फिक्स जोड़ा। समीक्षा के लिए तैयार 🎉 https://github.com/fable-compiler/Fable/pull/2345