👨‍🏫 👩‍🌾 🕸️ F # 4.6 पूर्वावलोकन की घोषणा 📲 🧖 🍿

हम यह घोषणा करते हुए उत्साहित हैं कि विजुअल स्टूडियो 2019 रिलीज होने पर F # का नया संस्करण शिप करेगा: F # 4.6!

F # 4.6 F # भाषा का एक छोटा अपडेट है, जो इसे "सही" बिंदु-विमोचन बनाता है। एफ # के पिछले संस्करणों के साथ, एफ # 4.6 पूरी तरह से एक खुले आरएफसी (टिप्पणियों के लिए अनुरोध) प्रक्रिया के माध्यम से विकसित किया गया था। एफ # समुदाय ने भाषा के इस संस्करण के लिए चर्चा में बहुत विस्तृत प्रतिक्रिया की पेशकश की है। आप इस रिलीज के साथ मेल खाने वाले सभी RFC देख सकते हैं:

यह पोस्ट फीचर सेट और इसे आरंभ करने का तरीका बताएगी।

ब्लॉग में मूल

आरंभ करें

सबसे पहले, या तो स्थापित करें:

इसके बाद, अपने FSharp.Core निर्भरता को FSharp.Core 4.6 (या उच्चतर) पर अपडेट करें। यदि आप Visual Studio का उपयोग कर रहे हैं, तो आप NuGet Package Management UI के साथ कर सकते हैं। यदि आप Visual Studio का उपयोग नहीं कर रहे हैं, या हाथ से संपादन प्रोजेक्ट फ़ाइलों को पसंद करते हैं, तो इसे प्रोजेक्ट फ़ाइल में जोड़ें:

<ItemGroup> <PackageReference Update="FSharp.Core" Version="4.6.0" /> </ItemGroup>

एक बार जब आप आवश्यक बिट्स स्थापित कर लेते हैं, तो आप F # 4.6 का उपयोग Visual Studio , Mac के लिए Visual Studio , या Ionide के साथ Visual Studio कोड का उपयोग कर सकते हैं।

अनाम रिकॉर्ड

विभिन्न बग फिक्स के अलावा, एफ # 4.6 में एकमात्र भाषा परिवर्तन बेनामी रिकॉर्ड प्रकारों की शुरूआत है।

मूल उपयोग

एफ # -ऑनली नजरिए से, बेनामी रिकॉर्ड एफ # रिकॉर्ड प्रकार हैं जिनके पास नामों की खोज नहीं है और उन्हें तदर्थ में घोषित किया जा सकता है। यद्यपि वे मौलिक रूप से बदलने की संभावना नहीं रखते हैं कि आप एफ # कोड कैसे लिखते हैं, वे कई छोटे अंतरालों को भरते हैं एफ # प्रोग्रामर ने समय के साथ सामना किया है, और उन रसीद डेटा हेरफेर के लिए इस्तेमाल किया जा सकता है जो पहले संभव नहीं था।

वे उपयोग करने के लिए काफी आसान हैं। उदाहरण के लिए, यहां आप एक ऐसे फ़ंक्शन के साथ बातचीत कैसे कर सकते हैं जो एक अनाम रिकॉर्ड का उत्पादन करता है:

 open System let circleStats radius = let d = radius * 2.0 let a = Math.PI * (radius ** 2.0) let c = 2.0 * Math.PI * radius {| Diameter=d; Area=a; Circumference=c |} let r = 2.0 let stats = circleStats r printfn "Circle with radius: %f has diameter %f, area %f, and circumference %f" r stats.Diameter stats.Area stats.Circumference

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

 let circleStats radius = let d = radius * 2.0 let a = Math.PI * (radius ** 2.0) let c = 2.0 * Math.PI * radius {| Diameter=d; Area=a; Circumference=c |} let printCircleStats r (stats: {| Area: float; Circumference: float; Diameter: float |}) = printfn "Circle with radius: %f has diameter %f, area %f, and circumference %f" r stats.Diameter stats.Area stats.Circumference let r = 2.0 let stats = circleStats r printCircleStats r stats

