text: "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.eqDate = exports.eqNumber = exports.eqString = exports.eqBoolean = exports.eq = exports.strictEqual = exports.getStructEq = exports.getTupleEq = exports.Contravariant = exports.getMonoid = exports.getSemigroup = exports.eqStrict = exports.URI = exports.contramap = exports.tuple = exports.struct = exports.fromEquals = void 0;
  var function_1 = require("./function");
  // -------------------------------------------------------------------------------------
  // constructors
  // -------------------------------------------------------------------------------------
  /**
   * @category constructors
   * @since 2.0.0
   */
  var fromEquals = function (equals) { return ({
      equals: function (x, y) { return x === y || equals(x, y); }
  }); };
  exports.fromEquals = fromEquals;
  // -------------------------------------------------------------------------------------
  // combinators
  // -------------------------------------------------------------------------------------
  /**
   * @category combinators
   * @since 2.10.0
   */
  var struct = function (eqs) {
      return exports.fromEquals(function (first, second) {
          for (var key in eqs) {
              if (!eqs[key].equals(first[key], second[key])) {
                  return false;
              }
          }
          return true;
      });
  };
  exports.struct = struct;
  /**
   * Given a tuple of `Eq`s returns a `Eq` for the tuple
   *
   * @example
   * import { tuple } from 'fp-ts/Eq'
   * import * as S from 'fp-ts/string'
   * import * as N from 'fp-ts/number'
   * import * as B from 'fp-ts/boolean'
   *
   * const E = tuple(S.Eq, N.Eq, B.Eq)
   * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)
   * assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)
   * assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)
   * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)
   *
   * @category combinators
   * @since 2.10.0
   */
  var tuple = function () {
      var eqs = [];
      for (var _i = 0; _i < arguments.length; _i++) {
          eqs[_i] = arguments[_i];
      }
      return exports.fromEquals(function (first, second) { return eqs.every(function (E, i) { return E.equals(first[i], second[i]); }); });
  };
  exports.tuple = tuple;
  // -------------------------------------------------------------------------------------
  // non-pipeables
  // -------------------------------------------------------------------------------------
  /* istanbul ignore next */
  var contramap_ = function (fa, f) { return function_1.pipe(fa, exports.contramap(f)); };
  // -------------------------------------------------------------------------------------
  // type class members
  // -------------------------------------------------------------------------------------
  /**
   * @category Contravariant
   * @since 2.0.0
   */
  var contramap = function (f) { return function (fa) {
      return exports.fromEquals(function (x, y) { return fa.equals(f(x), f(y)); });
  }; };
  exports.contramap = contramap;
  // -------------------------------------------------------------------------------------
  // instances
  // -------------------------------------------------------------------------------------
  /**
   * @category instances
   * @since 2.0.0
   */
  exports.URI = 'Eq';
  /**
   * @category instances
   * @since 2.5.0
   */
  exports.eqStrict = {
      equals: function (a, b) { return a === b; }
  };
  var empty = {
      equals: function () { return true; }
  };
  /**
   * @category instances
   * @since 2.10.0
   */
  var getSemigroup = function () { return ({
      concat: function (x, y) { return exports.fromEquals(function (a, b) { return x.equals(a, b) && y.equals(a, b); }); }
  }); };
  exports.getSemigroup = getSemigroup;
  /**
   * @category instances
   * @since 2.6.0
   */
  var getMonoid = function () { return ({
      concat: exports.getSemigroup().concat,
      empty: empty
  }); };
  exports.getMonoid = getMonoid;
  /**
   * @category instances
   * @since 2.7.0
   */
  exports.Contravariant = {
      URI: exports.URI,
      contramap: contramap_
  };
  // -------------------------------------------------------------------------------------
  // deprecated
  // -------------------------------------------------------------------------------------
  /**
   * Use [`tuple`](#tuple) instead.
   *
   * @category combinators
   * @since 2.0.0
   * @deprecated
   */
  exports.getTupleEq = exports.tuple;
  /**
   * Use [`struct`](#struct) instead.
   *
   * @category combinators
   * @since 2.0.0
   * @deprecated
   */
  exports.getStructEq = exports.struct;
  /**
   * Use [`eqStrict`](#eqstrict) instead
   *
   * @since 2.0.0
   * @deprecated
   */
  exports.strictEqual = exports.eqStrict.equals;
  /**
   * Use small, specific instances instead.
   *
   * @category instances
   * @since 2.0.0
   * @deprecated
   */
  exports.eq = exports.Contravariant;
  /**
   * Use [`Eq`](./boolean.ts.html#eq) instead.
   *
   * @category instances
   * @since 2.0.0
   * @deprecated
   */
  exports.eqBoolean = exports.eqStrict;
  /**
   * Use [`Eq`](./string.ts.html#eq) instead.
   *
   * @category instances
   * @since 2.0.0
   * @deprecated
   */
  exports.eqString = exports.eqStrict;
  /**
   * Use [`Eq`](./number.ts.html#eq) instead.
   *
   * @category instances
   * @since 2.0.0
   * @deprecated
   */
  exports.eqNumber = exports.eqStrict;
  /**
   * Use [`Eq`](./Date.ts.html#eq) instead.
   *
   * @category instances
   * @since 2.0.0
   * @deprecated
   */
  exports.eqDate = {
      equals: function (first, second) { return first.valueOf() === second.valueOf(); }
  };
  