How to use the @esfx/equatable.Equaler.create function in @esfx/equatable
To help you get started, we’ve selected a few @esfx/equatable examples, based on popular ways it is used in public projects.
Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
rbuckton / iterable-query / src / lib / fn / startsWith.ts View on Github 
export function startsWith(left: Queryable, right: Queryable, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): boolean {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeQueryable(left, "left");
assert.mustBeQueryable(right, "right");
assert.mustBeEqualer(equaler, "equaler");
const leftIterator = GetIterator(ToIterable(left));
let leftDone = false;
let leftValue: T;
try {
const rightIterator = GetIterator(ToIterable(right));
let rightDone = false;
let rightValue: T;
try {
for (;;) {
({ done: leftDone, value: leftValue } = leftIterator.next());
({ done: rightDone, value: rightValue } = rightIterator.next());
if (rightDone) return true;
if (leftDone || !equaler.equals(leftValue, rightValue)) return false;export async function includesAsync(source: AsyncQueryable, value: T, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): Promise {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeAsyncQueryable(source, "source");
assert.mustBeEqualer(equaler, "equaler");
for await (const element of ToPossiblyAsyncIterable(source)) {
if (equaler.equals(value, element)) {
return true;
}
}
return false;
}export async function endsWithAsync(left: AsyncQueryable, right: AsyncQueryable, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): Promise {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeAsyncQueryable(left, "left");
assert.mustBeAsyncQueryable(right, "right");
assert.mustBeEqualer(equaler, "equaler");
const rightArray = await toArrayAsync(right);
const numElements = rightArray.length;
if (numElements <= 0) {
return true;
}
const leftArray = await toArrayAsync(takeRightAsync(left, numElements));
if (leftArray.length < numElements) {
return false;
}
for (let i = 0; i < numElements; i++) {
if (!equaler.equals(leftArray[i], rightArray[i])) {
return false;
}export async function includesSequenceAsync(left: AsyncQueryable, right: AsyncQueryable, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): Promise {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeAsyncQueryable(left, "source");
assert.mustBeAsyncQueryable(right, "other");
assert.mustBeEqualer(equaler, "equaler");
const rightArray = await toArrayAsync(right);
const numRightElements = rightArray.length;
if (numRightElements <= 0) {
return true;
}
const span: T[] = [];
for await (const leftValue of ToPossiblyAsyncIterable(left)) {
for (;;) {
const rightValue = rightArray[span.length];
if (equaler.equals(leftValue, rightValue)) {
if (span.length + 1 >= numRightElements) {
return true;
}export function includes(source: Queryable, value: T, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): boolean {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeQueryable(source, "source");
assert.mustBeEqualer(equaler, "equaler");
for (const element of ToIterable(source)) {
if (equaler.equals(value, element)) {
return true;
}
}
return false;
}export function endsWith(left: Queryable, right: Queryable, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): boolean {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeQueryable(left, "left");
assert.mustBeQueryable(right, "right");
assert.mustBeEqualer(equaler, "equaler");
const rightArray = toArray(right);
const numElements = rightArray.length;
if (numElements <= 0) {
return true;
}
const leftArray = toArray(takeRight(left, numElements));
if (leftArray.length < numElements) {
return false;
}
for (let i = 0; i < numElements; i++) {
if (!equaler.equals(leftArray[i], rightArray[i])) {
return false;
}export function includesSequence(left: Queryable, right: Queryable, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): boolean {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeQueryable(left, "source");
assert.mustBeQueryable(right, "other");
assert.mustBeEqualer(equaler, "equaler");
const rightArray = toArray(right);
const numRightElements = rightArray.length;
if (numRightElements <= 0) {
return true;
}
const span: T[] = [];
for (const leftValue of ToIterable(left)) {
for (;;) {
const rightValue = rightArray[span.length];
if (equaler.equals(leftValue, rightValue)) {
if (span.length + 1 >= numRightElements) {
return true;
}export function correspondsBy(left: Queryable, right: Queryable, leftKeySelector: (element: T) => K, rightKeySelector: (element: T) => K = leftKeySelector, keyEqualer: EqualityComparison | Equaler = Equaler.defaultEqualer): boolean {
assert.mustBeQueryable(left, "left");
assert.mustBeQueryable(right, "right");
assert.mustBeFunction(leftKeySelector, "leftKeySelector");
assert.mustBeFunction(rightKeySelector, "rightKeySelector");
assert.mustBeObject(keyEqualer, "keyEqualer");
if (typeof keyEqualer === "function") keyEqualer = Equaler.create(keyEqualer);
const leftIterator = GetIterator(ToIterable(left));
let leftDone = false;
let leftValue: T;
try {
const rightIterator = GetIterator(ToIterable(right));
let rightDone = false;
let rightValue: T;
try {
for (;;) {
({ done: leftDone, value: leftValue } = leftIterator.next());
({ done: rightDone, value: rightValue } = rightIterator.next());
if (leftDone && rightDone) return true;
if (Boolean(leftDone) !== Boolean(rightDone) || !keyEqualer.equals(leftKeySelector(leftValue), rightKeySelector(rightValue))) return false;
}
}
finally {export async function startsWithAsync(left: AsyncQueryable, right: AsyncQueryable, equaler: EqualityComparison | Equaler = Equaler.defaultEqualer): Promise {
if (typeof equaler === "function") equaler = Equaler.create(equaler);
assert.mustBeAsyncQueryable(left, "left");
assert.mustBeAsyncQueryable(right, "right");
assert.mustBeEqualer(equaler, "equaler");
const leftIterator = GetAsyncIterator(ToPossiblyAsyncIterable(left));
let leftDone = false;
let leftValue: T;
try {
const rightIterator = GetAsyncIterator(ToPossiblyAsyncIterable(right));
let rightDone = false;
let rightValue: T;
try {
for (;;) {
({ done: leftDone, value: leftValue } = await leftIterator.next());
({ done: rightDone, value: rightValue } = await rightIterator.next());
if (rightDone) return true;
if (leftDone || !equaler.equals(leftValue, rightValue)) return false;export async function correspondsByAsync(left: AsyncQueryable, right: AsyncQueryable, leftKeySelector: (element: T) => K, rightKeySelector: (element: T) => K = leftKeySelector, keyEqualer: EqualityComparison | Equaler = Equaler.defaultEqualer): Promise {
assert.mustBeAsyncQueryable(left, "left");
assert.mustBeAsyncQueryable(right, "right");
assert.mustBeFunction(leftKeySelector, "leftKeySelector");
assert.mustBeFunction(rightKeySelector, "rightKeySelector");
assert.mustBeObject(keyEqualer, "keyEqualer");
if (typeof keyEqualer === "function") keyEqualer = Equaler.create(keyEqualer);
const leftIterator = GetAsyncIterator(ToPossiblyAsyncIterable(left));
let leftDone = false;
let leftValue: T;
try {
const rightIterator = GetAsyncIterator(ToPossiblyAsyncIterable(right));
let rightDone = false;
let rightValue: T;
try {
for (;;) {
({ done: leftDone, value: leftValue } = await leftIterator.next());
({ done: rightDone, value: rightValue } = await rightIterator.next());
if (leftDone && rightDone) return true;
if (Boolean(leftDone) !== Boolean(rightDone) || !keyEqualer.equals(leftKeySelector(leftValue), rightKeySelector(rightValue))) return false;
}
}
finally {@esfx/equatable
A low-level API for defining equality.
