f # सी # लाइब्रेरी

Question

से फ़ंक्शन का उपयोग करके दो सरणीओं पर पुनरावृत्त करना, मेरे पास शब्दों की एक सूची है और भाषण टैग के संबंधित भाग की एक सूची है। मैं एक .NET फ़ंक्शन में इनपुट के रूप में प्रत्येक अनुक्रमित ट्यूपल का उपयोग करके एक साथ (मिलान सूचकांक) दोनों पर पुनरावृत्ति करना चाहता हूं। इस का सबसे अच्छा तरीका (यह काम करता है, लेकिन मेरे लिए प्राकृतिक महसूस नहीं करता है) है:

let taggingModel = SeqLabeler.loadModel(lthPath + 
         "models\penn_00_18_split_dict.model"); 
let lemmatizer = new Lemmatizer(lthPath + "v_n_a.txt") 
let input = "the rain in spain falls on the plain" 

let words = Preprocessor.tokenizeSentence(input) 
let tags = SeqLabeler.tagSentence(taggingModel, words) 
let lemmas = Array.map2 (fun x y -> lemmatizer.lookup(x,y)) words tags 

Answer 1

आपका कोड मेरे लिए काफी अच्छा लग रहा है - इसमें से अधिकांश कुछ लदान और आरंभीकरण के साथ संबंधित है, इसलिए बहुत ज्यादा नहीं है आप उस हिस्से को सरल बनाने के लिए कर सकते हैं। वैकल्पिक रूप से Array.map2 के लिए, आप इस्तेमाल कर सकते हैं Seq.zipSeq.map के साथ संयुक्त - zip समारोह एक भी एक है कि मिलान सूचकांक के साथ तत्वों की जोड़ी हो उसमें दो दृश्यों को जोड़ती है:

let lemmas = Seq.zip words tags 
      |> Seq.map (fun (x, y) -> lemmatizer.lookup (x, y)) 

के बाद से lookup समारोह एक टपल है कि आप एक तर्क के रूप में मिला लेता है , आप लिख सकते हैं:

// standard syntax using the pipelining operator 
let lemmas = Seq.zip words tags |> Seq.map lemmatizer.lookup 

// .. an alternative syntax doing exactly the same thing 
let lemmas = (words, tags) ||> Seq.zip |> Seq.map lemmatizer.lookup 

||> ऑपरेटर दूसरे संस्करण में इस्तेमाल एक टपल दो मूल्यों से युक्त लेता है और दो तर्क के रूप में सही पक्ष पर कार्य करने के लिए उन्हें गुजरता है, जिसका अर्थ है वें (a, b) ||> f पर f a b का अर्थ है। |> ऑपरेटर बाईं ओर केवल एक ही मान लेता है, इसलिए (a, b) |> f का अर्थ f (a, b) होगा (जो काम करेगा यदि f फ़ंक्शन 0, स्पेस से अलग, पैरामीटर के बजाय अपेक्षित टुपल है)।

आप lemmas की जरूरत है अंत में एक सरणी होने के लिए आपको प्रसंस्करण पाइपलाइन (सभी Seq कार्यों दृश्यों, जो IEnumerable<T> के अनुरूप कार्य करते हैं)

एक और विकल्प के अंत तक Array.ofSeq जोड़ने की आवश्यकता होगी अनुक्रम एक्सप्रेशन का उपयोग करना है (आप सीधे अगर है कि तुम क्या जरूरत है एक सरणी के निर्माण के लिए [| .. |] उपयोग कर सकते हैं):

let lemmas = [| for wt in Seq.zip words tags do // wt is tuple (string * string) 
        yield lemmatizer.lookup wt |] 

अनुक्रम भाव है या नहीं का उपयोग करना है - कि सिर्फ एक निजी पसंद है। पहला विकल्प इस मामले में अधिक संक्षिप्त प्रतीत होता है, लेकिन अनुक्रम अभिव्यक्ति आंशिक फ़ंक्शन एप्लिकेशन (Seq.map का उपयोग कर छोटे संस्करण में)