Tipos flexibles

  • Artículo

Una anotación de tipo flexible indica que un parámetro, una variable o un valor tiene un tipo que es compatible con un tipo especificado, de tal forma que la compatibilidad viene determinada por la posición en una jerarquía orientada a objetos de clases o interfaces. Los tipos flexibles son útiles específicamente cuando no se produce la conversión automática a tipos superiores en la jerarquía de tipos, pero aun así quiere permitir que la funcionalidad funcione con cualquier tipo de la jerarquía o cualquier tipo que implemente una interfaz.

Sintaxis

#type

Comentarios

En la sintaxis anterior, type representa un tipo base o una interfaz.

Un tipo flexible es equivalente a un tipo genérico que tiene una restricción que limita los tipos permitidos a tipos compatibles con el tipo base o de interfaz. Es decir, las dos líneas de código siguientes son equivalentes.

#SomeType

'T when 'T :> SomeType

Los tipos flexibles son útiles en varias situaciones. Por ejemplo, cuando tiene una función de orden superior (una función que toma una función como argumento), a menudo resulta útil hacer que la función devuelva un tipo flexible. En el ejemplo siguiente, el uso de un tipo flexible con un argumento de secuencia en iterate2 permite que la función de orden superior funcione correctamente con funciones que generan secuencias, matrices, listas y cualquier otro tipo enumerable.

Tenga en cuenta las dos funciones siguientes, una de las cuales devuelve una secuencia, mientras que la otra devuelve un tipo flexible.

let iterate1 (f : unit -> seq<int>) =
    for e in f() do printfn "%d" e
let iterate2 (f : unit -> #seq<int>) =
    for e in f() do printfn "%d" e

// Passing a function that takes a list requires a cast.
iterate1 (fun () -> [1] :> seq<int>)

// Passing a function that takes a list to the version that specifies a
// flexible type as the return value is OK as is.
iterate2 (fun () -> [1])

Como otro ejemplo, considere la función de biblioteca Seq.concat:

val concat: sequences:seq<#seq<'T>> -> seq<'T>

Puede pasar cualquiera de las siguientes secuencias enumerables a esta función:

  • Una lista de listas
  • Una lista de matrices
  • Una matriz de listas
  • Una matriz de secuencias
  • Cualquier otra combinación de secuencias enumerables

En el código siguiente se usa Seq.concat para mostrar los escenarios que se pueden admitir mediante tipos flexibles.

let list1 = [1;2;3]
let list2 = [4;5;6]
let list3 = [7;8;9]

let concat1 = Seq.concat [ list1; list2; list3]
printfn "%A" concat1

let array1 = [|1;2;3|]
let array2 = [|4;5;6|]
let array3 = [|7;8;9|]

let concat2 = Seq.concat [ array1; array2; array3 ]
printfn "%A" concat2

let concat3 = Seq.concat [| list1; list2; list3 |]
printfn "%A" concat3

let concat4 = Seq.concat [| array1; array2; array3 |]
printfn "%A" concat4

let seq1 = { 1 .. 3 }
let seq2 = { 4 .. 6 }
let seq3 = { 7 .. 9 }

let concat5 = Seq.concat [| seq1; seq2; seq3 |]

printfn "%A" concat5

La salida es la siguiente.

seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]
seq [1; 2; 3; 4; ...]

En F#, como en otros lenguajes orientados a objetos, hay contextos en los que los tipos o los tipos derivados que implementan interfaces se convierten automáticamente en un tipo base o un tipo de interfaz. Estas conversiones automáticas se producen en argumentos directos, pero no cuando el tipo está en una posición subordinada, como parte de un tipo más complejo (por ejemplo, un tipo de valor devuelto de un tipo de función) o como argumento de tipo. Por lo tanto, la notación de tipo flexible es útil principalmente cuando el tipo al que se aplica forma parte de un tipo más complejo.

Vea también