एफ # मूल बातें: एक स्ट्रिंग

Question

मेरी स्ट्रिंग दिनों से थोड़ी सी जंगली में एक साथ फोल्डिंग 2 सूचियां, मैं 2 सूचियों को लेना चाहता हूं: संख्याओं में से एक और तारों में से एक, और उन्हें एक स्ट्रिंग में एक साथ जोड़ना जहां प्रत्येक जोड़ी है "{(ushort) 5," bla bla bla "}, \ n" जैसे लिखा है। मैं इसके बारे में सबसे अधिक है, मैं सिर्फ यकीन है कि कैसे फोल्ड ठीक से लिखने के लिए नहीं कर रहा हूँ:

let splitter = [|","|] 
let indexes = 
    indexStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 
let values = 
    valueStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 

let pairs = List.zip indexes values 
printfn "%A" pairs 

let result = pairs |> Seq.fold 
    (fun acc a -> String.Format("{0}, \{(ushort){1}, \"{2}\"\}\n", 
           acc, (List.nth a 0), (List.nth a 1))) 

Answer 1

आपकी गायब दो चीजें हैं। गुना की प्रारंभिक स्थिति जो एक खाली स्ट्रिंग है और आप F # में tuples पर सूची समझ का उपयोग नहीं कर सकते हैं।

let splitter = [|","|] 
let indexes = 
    indexStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 
let values = 
    valueStr.Split(splitter, System.StringSplitOptions.None) |> Seq.toList 

let pairs = List.zip indexes values 
printfn "%A" pairs 

let result = 
    pairs 
    |> Seq.fold (fun acc (index, value) -> 
     String.Format("{0}{{(ushort){1}, \"{2}\"}},\n", acc, index, value)) "" 

fold2 संस्करण

let result = 
    List.fold2 
     (fun acc index value -> 
      String.Format("{0}{{(ushort){1}, \"{2}\"}},\n", acc, index, value)) 
     "" 
     indexes 
     values 

आप गति के साथ संबंध रहे हैं, तो आप स्ट्रिंग बिल्डर का उपयोग करने के बाद से यह एक नया स्ट्रिंग हर बार जब आप संलग्न पैदा नहीं करता चाहते हो सकता है।

let result = 
    List.fold2 
     (fun (sb:StringBuilder) index value -> 
      sb.AppendFormat("{{(ushort){0}, \"{1}\"}},\n", index, value)) 
     (StringBuilder()) 
     indexes 
     values 
    |> string 

Answer 2

मुझे लगता है कि आप List.fold2 चाहते हैं। किसी कारण से List मॉड्यूल में fold2 सदस्य है लेकिन Seq नहीं है। फिर आप पूरी तरह से zip के साथ बांट सकते हैं।

अपने नामित चर के प्रकार और परिणाम आप के लिए आशा के प्रकार के सभी निहित हैं, तो यह मदद करने के लिए मुश्किल है, लेकिन अगर आप स्ट्रिंग की एक सूची जमा करने के लिए कोशिश कर रहे हैं आप

की तर्ज पर कुछ विचार कर सकते हैं

let result = pairs |> Seq.fold 
    (fun prev (l, r) -> 
      String.Format("{0}, \{(ushort){1}, \"{2}\"\}\n", prev, l, r) 
    "" pairs 

मेरा एफ #/कैमल बहुत जंगली है इसलिए मेरे पास तर्कों का गलत गलत हो सकता है। यह भी ध्यान दें कि आपकी स्ट्रिंग गठन वर्गबद्ध है; मेरे अपने कोड में मैं इन पंक्तियों के साथ अधिक कुछ के साथ जाना होगा:

let strings = 
    List.fold2 (fun ss l r -> 
       String.format ("\{(ushort){0}, \"{1}\"\}\n", l, r) :: ss) 
       [] indexes values 

let result = String.concat ", " strings 

यह आपको द्विघात समय खर्च नहीं होगा और यह एक छोटे अनुसरण करना आसान है। मैंने एमएसडीएन की जांच की है और मेरा मानना ​​है कि मेरे पास fold2 पर तर्कों का सही क्रम है।

ध्यान रखें मुझे पता है कि कैमल एफ # नहीं है और इसलिए मेरे पास तर्कों का विवरण या आदेश गलत हो सकता है।

Answer 3

शायद इस कार्य के लिए सबसे अच्छी विधि नहीं है। यह एक बहुत आसान मैप करने के लिए और concat इस तरह:

let l1 = "a,b,c,d,e".Split([|','|]) 
let l2 = "1,2,3,4,5".Split([|','|]) 
let pairs = 
    Seq.zip l1 l2 
    |> Seq.map (fun (x, y) -> sprintf "(ushort)%s, \"%s\"" x y) 
    |> String.concat "\n" 

Answer 4

शायद यह:

let strBuilder = new StringBuilder() 
for (i,v) in Seq.zip indexes values do 
    strBuilder.Append(String.Format("{{(ushort){0}, \"{1}\"}},\n", i,v)) 
    |> ignore 

साथ एफ # कभी कभी बेहतर अनिवार्य जाना है

...

Answer 5

MAP2 या fold2 के लिए सही रास्ता है चले जाओ। यहाँ मेरी ले रहा है, (||>) ऑपरेटर का उपयोग:

let l1 = [| "a"; "b"; "c"; "d"; "e" |] 
let l2 = [| "1"; "2"; "3"; "4"; "5" |] 
let pairs = (l1, l2) ||> Seq.map2 (sprintf ("(ushort)%s, \"%s\"")) 
         |> String.concat "\n" 

निश्चित रूप से