F #: संकलन के बाद आपका कोड क्या बदल जाता है

एफ # भाषा मानक VisualStudio पैकेज में हाल ही में दिखाई दिया, अर्थात् 2010 संस्करण (वर्तमान में सबसे अधिक प्रासंगिक)। स्वाभाविक रूप से, हर कोई यह अच्छी तरह से जानता है, भाषा CLR के आधार पर कार्य करती है - आपके सभी कोड को किसी अन्य .NET भाषा की तरह MS IL में संकलित किया जाएगा।

आइए देखें कि कंपाइलर आपके कोड को किस तरह से बदल देता है, उदाहरण के लिए अक्सर उपयोग की जाने वाली और उपयोगी याद रखने की तकनीक के रूप में। स्पष्टता के लिए, मैं F # में कोड लिखूंगा और इसे C # में अपघटित करूंगा।

तो, मूल उदाहरण:

let memoize f = let cache = System.Collections.Generic.Dictionary() fun x -> if cache.ContainsKey(x) then cache.[x] else let res = fx cache.[x] <- res res let rec memoizedFactorial = let factorial x = match x with | a when a = 0I -> 1I | x -> x * memoizedFactorial (x - 1I) memoize factorial let now = System.DateTime.Now let arguments = [10000I .. 10100I] let factorials = arguments |> List.map memoizedFactorial let timeDiff = System.DateTime.Now - now printfn "Time: %A" timeDiff 

कुछ स्पष्टीकरण:

• हम 10,000 से 10,100 तक 101 फैक्टरियल पर विचार करेंगे।
• हम अपनी गणना के निष्पादन का समय नोट करते हैं।
• चूँकि F # में कोई अंतर्निहित संस्मरण नहीं है, इसलिए हम एक घर का उपयोग करते हैं। यह किसी भी फ़ंक्शन को एक तर्क के रूप में लेता है, कैश को इनिशियलाइज़ करता है और एक लैम्ब्डा एक्सप्रेशन बनाता है जिसका उपयोग कैश में तत्व के अस्तित्व की जांच करने के लिए किया जाता है, वास्तविक फ़ंक्शन को कॉल करें यदि तत्व अनुपस्थित है, और तत्व को कैश में जोड़ें।
• स्पष्टता के लिए, मैंने एक अलग memoizedFactorial समारोह memoizedFactorial । प्रभाव इस तथ्य पर आधारित है कि हम तर्कों के बिना memoizedFactorial फ़ंक्शन को परिभाषित करते हैं, और परिणामस्वरूप हम एक और फ़ंक्शन लौटाते हैं, जिसके बाद हम तर्कों को पास करेंगे। इस प्रकार, यह पता चलता है कि एक वस्तु के रूप में memoizedFactorial एक ही उदाहरण में मौजूद है, और हमारा कैश एक ही कॉल के साथ समान होगा।

आइए अब देखें कि स्मारक किसके नेतृत्व में चला।
संस्मरण के बिना कार्यक्रम का निष्पादन समय 28.97 सेकेंड है, और संस्मरण 0.89 s के साथ। जैसा कि कहा जाता है, प्रभाव स्पष्ट है।

हम देखते हैं कि यह सब क्या संकलित करता है। C # प्रोग्रामर के लिए सबसे दिलचस्प बिंदु निश्चित रूप से memoizedFactorial फ़ंक्शन को कॉल करने का memoizedFactorial है। स्थानीय फ़ंक्शन कैश को फिर से क्यों नहीं बनाया जाता है?
चलो देखते हैं।

main समारोह:

 public static void main@() { memoizedFactorial@11-1 = LazyExtensions.Create<FSharpFunc<BigInteger, BigInteger>>(new Program.clo@11-1()); memoizedFactorial@11 = Program.memoizedFactorial@11.get_Value(); now@18 = DateTime.Now; arguments@20 = SeqModule.ToList<BigInteger>(new Program.arguments@20(0, new BigInteger())); factorials@21 = ListModule.Map<BigInteger, BigInteger>(Program.memoizedFactorial, Program.arguments); timeDiff@23 = (TimeSpan) (DateTime.Now - Program.now); fp@1 = new PrintfFormat<FSharpFunc<TimeSpan, Unit>, TextWriter, Unit, Unit, TimeSpan>("Time: %A"); PrintfModule.PrintFormatLineToTextWriter<FSharpFunc<TimeSpan, Unit>>(Console.Out, Program.fp@1).Invoke(Program.timeDiff); } 

हम्म ... memoizedFactorial फ़ंक्शन एक अलग ऑब्जेक्ट बन गया है। इसके अलावा, वहाँ कोई चर नहीं हैं - वे सभी वर्ग internal static class $Program क्षेत्र बन गए। सामान्य तौर पर, विशिष्ट कक्षाओं तक, कोड स्पष्ट होना चाहिए। memoizedFactorial में memoizedFactorial से memoizedFactorial ।

