F#
Secuencia

Generar secuencias

Hay varias formas de crear una secuencia.

Puedes usar funciones del módulo Seq:

// Create an empty generic sequence
let emptySeq = Seq.empty 

// Create an empty int sequence
let emptyIntSeq = Seq.empty<int> 

// Create a sequence with one element    
let singletonSeq = Seq.singleton 10 

// Create a sequence of n elements with the specified init function
let initSeq = Seq.init 10 (fun c -> c * 2) 

// Combine two sequence to create a new one
let combinedSeq = emptySeq |> Seq.append singletonSeq

// Create an infinite sequence using unfold with generator based on state
let naturals = Seq.unfold (fun state -> Some(state, state + 1)) 0

También puede utilizar la expresión de secuencia:

// Create a sequence with element from 0 to 10
let intSeq = seq { 0..10 }

// Create a sequence with an increment of 5 from 0 to 50
let intIncrementSeq = seq{ 0..5..50 }

// Create a sequence of strings, yield allow to define each element of the sequence
let stringSeq = seq {
    yield "Hello"
    yield "World"
}

// Create a sequence from multiple sequence, yield! allow to flatten sequences
let flattenSeq = seq {
    yield! seq { 0..10 }
    yield! seq { 11..20 }
}

Introducción a las secuencias.

Una secuencia es una serie de elementos que pueden ser enumerados. Es un alias de System.Collections.Generic.IEnumerable y perezoso. Almacena una serie de elementos del mismo tipo (puede ser cualquier valor u objeto, incluso otra secuencia). Las funciones del Seq.module se pueden utilizar para operar en él.

Aquí hay un ejemplo simple de una enumeración de secuencia:

let mySeq = { 0..20 } // Create a sequence of int from 0 to 20
mySeq
|> Seq.iter (printf "%i ") // Enumerate each element of the sequence and print it

Salida:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Seq.map

let seq = seq {0..10}

s |> Seq.map (fun x -> x * 2)

> val it : seq<int> = seq [2; 4; 6; 8; ...]

Aplicar una función a cada elemento de una secuencia usando Seq.map

Seq.filter

Supongamos que tenemos una secuencia de enteros y queremos crear una secuencia que contenga solo los enteros pares. Podemos obtener este último utilizando la función de filter del módulo Seq. La función de filter tiene la firma de tipo ('a -> bool) -> seq<'a> -> seq<'a> ; esto indica que acepta una función que devuelve verdadero o falso (a veces llamado predicado) para una entrada dada de tipo 'a y una secuencia que comprende valores de tipo 'a para producir una secuencia que comprende valores de tipo 'a .

// Function that tests if an integer is even
let isEven x = (x % 2) = 0

// Generates an infinite sequence that contains the natural numbers
let naturals = Seq.unfold (fun state -> Some(state, state + 1)) 0
 
// Can be used to filter the naturals sequence to get only the even numbers
let evens = Seq.filter isEven naturals 

Secuencias repetitivas infinitas

let data = [1; 2; 3; 4; 5;]
let repeating = seq {while true do yield! data}

Se pueden crear secuencias repetidas usando una expresión de cálculo seq {}