Expand Minimize

Seq.cache<'T> Function (F#)

Returns a sequence that corresponds to a cached version of the input sequence.

Namespace/Module Path: Microsoft.FSharp.Collections.Seq

Assembly: FSharp.Core (in FSharp.Core.dll)

// Signature:
Seq.cache : seq<'T> -> seq<'T>

// Usage:
Seq.cache source

source

Type: seq<'T>

The input sequence.

Exception

Condition

ArgumentNullException

Thrown when the input sequence is null.

The result sequence.

This result sequence will have the same elements as the input sequence. The result can be enumerated multiple times. The input sequence is enumerated at most once and only as far as is necessary. Caching a sequence is typically useful when repeatedly evaluating items in the original sequence is computationally expensive or if iterating the sequence causes side-effects that the user does not want to be repeated multiple times. Once enumeration of the input sequence has started, its enumerator will be kept active by this object until the enumeration has completed. At that point, the enumerator will be disposed. The enumerator may be disposed and underlying cache storage released by converting the returned sequence object to type IDisposable, and calling the Dispose method on this object. The sequence object may then be re-enumerated and a fresh enumerator will be used.

This function is named Cache in compiled assemblies. If you are accessing the function from a language other than F#, or through reflection, use this name.

The following code example demonstrates how to use Seq.cache to avoid recomputing elements of a sequence.

// Recursive isprime function. 
let isPrime n =
    let rec check i =
        i > n/2 || (n % i <> 0 && check (i + 1))
    check 2

let seqPrimes = seq { for n in 2 .. 10000 do if isPrime n then yield n }
// Cache the sequence to avoid recomputing the sequence elements. 
let cachedSeq = Seq.cache seqPrimes
for index in 1..5 do
    printfn "%d is prime." (Seq.nth (Seq.length cachedSeq - index) cachedSeq)

Output

9973 is prime.
9967 is prime.
9949 is prime.
9941 is prime.
9931 is prime.

Enumeration of the result sequence is thread-safe in the sense that multiple independent IEnumerator values may be used simultaneously from different threads (accesses to the internal lookaside table are thread-safe). Each individual IEnumerator is not typically thread-safe and should not be accessed concurrently.

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

F# Core Library Versions

Supported in: 2.0, 4.0, Portable

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft