Fonction de liaison ReasonML avec configuration ayant des valeurs de chaîne fixes

En effet, en réalité, ces valeurs sont des variantes strong>, au lieu d'essayer de le rendre exactement comme JavaScript, je préférerais essayer quelque chose de plus idiomatique à Reason:

type color = Blue | Green | Red;
type coords = X | Y;
type config = {
  color,
  coords,
  number: int
};

let func = (config: config) => "something"

Les attributs @bs sont souvent des hacks mal pensés dont vous ne devriez pas vous attendre à bien fonctionner avec d'autres attributs, ou vraiment avec autre chose que ce que la documentation explique ou montre des exemples. Cependant, si un attribut est utilisé là où il n'est pas prévu, vous recevrez généralement au moins un avertissement indiquant que l'attribut n'est pas utilisé, ce que fait votre code.

@ bs.string en particulier ne fonctionne que sur les types au niveau le plus externe des externes, c'est-à-dire sur les types dont les valeurs seront passées directement à la fonction externe. Il existe également un moyen de créer des objets JavaScript à l'aide de fonctions externes qui utilisent également moins de magie et vous donnent beaucoup plus de contrôle sur l'API. Pour autant que je sache, le seul inconvénient par rapport à @ bs.deriving est que vous ne pouvez pas remplacer les noms de champ en utilisant quelque chose comme @ bs.as . Ils doivent être des identifiants OCaml valides.

Voici votre exemple implémenté à l'aide d'une fonction externe annotée avec @bs.obj:

type color = Blue | Red | Green;
let colorToString = fun
  | Blue => "blue"
  | Red => "red"
  | Green => "green";

type other = X | Y;    
let otherToString = fun
  | X => "x"
  | Y => "y";

[@bs.obj] external options : (
  ~color:string=?,
  ~number:int=?,
  ~other:string=?,
  unit
  ) => options = "";

[@bs.module] external func: options => string = "func";

let func = (~color=?, ~number=?, ~other=?, ()) =>
    func(options(
      ~color = ?Belt.Option.map(color, colorToString),
      ~number?,
      ~other = ?Belt.Option.map(other, otherToString),
      ()));

let config = func(~color=Blue,~number=123, ~other=X, ());

Pour l'utiliser, vous l'appelez exactement comme avec @bs.deriving:

let config = options(~color=`blue,~number=123, ~other=`x, ());

Mais même avec cela, j'ai rencontré des cas extrêmes où integer les valeurs sont transmises à la place des chaînes. Pour cette raison, j'ai tendance à éviter complètement les attributs de variantes polymorphes et à utiliser à la place des variantes ordinaires avec des fonctions de conversion. Cela présente l'avantage supplémentaire d'être plus idiomatique, de mieux s'intégrer et d'être plus interopérable avec du code non BuckleScript.

Voici à quoi pourrait ressembler votre exemple en utilisant cette approche:

type options;
[@bs.obj] external options : (
  ~color:[@bs.string] [`blue | `red | `green]=?,
  ~number:int=?,
  ~other:[@bs.string] [`x | `y]=?,
  unit
  ) => options = "";

Il s'agit d'un cas d'idiome JavaScript pour les paramètres nommés (objets avec des champs optionnels), devant être adapté à l'idiome OCaml / ReasonML (fonctions avec des paramètres étiquetés réels). Vous feriez cela en trois étapes. Étape 1, comme Glenn l'a montré, définissez un externe pour la configuration:

let result = func(~color=`blue, ());

Étape 2, liez-vous à la fonction JavaScript en utilisant le style JavaScript de l'objet de configuration:

let func(~color=?, ~number=?, ~other=?, ()) = ()
  |> config(~color?, ~number?, ~other?)
  |> func;

Étape 3, enveloppez la liaison de la fonction JavaScript dans une fonction OCaml-idiomatic avec des paramètres étiquetés:

[@bs.val] external func: config => string = "";

Vous pouvez l'utiliser comme ceci: p >

type config;
[@bs.obj] external config: (
  ~color:[@bs.string] [`blue | `red | `green]=?,
  ~number:int=?,
  ~other:[@bs.string] [`x | `y]=?,
 unit,
) => config = "";