@function __equal-lists($list, $other, $equal-func, $customizer, $is-where) {
  $index: 1;
  $list-length: length($list);
  $other-length: length($other);
  $result: true;

  @if not($list-length == $other-length) and not
    ($is-where and ($other-length > $list-length))
  {
    @return false;
  }

  @while ($result and ($index <= $list-length)) {
    $list-value: nth($list, $index);
    $other-value: nth($other, $index);
    $result: $__undefined__;

    @if ($customizer) {
      $result: if(
        $is-where,
        __exec($customizer, $other-value, $list-value, $index),
        __exec($customizer, $list-value, $other-value, $index)
      );
    }

    @if (__is-undefined($result)) {
      @if ($is-where) {
        $other-index: $other-length;
        $break: false;

        @while ($other-index > 0 and not $break) {
          $other-value: nth($other, $other-index);
          $result: if(
            $list-value == $other-value,
            true,
            __exec(
              $equal-func,
              $list-value,
              $other-value,
              $customizer,
              $is-where
            )
          );

          @if ($result) {
            $break: true;
          }

          $other-index: $other-index - 1;
        }
      } @else {
        $result: if(
          if($list-value, $list-value == $other-value, false),
          true,
          __exec($equal-func, $list-value, $other-value, $customizer, $is-where)
        );
      }
    }

    $index: $index + 1;
  }

  @return if($result, true, false);
}

@function __equal-by-tag() {
}

@function __equal-maps(
  $map,
  $other,
  $equal-func: false,
  $customizer: false,
  $is-where: false
) {
  $map-props: map-keys($map);
  $map-length: length($map-props);
  $other-props: map-keys($other);
  $other-length: length($other-props);

  @if ($map-length != $other-length) and not ($is-where) {
    @return false;
  }

  $has-ctor: false;
  $index: 1;

  @while ($index <= $map-length) {
    $key: nth($map-props, $index);
    $result: map-has-key($other, $key);

    @if ($result) {
      $map-value: __get($map, $key);
      $other-value: __get($other, $key);
      $result: $__undefined__;

      @if ($customizer) {
        $result: if(
          $is-where,
          __exec($customizer, $other-value, $map-value, $key),
          __exec($customizer, $map-value, $other-value, $key)
        );
      }

      @if (__is-undefined($result)) {
        $result: if(
          $map-value == $other-value,
          true,
          __exec($equal-func, $map-value, $other-value, $customizer, $is-where)
        );
      }
    }

    @if not($result) {
      @return false;
    }

    $has-ctor: if($has-ctor, true, ($key == "_type"));
    $index: $index + 1;
  }

  @if not($has-ctor) {
    // todo
  }

  @return true;
}

@function __base-is-equal($value, $other, $customizer: null, $is-where: null) {
  @if $value == $other {
    @return true;
  }

  @if __is-string($value) or not __is-iterable($value) {
    @return false;
  }

  @return __base-is-equal-deep($value, $other, $customizer, $is-where);
}

@function __base-is-equal-deep(
  $value,
  $other,
  $customizer: null,
  $is-where: null
) {
  $func: if(__is-list-like($value), "__equal-lists", "__equal-maps");

  @return __exec(
    $func,
    $value,
    $other,
    "__base-is-equal",
    $customizer,
    $is-where
  );
}

@function __is-equal($value, $other, $customizer: null, $this-arg: null) {
  $customizer: if(
    __function-exists($customizer),
    __bind-callback($customizer, $this-arg, 3),
    false
  );

  @if (
    not
      $customizer and
      __is-strict-comparable($value) and
      __is-strict-comparable($other)
  ) {
    @return ($value == $other) and (type-of($value) == type-of($other));
  }

  $result: if($customizer, __exec($customizer, $value, $other), $__undefined__);

  @return if(
    __is-undefined($result) or __is-null($result),
    __base-is-equal($value, $other, $customizer),
    ($result and true)
  );
}

/// Performs a deep comparison between two values to determine if they are
/// equivalent. If `$customizer` is provided it is invoked to compare values.
/// If `$customizer` returns `undefined` comparisons are handled by the method
/// instead. The `$customizer` is bound to `$this-arg` and invoked with three
/// arguments; (value, other, (index|key)).
///
///
/// @access public
/// @group Lang
/// @param {*} $value The value to compare.
/// @param {*} $other The other value to compare.
/// @param {Function} $customizer [null] The function to customize comparing values.
/// @param {*} $this-arg [null] - The `_this` binding of `$customizer`.
/// @returns {boolean} Returns `true` if the values are equivalent, else `false`.
/// @example scss
///     $object: ( 'user': 'fred' );
///     $other: ( 'user': 'fred' );
///     $foo: _is-equal($object, $other);
///     // => true
///
///     // using a customizer callback
///     // todo

@function _is-equal($args...) {
  @return call(get-function("__is-equal"), $args...);
}

/// @alias _is-equal

@function _eq($args...) {
  @return call(get-function("__is-equal"), $args...);
}