आरंभ करने के लिए, हमारे पास $Program वर्ग के दो क्षेत्र हैं:

 internal static FSharpFunc<BigInteger, BigInteger> memoizedFactorial@11; internal static Lazy<FSharpFunc<BigInteger, BigInteger>> memoizedFactorial@11-1; 

यह देखा जा सकता है कि दूसरा मानक वर्ग के ऑब्जेक्ट द्वारा आरम्भ किया जाता है जिसमें क्लोजर पास होता है। पहला क्षेत्र कुछ भी दिलचस्प नहीं करता है, यह सिर्फ खुद को वापस लाता है ( get_Value विधि)।

तो, बंद लग रहा है:

 internal class clo@11-1 : FSharpFunc<Unit, FSharpFunc<BigInteger, BigInteger>> { // Methods internal clo@11-1(); public override FSharpFunc<BigInteger, BigInteger> Invoke(Unit arg00@); } 

हम समझते हैं कि यह एक ऐसा वर्ग है जिसमें एक दिलचस्प विधि है:

 public override FSharpFunc<BigInteger, BigInteger> Invoke(Unit arg00@) { return Program.memoizedFactorial@11-1(); } 

हम्म। ऐसा लग रहा है कि वे वहां आए जहां वे पहले से ही थे। लेकिन ऐसा है नहीं। यह memoizedFactorial@11-1 फ़ंक्शन को कॉल करने का परिणाम देता है। अंत में, हम इस फ़ंक्शन को देखते हैं:

 internal static FSharpFunc<BigInteger, BigInteger> memoizedFactorial@11-1() { return memoize<BigInteger, BigInteger>(new clo@13()); } 

यहाँ! अंत में हमें memoize फंक्शन मिला। और एक और बंद करने के लिए। एक क्लोजर उसी वर्ग का उत्तराधिकारी है, हम तुरंत इनवोक विधि को देखते हैं:

 public override BigInteger Invoke(BigInteger x) { if (LanguagePrimitives.HashCompare.GenericEqualityIntrinsic<BigInteger>(x, BigInteger.Zero)) { return BigInteger.One; } return (x * Program.memoizedFactorial@11.get_Value().Invoke(x - BigInteger.One)); } 

यहाँ यह हमारी सच्चाई है! हमने एक फ़ंक्शन पाया जो सीधे मूल्य की गणना करता है। ध्यान दें कि एक स्मारक संस्करण का उपयोग पुनरावृत्ति के लिए किया जाता है, जैसा कि हमने एफ # कोड में लिखा था। टेम्पलेट के साथ तुलना को नियमित रूप से परिवर्तित किया गया था if । इसके अलावा, जिस तरह से, हम देखते हैं कि दो BigInteger तुलना उनके हैश के माध्यम से की जाती है।

चलो एक कदम पीछे चलते हैं और memoize समारोह को memoize हैं:

 public static FSharpFunc<a, b> memoize<a, b>(FSharpFunc<a, b> f) { return new memoize@3<a, b>(f, new Dictionary<a, b>()); } 

इधर, मस्ती शुरू हुई। कार्य के परिणामस्वरूप, ऑब्जेक्ट को उन निर्माता मापदंडों पर वापस लौटा दिया जाता है जिनमें से हमारा क्लोजर (पहला तर्क) और शब्दकोश (दूसरा तर्क) पास हो जाता है। अब यह स्पष्ट है कि हर बार शब्दकोश को फिर से क्यों नहीं बनाया गया है।

हम गहराई तक जाते हैं:

 internal class memoize@3<a, b> : FSharpFunc<a, b> { // Fields public Dictionary<a, b> cache; public FSharpFunc<a, b> f; // Methods internal memoize@3(FSharpFunc<a, b> f, Dictionary<a, b> cache); public override b Invoke(ax); } 

वर्ग फ़ील्ड एक बार फिर दिखाते हैं कि कैश पूरे कार्यक्रम के लिए एक क्यों है। हम Invoke फ़ंक्शन को देखते हैं:

 public override b Invoke(ax) { if (this.cache.ContainsKey(x)) { return this.cache[x]; } b res = this.f.Invoke(x); this.cache[x] = res; return res; } 

और यहाँ हमारे स्मारक समारोह है! कुंजी को तर्क के माध्यम से पारित किया जाता है। क्लोजर f हम पहले से ही वस्तु के क्षेत्रों के माध्यम से जानते हैं। रहस्य अनसुलझा है।

इसलिए F # में कोई जादू नहीं है। खैर, बिल्कुल। इन सभी करी (और memoizedFactorial फ़ंक्शन memoizedFactorial क्या है), प्रथम श्रेणी के नागरिकों जैसे कार्य वास्तव में स्वचालित रूप से उत्पन्न कक्षाएं और ऑब्जेक्ट हैं। मुझे उम्मीद है कि मेरा लेख किसी को बेहतर ढंग से समझने में मदद करेगा कि एफ # अंदर कैसे काम करता है।