यदि आप एक गुमनाम रिकॉर्ड के साथ `PrintCircleStats` को कॉल करने का प्रयास करते हैं, जिसमें समान अंतर्निहित डेटा प्रकार लेकिन विभिन्न लेबल थे, तो यह संकलन करने में विफल होगा:

 printCircleStats r {| Diameter=2.0; Area=4.0; MyCircumference=12.566371 |} // Two anonymous record types have mismatched sets of field names '["Area"; "Circumference"; "Diameter"]' and '["Area"; "Diameter"; "MyCircumference"]'

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

संरचना अनाम रिकॉर्ड

अज्ञात कीवर्ड का उपयोग करके अज्ञात रिकॉर्ड भी हो सकते हैं:

 open System let circleStats radius = let d = radius * 2.0 let a = Math.PI * (radius ** 2.0) let c = 2.0 * Math.PI * radius // Note that the keyword comes before the '{| |}' brace pair struct {| Area=a; Circumference=c; Diameter=d |} // the 'struct' keyword also comes before the '{| |}' brace pair when declaring the parameter type let printCircleStats r (stats: struct {| Area: float; Circumference: float; Diameter: float |}) = printfn "Circle with radius: %f has diameter %f, area %f, and circumference %f" r stats.Diameter stats.Area stats.Circumference let r = 2.0 let stats = circleStats r printfn "Circle with radius: %f has diameter %f, area %f, and circumference %f" r stats.Diameter stats.Area stats.Circumference

आप एक फ़ंक्शन को कॉल कर सकते हैं जो एक संरचनात्मक अनाम रिकॉर्ड लेता है इसे स्पष्ट रूप से इस तरह किया जा सकता है:

 let printCircleStats r (stats: struct {| Area: float; Circumference: float; Diameter: float |}) = printfn "Circle with radius: %f has diameter %f, area %f, and circumference %f" r stats.Diameter stats.Area stats.Circumference printCircleStats r struct {| Area=4.0; Circumference=12.6; Diameter=12.6 |}

या आप कॉल साइट पर `संरचना` को खत्म करने के लिए" संरचना का अनुमान "का उपयोग कर सकते हैं:

 let printCircleStats r (stats: struct {| Area: float; Circumference: float; Diameter: float |}) = printfn "Circle with radius: %f has diameter %f, area %f, and circumference %f" r stats.Diameter stats.Area stats.Circumference printCircleStats r {| Area=4.0; Circumference=12.6; Diameter=12.6 |}

यह आपके द्वारा बनाए गए अनाम रिकॉर्ड के उदाहरण को समझेगा जैसे कि यह एक संरचना थी।

ध्यान दें कि रिवर्स सच नहीं है:

 let printCircleStats r (stats: {| Area: float; Circumference: float; Diameter: float |}) = printfn "Circle with radius: %f has diameter %f, area %f, and circumference %f" r stats.Diameter stats.Area stats.Circumference // This will fail to compile for hopefully obvious reasons! printCircleStats r struct {| Area=4.0; Circumference=12.6; Diameter=12.6 |}

वर्तमान में IsByRefLike या IsReadOnly संरचित अनाम रिकॉर्ड प्रकारों को परिभाषित करना संभव नहीं है। एक भाषा सुझाव है जो इस वृद्धि का प्रस्ताव करता है, लेकिन वाक्यविन्यास में विषमताओं के कारण यह अभी भी चर्चा में है।

चीजों को और आगे ले जाना

बेनामी रिकॉर्ड का उपयोग अधिक उन्नत संदर्भों के व्यापक सेट में किया जा सकता है।

अनाम रिकॉर्ड क्रमबद्ध हैं

आप गुमनाम रिकॉर्ड को क्रमबद्ध और निष्क्रिय कर सकते हैं:

 open Newtonsoft.Json let phillip = {| name="Phillip"; age=28 |} let str = JsonConvert.SerializeObject(phillip) printfn "%s" str let phillip' = JsonConvert.DeserializeObject<{|name: string; age: int|}>(str) printfn "Name: %s Age: %d" phillip'.name phillip'.age

