F # में गोल्फिंग के लिए आपके पास क्या सामान्य सुझाव हैं? मैं उन विचारों की तलाश कर रहा हूं जो सामान्य रूप से एफ # # के लिए कम से कम कुछ विशिष्ट हैं जो गोल्फ की समस्याओं को लागू कर सकते हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)। कृपया प्रति उत्तर एक टिप पोस्ट करें।
जवाबों:
जब संभव हो तो functionइसके बजाय का उपयोग करें match; यह 1-वर्ण चर के लिए 6 वर्णों को बचाएगा:
let f=function // ... (14 chars)
बनाम
let f x=match x with // ... (20 chars)
यह 1 वर्ण को लगातार बचाने के लिए किसी भी पैटर्न मैच की जगह ले सकता है:
match a with| // ... (13 chars)
a|>function| // ... (12 chars)
(function| (* ... *))a // (12 chars)
जब आप कर सकते हैं तो infix ऑपरेटरों के लिए उपसर्ग संकेतन का उपयोग करें - यह आपको उनका उपयोग करने के लिए फ़ंक्शन को परिभाषित करने से बचाएगा।
उदाहरण के लिए, आप इसे बदल सकते हैं:
List.map(fun i->i+2)[1;1;2;3;5;8]
इस मामले में:
List.map((+)2)[1;1;2;3;5;8]
यदि आप चर का उपयोग करने के लिए चारों ओर नहीं पहुंच सकते हैं, तो एकाधिक लेट एक्सप्रेशंस के बजाय टपल डीकंस्ट्रक्शन का उपयोग करें
let a,b ="",[]
के बजाय
let a=""
let b=[]
एफ # कोर लाइब्रेरी System.Console.Inनामक एक उपनाम को परिभाषित करता है stdin। ये आपको इनपुट पढ़ने की अनुमति देते हैं।
// Signature:
stdin<'T> : TextReader
तथ्य यह है कि यह की तुलना Consoleमें कम है एक तरफ बड़ा लाभ , आप या तो सिस्टम को खोलने के लिए नहीं है
स्ट्रिंग मूल रूप से एक है char seq, यह आपको Seq.mapस्ट्रिंग्स के साथ सीधे उपयोग करने की अनुमति देता है । समझ में उनका उपयोग करना भी संभव है[for c in "" do]
संदर्भ कक्षों का उपयोग करना हमेशा कम नहीं होता है क्योंकि प्रत्येक रीड ऑपरेशन सेल को निष्क्रिय करने के लिए एक अतिरिक्त वर्ण के साथ आता है।
संपूर्ण match .. withइनलाइन लिखना संभव है
function|'a'->()|'b'->()|_->()
गैर अल्फ़ान्यूमेरिक वर्णों के पहले और बाद में श्वेत-स्थान की कोई आवश्यकता नहीं है।
String.replicate 42" "
if Seq.exists((<>)'@')s then
if(Seq.exists((<>)'@')s)then
यदि आपको रिक्त स्थान के साथ एक स्ट्रिंग को बाएं या दाएं पैड की आवश्यकता होती है, तो आप इसके लिए [s] प्रिंटफ [n] झंडे का उपयोग कर सकते हैं।
> sprintf "%20s" "Hello, World!";;
val it : string = " Hello, World!"
आईडी पहचान कार्य के लिए एक ऑपरेटर है।
let u x=x|>Seq.countBy (fun x->x)
लिखा जा सकता है
let u x=x|>Seq.countBy id
मैं इसका उपयोग यहां करता हूं
मेरे एक समाधान में इस टिप के लिए लकोनी का बहुत धन्यवाद ।
किसी फ़ंक्शन पर विचार करें, कहें, अपर-केस अक्षरों के लिए 3 और अन्य सभी वर्णों के लिए एक स्ट्रिंग लिखें। इसलिए:
let counter input = Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1) input
एटा-रूपांतरण द्वारा इसे इस प्रकार लिखा जा सकता है:
let counter = Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1)
और पहले की तरह ही बुलाया गया:
counter "Hello world!" |> printfn "%i"
>>अब मान लें कि हमारी मूल चुनौती ऊपरी मामले के पत्रों के लिए 3 और निचले मामलों के पत्रों के लिए 1 के साथ एक स्ट्रिंग की राशि होगी, और अन्य सभी वर्णों को बाहर रखा गया है।
हम इसे इस प्रकार लिख सकते हैं:
let counter input = Seq.filter Char.IsLetter input |> Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1)
हम >>दो कार्यों ( Seq.filterऔर Seq.sumBy) को एक साथ करने के लिए फॉरवर्ड-कंपोजिशन ऑपरेटर ( ) का उपयोग कर सकते हैं। एटा-रूपांतरण के साथ फ़ंक्शन परिभाषा बन जाएगी:
let counter = Seq.filter Char.IsLetter >> Seq.sumBy (fun x -> if Char.IsUpper x then 3 else 1)
क्रिस स्मिथ ने >>अपने MSDN ब्लॉग पर ऑपरेटर पर एक शानदार लेखन किया ।
जब संभव हो इससे Seqछोटा हो List:
[[1];[2;3];[4];[5]|>List.collect
[[1];[2;3];[4];[5]|>Seq.collect
एक चार छोटी है ...
let f = [(0,1);(1,4)]|>Seq.map(fst)
printfn "%A" f
लिखा जा सकता है
let f = [0,1;1,4]|>Seq.map fst
printfn "%A" f
यह आपके कोड में एक भी नई लाइन वर्ण पर भुगतान करना शुरू कर देगा। एक उपयोग मामला हो सकता है:
string.Concat"\n"
string.Concat"
"
Es6 के लिए चिरु के उत्तर से प्रेरित ।
.NET बहुत अच्छे बिल्डिंग्स प्रदान करता है। F # उनका उपयोग कर सकते हैं, इसलिए उन्हें मत भूलना!
उदाहरण:
open System.Linq
यह मददगार हो सकता है!
for i in[0..2]
for i=0 to 2
moduleकीवर्ड मॉड्यूल नाम जब बार-बार इस्तेमाल कम करने के लिए इस्तेमाल किया जा सकता। उदाहरण के लिए:
Array.fold ...
Seq.iter ...
List.map ...
बन सकता है
module A=Array
A.fold ...
module S=Seq
S.iter ...
module L=List
L.map ...
यह अधिक समय तक चलने वाले कार्यक्रमों के लिए अधिक उपयोगी है जहां मॉड्यूल विधियों का बार-बार उपयोग किया जाता है (और हर बार पूरी तरह से नाम होना चाहिए क्योंकि उनके पास RequireQualifiedAccessसंशोधक है), और विशेष रूप से नियमित रूप से सीएलआर सरणी का उपयोग करने के लिए अधिक उपयोगी होने पर कुछ वर्णों को बंद करने की अनुमति देता है (जैसे, परिवर्तनशीलता ) एक F # seqया से list।