Seq.delay<'T>, fonction (F#)

generator

Type : unit -> seq<'T>

Fonction génératrice pour la séquence.

La séquence résultante.

La fonction d'entrée est évaluée à chaque fois qu'un IEnumerator pour la séquence est demandé.

Cette fonction se nomme Delay dans les assemblys compilés. Si vous accédez à la fonction à partir d'un langage autre que F# ou par réflexion, utilisez ce nom.

Le code suivant montre comment utiliser Seq.delay pour différer l'évaluation d'une séquence qui est créée à partir d'une collection qui est normalement évaluée immédiatement.

// Normally sequences are evaluated lazily.  In this case,
// the sequence is created from a list, which is not evaluated
// lazily. Therefore, without Seq.delay, the elements would be
// evaluated at the time of the call to makeSequence.
let makeSequence function1 maxNumber = Seq.delay (fun () ->
    let rec loop n acc =
        printfn "Evaluating %d." n
        match n with
        | 0 -> acc
        | n -> (function1 n) :: loop (n - 1) acc
    loop maxNumber []
    |> Seq.ofList)
printfn "Calling makeSequence."
let seqSquares = makeSequence (fun x -> x * x) 4          
let seqCubes = makeSequence (fun x -> x * x * x) 4
printfn "Printing sequences."
printfn "Squares:"
seqSquares |> Seq.iter (fun x -> printf "%d " x)
printfn "\nCubes:"
seqCubes |> Seq.iter (fun x -> printf "%d " x)                       

Sortie

            
              Appel de makeSequence.
            
            
              Impression de séquences
            
            
              Carrés : évaluer 4.
            
            
              Évaluation 3.
            
            
              Évaluation 2.
            
            
              Évaluation 1.
            
            
              Évaluation 0.
            
            
              16 9 4 cubes 1 : évaluer 4.
            
            
              Évaluation 3.
            
            
              Évaluation 2.
            
            
              Évaluation 1.
            
            
              Évaluation 0.
            
            
              64 27 8 1
            
          

L'exemple de code suivant est équivalent à l'exemple précédent, mais il n'utilise pas Seq.delay. Remarquez la différence dans la sortie.

// Compare the output of this example with that of the previous.
// Notice that Seq.delay delays the
// execution of the loop until the sequence is used.
let makeSequence function1 maxNumber =
    let rec loop n acc =
        printfn "Evaluating %d." n
        match n with
        | 0 -> acc
        | n -> (function1 n) :: loop (n - 1) acc
    loop maxNumber []
    |> Seq.ofList
printfn "Calling makeSequence."
let seqSquares = makeSequence (fun x -> x * x) 4          
let seqCubes = makeSequence (fun x -> x * x * x) 4
printfn "Printing sequences."
printfn "Squares:"
seqSquares |> Seq.iter (fun x -> printf "%d " x)
printfn "\nCubes:"
seqCubes |> Seq.iter (fun x -> printf "%d " x)

Sortie

            
              Appel de makeSequence.
            
            
              Évaluation 4.
            
            
              Évaluation 3.
            
            
              Évaluation 2.
            
            
              Évaluation 1.
            
            
              Évaluation 0.
            
            
              Évaluation 4.
            
            
              Évaluation 3.
            
            
              Évaluation 2.
            
            
              Évaluation 1.
            
            
              Évaluation 0.
            
            
              Impression de séquences
            
            
              Carrés : 16 9 4 cubes 1 : 64 27 8 1
            
          

Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

Versions de bibliothèque principale F#

Prise en charge dans : 2,0, 4,0, portables

Référence