यह आपको उम्मीद कर सकता है:

 {"age":28,"name":"Phillip"} Name: Phillip Age: 28

यहां एक नमूना पुस्तकालय है जिसे किसी अन्य परियोजना में भी कहा जाता है:

 namespace AnonyRecdOne open Newtonsoft.Json module AR = let serialize () = let phillip = {| name="Phillip"; age=28 |} JsonConvert.SerializeObject(phillip)

 open AnonyRecdOne open Newtonsoft.Json [<EntryPoint>] let main _ = let str = AR.serialize () let phillip = JsonConvert.DeserializeObject<{|name: string; age: int|}>(str) printfn "Name: %s Age: %d" phillip.name phillip.age

यह परिदृश्यों के लिए चीजों को आसान बना सकता है जैसे कि माइक्रो सर्वर से बने सिस्टम में एक नेटवर्क पर हल्का डेटा जा रहा है।

बेनामी रिकॉर्ड को अन्य प्रकार की परिभाषाओं के साथ जोड़ा जा सकता है

आपके डोमेन में एक पेड़ जैसा डेटा मॉडल हो सकता है, जैसे कि निम्न उदाहरण:

 type FullName = { FirstName: string; LastName: string } type Employee = | Engineer of FullName | Manager of name: FullName * reports: Employee list | Executive of name: FullName * reports: Employee list * assistant: Employee

ऐसे मामलों को देखना विशिष्ट है, जिनका नाम संघ के क्षेत्रों में ट्यूपल्स के रूप में रखा गया है, लेकिन जैसे-जैसे डेटा अधिक जटिल होता है, आप प्रत्येक मामले को निम्न के साथ निकाल सकते हैं:

 type FullName = { FirstName: string; LastName: string } type Employee = | Engineer of FullName | Manager of Manager | Executive of Executive and Manager = { Name: FullName; Reports: Employee list } and Executive = { Name: FullName; Reports: Employee list; Assistant: Employee }

यदि यह आपके कोडबेस के अनुरूप है तो इस पुनरावर्ती परिभाषा को अब गुमनाम रिकॉर्ड के साथ छोटा किया जा सकता है:

 type FullName = { FirstName: string; LastName: string } type Employee = | Engineer of FullName | Manager of {| Name: FullName; Reports: Employee list |} | Executive of {| Name: FullName; Reports: Employee list; Assistant: Employee |}

पिछले उदाहरणों की तरह, इस तकनीक को विवेकपूर्ण तरीके से और आपके परिदृश्य पर लागू होने पर लागू किया जाना चाहिए।

अनाम रिकॉर्ड F # में LINQ के उपयोग को कम करते हैं

F # प्रोग्रामर आमतौर पर डेटा के साथ काम करते समय लिस्ट, एरे और सीक्वेंस कॉम्बिनेटर का उपयोग करना पसंद करते हैं, लेकिन यह कभी-कभी LINQ का उपयोग करने के लिए सहायक हो सकता है। यह पारंपरिक रूप से थोड़ा दर्दनाक रहा है, क्योंकि LINQ C # अनाम प्रकारों का उपयोग करता है।

अनाम रिकॉर्ड के साथ, आप LINQ विधियों का उपयोग कर सकते हैं जैसे आप C # और अनाम प्रकारों के साथ करेंगे:

 open System.Linq let names = [ "Ana"; "Felipe"; "Emillia"] let nameGrouping = names.Select(fun n -> {| Name=n; FirstLetter=n.[0] |}) for ng in nameGrouping do printfn "%s has first letter %c" ng.Name ng.FirstLetter

यह प्रिंट:

 Ana has first letter A Felipe has first letter F Emillia has first letter E

बेनामी रिकॉर्ड एंटिटी फ्रेमवर्क और अन्य ORM के साथ काम करने में आसानी करते हैं

