javascript - Lodash Flow y TypeScript

functional-programming

Question

He estado siguiendo un artículo sobre Lodash, Por qué usar _.chain es un error , y se destaca que puedes eliminar la necesidad de usar la cadena usando Flow .

El ejemplo dado es el siguiente usando cadena

import _ from "lodash";

_.chain([1, 2, 3])
    .map(x => [x, x*2])
    .flatten()
    .sort()
    .value();

se puede convertir a la siguiente utilizando el flujo

import map from "lodash/fp/map";
import flatten from "lodash/fp/flatten";
import sortBy from "lodash/fp/sortBy";
import flow from "lodash/fp/flow";

flow(
    map(x => [x, x*2]),
    flatten,
    sortBy(x => x) 
)([1,2,3]);

Sin embargo, cuando implemento esto usando TypeScript, obtengo el siguiente error

El objeto es de tipo ''desconocido'' .ts (2571)

¿Hay alguna forma de solucionar esto para que TypeScript sepa con qué tipos está tratando?

Answer 1

A medida que se interpreta JavaScript / TypeScript (nota: el código de TypeScript se transpila a JavaScript, que luego se interpreta), cuando se usa la cadena, el script de tipo es consciente del tipo con el que trata (es decir, una matriz de números) como su primer lugar. Sin embargo, con el flujo, el tipo en el que actuarán las funciones de flujo se especifica en último lugar, por lo que no sabe qué tipos va a usar, de ahí la necesidad de genéricos u otra forma de indicar los tipos que se van a usar. Además, el indicador que genera este error es interpretar el código, por lo que no conoce los tipos que se tratan cuando la entrada es la última cuando se usa "flujo".

A medida que usa lodash con TypeScript, las funciones que está usando admiten genéricos para especificar los tipos con los que están tratando.

Por lo tanto, puede indicar lo que se está ingresando / emitiendo desde las funciones de lodash de la siguiente manera:

flow(
    map<number, [number, number]>(x => [x, x * 2]),
    flatten,
    sortBy(x => x)
)([1, 2, 3]);

o como sugiere dareka:

flow(
    map((x: number) => [x, x * 2]),
    flatten,
    sortBy(x => x)
)([1, 2, 3])

Pero, de nuevo, esto solo funciona porque le estamos indicando al compilador de qué tipo de letra se va a actuar.

Un ejemplo de estos fragmentos de código de trabajo se puede encontrar here .

Observe cómo las entradas / salidas de la función se han definido explícitamente, por ejemplo, "mapa" indica que el tipo sobre el que se va a iterar es un número, y el resultado de la operación es una tupla.

Answer 2

El método _.flow() genera una función de pointfree . Esto evita que el manuscrito infiera el tipo de la entrada.

Para resolver esto, asigne la función a una variable y agregue el tipo de función. Cuando se declaran los parámetros de las funciones y la salida, mecanografiado puede inferir los tipos internos de las funciones dentro del flujo.

Después de asignar la función a una variable, puede llamarla ( sandobx ):

const fn: (numbers: number[]) => number[] = flow(
    map(x => [x, x*2]),
    flatten,
    sortBy(x => x) 
);

const result = fn([1,2,3]);

O use la aserción de tipo si desea invocar la función inmediatamente ( sandbox ):

type Fn = (numbers: number[]) => number[];

const result = (flow(
  map(x => [x, x * 2]),
  flatten,
  sortBy(x => x)
) as Fn)([1, 2, 3]);

Answer 3

Me gusta la respuesta de Ben Smith, ya que fue bastante educativa para mí. Pero iba a sugerir esto

map((x: number) => [x, x*2])

o incluso

map((x: any) => [x, x*2])

Para casos más generales. Parece que funciona y obtendrá la mayor inferencia posible si no quieres ser demasiado estricto.