Structural typing with first-class modules

Demo.bs.js

// Generated by BUCKLESCRIPT, PLEASE EDIT WITH CARE
'use strict';

var List$Modules = require("./List.bs.js");
var String$Modules = require("./String.bs.js");

var x = List$Modules.contains(String$Modules.Eq, "a", /* :: */[
      "b",
      /* :: */[
        "c",
        /* :: */[
          "d",
          /* [] */0
        ]
      ]
    ]);

var y = List$Modules.contains({
      eq: String$Modules.eq
    }, "a", /* :: */[
      "b",
      /* :: */[
        "c",
        /* :: */[
          "d",
          /* [] */0
        ]
      ]
    ]);

exports.x = x;
exports.y = y;
/* x Not a pure module */

Demo.re

let x = List.contains((module String.Eq), "a", ["b", "c", "d"]);
let y = List.contains((module String), "a", ["b", "c", "d"]);

Interface.re

module type EQ = {
  type t;
  let eq: (t, t) => bool;
};

List.re

let contains =
    (type a, eq: (module Interface.EQ with type t = a), x: a, xs: list(a))
    : bool => {
  module Eq = (val eq);
  Belt.List.reduce(xs, false, (acc, curr) => acc || Eq.eq(curr, x));
};

String.re

type t = string;

let append = (++);
let eq = (a: string, b: string) => a == b;
let lte = (a: string, b: string) => a <= b;
let toUpperCase = Js.String.toUpperCase;

module Eq: Interface.EQ with type t = string = {
  type t = string;
  let eq = eq;
};