F # प्रोग्रामर एक डेटाबेस के साथ बातचीत करने के लिए F # क्वेरी एक्सप्रेशन का उपयोग करते हुए अनाम रिकॉर्ड के साथ जीवन सुधार के कुछ मामूली गुणवत्ता को देखना चाहिए।

उदाहरण के लिए, आप एक cl select` क्लॉज के साथ समूह डेटा में टुपल्स का उपयोग करने के लिए उपयोग किया जा सकता है:

 let q = query { for row in db.Status do select (row.StatusID, row.Name) }

लेकिन यह आइटम 1 और आइटम 2 जैसे नामों के साथ कॉलम में परिणाम देता है जो आदर्श नहीं हैं। अनाम रिकॉर्ड से पहले, आपको एक रिकॉर्ड प्रकार घोषित करना होगा और उसका उपयोग करना होगा। अब आपको ऐसा करने की आवश्यकता नहीं है:

 let q = query { for row in db.Status do select {| StatusID = row.StatusID; Name = row.Name |} }

रिकॉर्ड प्रकार सामने निर्दिष्ट करने की आवश्यकता नहीं है! यह क्वेरी अभिव्यक्तियों को वास्तविक एसक्यूएल के साथ और अधिक संरेखित करता है जो वे मॉडल करते हैं।

बेनामी रिकॉर्ड भी आपको क्वेरी के उद्देश्यों के लिए डेटा के एक ऐड-हॉक समूहीकरण बनाने के लिए केवल अधिक उन्नत प्रश्नों में बेनामी ऑबजेक्ट प्रकार बनाने से बचते हैं।

अनाम रिकॉर्ड ASP.NET कोर में कस्टम रूटिंग के उपयोग को आसान बनाते हैं

आप पहले से एफ # के साथ ASP.NET कोर का उपयोग कर रहे हैं, लेकिन हो सकता है कि कस्टम रूट को परिभाषित करते समय एक अजीब स्थिति में चला गया हो। पिछले उदाहरणों के साथ, यह अभी भी एक रिकॉर्ड प्रकार को सामने से परिभाषित करके किया जा सकता है, लेकिन इसे अक्सर एफ # डेवलपर्स द्वारा अनावश्यक के रूप में देखा गया है। अब आप इसे इनलाइन कर सकते हैं:

 app.UseMvc(fun routes -> routes.MapRoute("blog","blog/{*article}", defaults={| controller="Blog"; action="Article" |}) |> ignore ) |> ignore

यह इस तथ्य के कारण अभी भी आदर्श नहीं है कि एफ # रिटर्न प्रकारों के बारे में सख्त है (सी # के विपरीत, जहां आपको उन चीजों को स्पष्ट रूप से अनदेखा करने की आवश्यकता नहीं है जो मूल्य वापस करते हैं)। हालाँकि, यह आपको पहले से परिभाषित रिकॉर्ड परिभाषाओं को हटाने देता है जो आपको ASP.NET मिडलवेयर पाइपलाइन में डेटा भेजने की अनुमति देने के अलावा कोई उद्देश्य नहीं देता है।

अनाम रिकॉर्ड के साथ भावों को कॉपी और अपडेट करें

रिकॉर्ड प्रकारों के साथ, आप अनाम रिकॉर्ड के साथ कॉपी-एंड-अपडेट सिंटैक्स का उपयोग कर सकते हैं:

 let data = {| X = 1; Y = 2 |} let expandedData = {| data with Z = 3 |} // Gives {| X=1; Y=2; Z=3 |} let stringifiedY = {| expandedData with Y="Hello!" |} // Gives {| X=1; Y="Hello!"; Z=3 |}

मूल अभिव्यक्ति एक रिकॉर्ड प्रकार भी हो सकती है:

 type R = { X: int } let data = { X=1 } let data' = {| data with Y = 2 |} // Gives {| X=1; Y=2 |}

आप संदर्भ और संरचित अनाम अभिलेखों से भी डेटा कॉपी कर सकते हैं:

 // Copy data from a reference record into a struct anonymous record type R1 = { X: int } let r1 = { X=1 } let data1 = struct {| r1 with Y=1 |} // Copy data from a struct record into a reference anonymous record [<Struct>] type R2 = { X: int } let r2 = { X=1 } let data2 = {| r1 with Y=1 |}

कॉपी-और-अपडेट अभिव्यक्तियों का उपयोग अनाम रिकॉर्ड्स को F # में डेटा के साथ काम करने पर उच्च लचीलापन देता है।

समानता और पैटर्न मिलान

अनाम रिकॉर्ड संरचनात्मक रूप से समतुल्य और तुलनीय हैं:

 {| a = 1+1 |} = {| a = 2 |} // true {| a = 1+1 |} > {| a = 1 |} // true

हालाँकि, जिस प्रकार की तुलना की जा रही है, उसका आकार समान होना चाहिए:

 // error FS0001: Two anonymous record types have mismatched sets of field names '["a"]' and '["a"; "b"]' {| a = 1+1 |} = {| a = 2; b = 1|}

यद्यपि आप अनाम रिकॉर्ड की बराबरी कर सकते हैं और तुलना कर सकते हैं, आप उन पर मेल नहीं खा सकते हैं। यह दो कारणों से है:

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

इसके बजाय, "dot" -syntax का उपयोग अनाम रिकॉर्ड से मान निकालने के लिए किया जाता है। यह हमेशा वर्बोज़ के रूप में अधिक से अधिक होगा, जैसे कि पैटर्न मिलान का उपयोग किया गया था, और व्यवहार में हमेशा कम मूल्य की होने की संभावना है क्योंकि हमेशा एक अनाम रिकॉर्ड से हर मूल्य नहीं निकाला जाता है। यहां पिछले उदाहरण के साथ काम करने का तरीका बताया गया है जहां अनाम रिकॉर्ड एक भेदभाव वाले संघ का हिस्सा हैं:

 type Employee = | Engineer of FullName | Manager of {| Name: FullName; Reports: Employee list |} | Executive of {| Name: FullName; Reports: Employee list; Assistant: Employee |} let getFirstName e = match e with | Engineer fullName -> fullName.FirstName | Manager m -> m.Name.FirstName | Executive ex -> ex.Name.FirstName

वर्तमान में सीमित संदर्भों में अनाम रिकॉर्ड पर पैटर्न मिलान की अनुमति देने के लिए एक खुला सुझाव है जिसे वे वास्तव में सक्षम कर सकते हैं। यदि आपके पास एक प्रस्तावित उपयोग मामला है, तो कृपया उस मुद्दे का उपयोग करने के लिए उस पर चर्चा करें!

FSharp.Core अतिरिक्त

यह एफ # कोर लाइब्रेरी में परिवर्धन के बिना एक और एफ # रिलीज नहीं होगा!

मान का विस्तार

ValueOption प्रकार का परिचय F # 4.5 में अब कुछ और प्रकार से जुड़ी हुई अच्छाइयाँ हैं:

डीबगर्गरडिस्प्ले विशेषता डिबगिंग के साथ मदद करने के लिए
IsNone , IsSome , कोई नहीं , कुछ , op_Implicit , और ToString सदस्य

यह विकल्प प्रकार के साथ इसे "समता" देता है।

इसके अतिरिक्त, अब एक ValueOption मॉड्यूल है जिसमें समान विकल्प हैं, जिसमें `Option` मॉड्यूल है:

 module ValueOption = [<CompiledName("IsSome")>] val inline isSome: voption:'T voption -> bool [<CompiledName("IsNone")>] val inline isNone: voption:'T voption -> bool [<CompiledName("DefaultValue")>] val defaultValue: value:'T -> voption:'T voption -> 'T [<CompiledName("DefaultWith")>] val defaultWith: defThunk:(unit -> 'T) -> voption:'T voption -> 'T [<CompiledName("OrElse")>] val orElse: ifNone:'T voption -> voption:'T voption -> 'T voption [<CompiledName("OrElseWith")>] val orElseWith: ifNoneThunk:(unit -> 'T voption) -> voption:'T voption -> 'T voption [<CompiledName("GetValue")>] val get: voption:'T voption -> 'T [<CompiledName("Count")>] val count: voption:'T voption -> int [<CompiledName("Fold")>] val fold<'T,'State> : folder:('State -> 'T -> 'State) -> state:'State -> voption:'T voption -> 'State [<CompiledName("FoldBack")>] val foldBack<'T,'State> : folder:('T -> 'State -> 'State) -> voption:'T voption -> state:'State -> 'State [<CompiledName("Exists")>] val exists: predicate:('T -> bool) -> voption:'T voption -> bool [<CompiledName("ForAll")>] val forall: predicate:('T -> bool) -> voption:'T voption -> bool [<CompiledName("Contains")>] val inline contains: value:'T -> voption:'T voption -> bool when 'T : equality [<CompiledName("Iterate")>] val iter: action:('T -> unit) -> voption:'T voption -> unit [<CompiledName("Map")>] val map: mapping:('T -> 'U) -> voption:'T voption -> 'U voption [<CompiledName("Map2")>] val map2: mapping:('T1 -> 'T2 -> 'U) -> voption1: 'T1 voption -> voption2: 'T2 voption -> 'U voption [<CompiledName("Map3")>] val map3: mapping:('T1 -> 'T2 -> 'T3 -> 'U) -> 'T1 voption -> 'T2 voption -> 'T3 voption -> 'U voption [<CompiledName("Bind")>] val bind: binder:('T -> 'U voption) -> voption:'T voption -> 'U voption [<CompiledName("Flatten")>] val flatten: voption:'T voption voption -> 'T voption [<CompiledName("Filter")>] val filter: predicate:('T -> bool) -> voption:'T voption -> 'T voption [<CompiledName("ToArray")>] val toArray: voption:'T voption -> 'T[] [<CompiledName("ToList")>] val toList: voption:'T voption -> 'T list [<CompiledName("ToNullable")>] val toNullable: voption:'T voption -> Nullable<'T> [<CompiledName("OfNullable")>] val ofNullable: value:Nullable<'T> -> 'T voption [<CompiledName("OfObj")>] val ofObj: value: 'T -> 'T voption when 'T : null [<CompiledName("ToObj")>] val toObj: value: 'T voption -> 'T when 'T : null

यह किसी भी चिंताओं को कम करना चाहिए कि `ValueOption`` Option` का अजीब भाई है कि कार्यक्षमता का एक ही सेट नहीं मिलता है।

tryExactlyOne सूची, सरणी, और Seq के लिए

इस बढ़िया समारोह का योगदान ग्रेज़गोरज़ डियाज़्डक्यूविक द्वारा किया गया था। यहां बताया गया है कि यह कैसे काम करता है:

 List.tryExactlyOne [] // None List.tryExactlyOne [1] // Some 1 List.tryExactlyOne [1; 2] // None Array.tryExactlyOne null // ArgumentNullException Array.tryExactlyOne [||] // None Array.tryExactlyOne [|1|] // Some 1 Array.tryExactlyOne [|1; 2|] // None Seq.tryExactlyOne null // ArgumentNullException Seq.tryExactlyOne (Seq.ofList []) // None Seq.tryExactlyOne (Seq.ofList [1]) // Some 1 Seq.tryExactlyOne (Seq.ofList [1; 2]) // None

लपेटता हुआ

यद्यपि F # 4.6 में सुविधाओं की कुल सूची बहुत बड़ी नहीं है, फिर भी वे काफी गहरी हैं! हम आपको F # 4.6 का प्रयास करने और हमें प्रतिक्रिया छोड़ने के लिए प्रोत्साहित करते हैं ताकि हम पूर्ण रिलीज से पहले चीजों को ठीक कर सकें। हमेशा की तरह, F # समुदाय को उनके योगदानों के लिए धन्यवाद - कोड और डिज़ाइन चर्चा दोनों में - जो हमें F # भाषा को आगे बढ़ाने में मदद करते हैं।

चीयर्स, और खुश हैकिंग!

F # 4.6 पूर्वावलोकन की घोषणा