F#
अनुक्रम वर्कफ़्लोज़

उपज और उपज!

अनुक्रम वर्कफ़्लोज़ में, yield एकल आइटम को अनुक्रम में बनाया जाता है। (राक्षसी शब्दावली में, यह return )

> seq { yield 1; yield 2; yield 3 }
val it: seq<int> = seq [1; 2; 3]

> let homogenousTup2ToSeq (a, b) = seq { yield a; yield b }
> tup2Seq ("foo", "bar")
val homogenousTup2ToSeq: 'a * 'a -> seq<'a>
val it: seq<string> = seq ["foo"; "bar"]

yield! (स्पष्ट उपज धमाका ) इस क्रम में निर्मित किए जा रहे अन्य अनुक्रम की सभी वस्तुओं को सम्मिलित करता है। या, दूसरे शब्दों में, यह एक क्रम जोड़ता है। (भिक्षुओं के संबंध में, यह bind ।)

> seq { yield 1; yield! [10;11;12]; yield 20 }
val it: seq<int> = seq [1; 10; 11; 12; 20]

// Creates a sequence containing the items of seq1 and seq2 in order
> let concat seq1 seq2 = seq { yield! seq1; yield! seq2 }
> concat ['a'..'c'] ['x'..'z']
val concat: seq<'a> -> seq<'a> -> seq<'a>
val it: seq<int> = seq ['a'; 'b'; 'c'; 'x'; 'y'; 'z']

अनुक्रम वर्कफ़्लोज़ द्वारा बनाई गई अनुक्रम भी आलसी हैं, जिसका अर्थ है कि अनुक्रम की वस्तुओं का वास्तव में मूल्यांकन नहीं किया जाता है जब तक कि उन्हें ज़रूरत न हो। आइटम को बाध्य करने के कुछ तरीकों में Seq.take ( Seq.take में पहले n आइटम को Seq.iter ), Seq.iter (साइड इफेक्ट्स को निष्पादित करने के लिए प्रत्येक आइटम पर एक फ़ंक्शन लागू होता है), या Seq.toList (एक सूची में एक अनुक्रम परिवर्तित करता है) शामिल हैं। । इसे पुनरावृत्ति के साथ जोड़ना जहां yield! वास्तव में चमक शुरू होता है।

> let rec numbersFrom n = seq { yield n; yield! numbersFrom (n + 1) }
> let naturals = numbersFrom 0
val numbersFrom: int -> seq<int>
val naturals: seq<int> = seq [0; 1; 2; ...]

// Just like Seq.map: applies a mapping function to each item in a sequence to build a new sequence
> let rec map f seq1 =
      if Seq.isEmpty seq1 then Seq.empty
      else seq { yield f (Seq.head seq1); yield! map f (Seq.tail seq1) }
> map (fun x -> x * x) [1..10]
val map: ('a -> 'b) -> seq<'a> -> 'b
val it: seq<int> = seq [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

के लिये

अनुक्रम अभिव्यक्ति के for अपने अधिक प्रसिद्ध चचेरे भाई की तरह देखने के लिए डिज़ाइन किया गया है, अनिवार्य लूप। यह एक अनुक्रम के माध्यम से "लूप्स" करता है और प्रत्येक पुनरावृत्ति के शरीर का मूल्यांकन उस अनुक्रम में करता है जो इसे उत्पन्न कर रहा है। सब कुछ अनुक्रम से संबंधित की तरह, यह परस्पर नहीं है।

> let oneToTen = seq { for x in 1..10 -> x }
val oneToTen: seq<int> = seq [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
// Or, equivalently:
> let oneToTen = seq { for x in 1..10 do yield x }
val oneToTen: seq<int> = seq [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

// Just like Seq.map: applies a mapping function to each item in a sequence to build a new sequence
> let map mapping seq1 = seq { for x in seq1 do yield mapping x }
> map (fun x -> x * x) [1..10]
val map: ('a -> 'b) -> seq<'a> -> seq<'b>
val it: seq<int> = seq [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]

// An infinite sequence of consecutive integers starting at 0
> let naturals =
      let numbersFrom n = seq { yield n; yield! numbersFrom (n + 1) }
      numbersFrom 0
// Just like Seq.filter: returns a sequence consisting only of items from the input sequence that satisfy the predicate
> let filter predicate seq1 = seq { for x in seq1 do if predicate x then yield x }
> let evenNaturals = naturals |> filter (fun x -> x % 2 = 0)
val naturals: seq<int> = seq [1; 2; 3; ...]
val filter: ('a -> bool) -> seq<'a> -> seq<'a>
val evenNaturals: seq<int> = seq [2; 4; 6; ...]

// Just like Seq.concat: concatenates a collection of sequences together
> let concat seqSeq = seq { for seq in seqSeq do yield! seq }
> concat [[1;2;3];[10;20;30]]
val concat: seq<#seq<'b>> -> seq<'b>
val it: seq<int> = seq [1; 2; 3; 10; 20; 30]