दोहरा दृश्यों

Question

मैं मूल्य का एक 'संकुचित' धारा है, कि मूल्य की घटना की संख्या से जुड़ा हुआ है जो करने के लिए उदाहरण के लिए:

let a = [(),1;(),4;(),3;] 

मैं करने के लिए 'uncompress' है कि अनुक्रम पसंद है और फेंकना होगा मूल अनुक्रम मैं उपज करने के लिए एक दोहराने वाला संयोजक परिभाषित कर सकता हूं! उस प्रभाव

let rec repeat avalue n = seq { if n > 0 then 
            yield avalue; yield! repeat avalue (n-1) } 

let b = seq { for v,n in a do 
       yield! repeat v n } |> Seq.toList 

को वहाँ कि इनलाइन, एक संरचना के रूप में व्यक्त करने के लिए एक तरीका है?

let c = a |> Seq.XXX(fun e -> ...) 

Answer 1

आप Enumerable.Repeat का उपयोग कर ऐसा कर सकते हैं:

> Seq.collect Enumerable.Repeat [ 1, 2; 3, 4; 5, 6 ] |> List.ofSeq;; 
val it : int list = [1; 1; 3; 3; 3; 3; 5; 5; 5; 5; 5; 5] 

Answer 2

मैं Enumerable.Repeat के लिए इसी तरह एक पुस्तकालय समारोह कैसे के बारे में

let c = a |> Seq.collect (fun (v,i) -> [1..i] |> Seq.map (fun x -> v)) 

पता नहीं है; अगर कोई एक के बारे में जानता है, तो कृपया एक टिप्पणी जोड़ें।

संपादित

मैं हालांकि यह List मॉड्यूल में है, Enumerable.Repeat के लिए इसी तरह एक पुस्तकालय समारोह पाया है:

let c = a |> Seq.collect (fun (v,i) -> List.replicate i v) 

यह और अधिक सुरुचिपूर्ण हो सकता है अगर स्रोत में जोड़े अनुक्रम उलट दिया गया:

let c = a |> Seq.collect ((<||) List.replicate) 

तो ऐसा लगता है कि संख्यात्मक.रे

let c = a |> Seq.collect Enumerable.Repeat 

किसी को भी एक इसी तरह सुरुचिपूर्ण समाधान है कि एफ # पुस्तकालय के भीतर रहता है की जानता है, एक टिप्पणी जोड़ें: (स्वीकार किए जाते हैं जवाब के रूप में) पीट वास्तव में के बाद से अपने tupled तर्क अनुक्रम तत्वों से मेल खाता है, सबसे अच्छा समाधान पड़ता है ; धन्यवाद।

Answer 3

let rec repeat (item,n) = seq { if n > 0 then yield item; yield! repeat(item, n-1)} 
a |> Seq.collect repeat 

उदाहरण के लिए,

[('a',2); ('b',2)] |> Seq.collect repeat 

val it: seq<char> = seq ['a';'a';'b';'b']