es6 - qué se debe tener en cuenta para darle el nombre a una variable o constante en javascript

Tipos de flujo con cadenas constantes y tipos dependientes.

Question

Digamos que tengo la siguiente cadena constante:

export default const FOO = ''FOO''

Digamos que yo importe esto en un archivo anotado de flujo como tal:

import FOO from ''../consts/Foo''

Entonces tengo una función:

const example = (foo : string) : {| type: FOO, foo: string |} => {
  return {type: FOO, foo: foo}
}

Esto no se comprueba con:

  6: const example = (foo : string) : {| type: FOO, foo: string |}=> {
                                                         ^^^^^^^^^^^^^^ string. Ineligible value used in/as type annotation (did you forget ''typeof''?)
  6: const example = (foo : string) : {| type: FOO, foo: string |}=> {
                                                         ^^^^^^^^^^^^^^ FOO

Así que mis preguntas son:

1) ¿Es posible usar constantes en los tipos de flujo? ¿Cómo puedo reproducir este comportamiento?

2) ¿Es posible hacer tipos dependientes en flujo? Entonces, por ejemplo, ¿podría codificar, a través de tipos, que la cadena que se devuelve debe ser la misma que se pasa a la función de example ?

EDIT: Aclaración de la parte 2: ¿Es posible indicar de alguna manera que el parámetro foo pasado a la función de example es de hecho la misma cadena que la cadena en la tecla foo en el objeto de retorno? O para afirmar que la entrada y la salida tienen la misma longitud (por ejemplo, una función de cifrado de cambio). ¿O decir que contienen una permutación de los mismos caracteres? (Para un shuffle).

https://en.wikipedia.org/wiki/Dependent_type

Answer 1

En lugar de declarar FOO como una const , declare que es una unión desunida con una sola rama:

type FOO = "FOO"

Entonces tu código se puede actualizar así:

const example = (foo : string) : {| type: FOO, foo: string |} => {
  return {type: "FOO", foo: foo}
}

Si usa cualquier valor además de la cadena exacta literal "FOO" donde se requiere un FOO , entonces es un error de compilación.

Si prefiere mantener la constante, deberá nombrar el tipo de forma diferente, ya que chocaría. Para que pudieras hacer:

const FOO = "FOO"
type FooType = "FOO";

const example = (foo : string) : {| type: FooType, foo: string |} => {
  return {type: FOO, foo: foo}
}

Desafortunadamente, no puedo ver una manera de evitar la duplicación de la cadena literal, porque la sintaxis de definición de unión de tipo disjoint solo permite literales y tipos, no variables, incluso si son constantes.