hbecher/sequence-js
1
0
Fork 0
Code Activity

Compare commits

base: hbecher:afa56b7adf2a310cc44e53b5732d235e67200cff
Branches Tags
hbecher:main
..
compare: hbecher:main
Branches Tags
hbecher:main

16 Commits
afa56b7adf ... main

Author SHA1 Message Date
Hervé BECHER
d0164640a1 remove declaration 2026-04-08 22:52:14 +02:00
Hervé BECHER
ae5305f3c6 sync 2026-04-06 18:45:31 +02:00
Hervé BECHER
31c0757780 update deps 2026-04-06 18:39:58 +02:00
Hervé BECHER
696729d2c2 remove Sequences.ofPropertyKeys 2025-11-22 14:09:38 +01:00
Hervé BECHER
bdea643256 properly implement comparer and equality comparer combination 2025-11-22 14:09:37 +01:00
Hervé BECHER
4e5dfd7134 add cartesian product 2025-11-22 14:09:35 +01:00
Hervé BECHER
955acc6c96 add async equality comparer and broaden to comparison or comparer 2025-11-22 14:09:33 +01:00
Hervé BECHER
c7a6d6880c update packages and tsconfig 2025-11-22 14:09:32 +01:00
Hervé BECHER
400644e079 refactor 2025-11-22 14:09:28 +01:00
Hervé BECHER
f6a9dd97ed use consistent wording 2025-11-22 14:09:26 +01:00
Hervé BECHER
806d735c35 sync 2025-11-22 14:09:22 +01:00
Hervé BECHER
637991c394 move identity function to utils 2025-11-22 14:09:19 +01:00
Hervé BECHER
afa4c8a684 improve typing of element finding utils 2025-11-22 14:09:18 +01:00
Hervé BECHER
75219bc716 move BitArray in its namerspace 2025-11-22 14:09:18 +01:00
Hervé BECHER
c98e462142 sync 2025-11-22 14:09:18 +01:00
Hervé BECHER
9af08e71fc sync 2025-11-22 14:09:10 +01:00
26 changed files with 1184 additions and 551 deletions
Expand all files Collapse all files

263
package-lock.json generated
View File

@@ -9,16 +9,15 @@
"version": "1.0.0", "version": "1.0.0",
"license": "ISC", "license": "ISC",
"devDependencies": { "devDependencies": {
"@types/node": "^22.15.21", "@types/node": "^25.5.0",
"esbuild": "^0.25.4",
"tsx": "^4.19.4", "tsx": "^4.19.4",
"typescript": "^5.8.3" "typescript": "^6.0.2"
} }
}, },
"node_modules/@esbuild/aix-ppc64": { "node_modules/@esbuild/aix-ppc64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.7.tgz",
"integrity": "sha512-1VCICWypeQKhVbE9oW/sJaAmjLxhVqacdkvPLEjwlttjfwENRSClS8EjBz0KzRyFSCPDIkuXW34Je/vk7zdB7Q==", "integrity": "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==",
"cpu": [ "cpu": [
"ppc64" "ppc64"
], ],
@@ -33,9 +32,9 @@
} }
}, },
"node_modules/@esbuild/android-arm": { "node_modules/@esbuild/android-arm": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.7.tgz",
"integrity": "sha512-QNdQEps7DfFwE3hXiU4BZeOV68HHzYwGd0Nthhd3uCkkEKK7/R6MTgM0P7H7FAs5pU/DIWsviMmEGxEoxIZ+ZQ==", "integrity": "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==",
"cpu": [ "cpu": [
"arm" "arm"
], ],
@@ -50,9 +49,9 @@
} }
}, },
"node_modules/@esbuild/android-arm64": { "node_modules/@esbuild/android-arm64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.7.tgz",
"integrity": "sha512-bBy69pgfhMGtCnwpC/x5QhfxAz/cBgQ9enbtwjf6V9lnPI/hMyT9iWpR1arm0l3kttTr4L0KSLpKmLp/ilKS9A==", "integrity": "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==",
"cpu": [ "cpu": [
"arm64" "arm64"
], ],
@@ -67,9 +66,9 @@
} }
}, },
"node_modules/@esbuild/android-x64": { "node_modules/@esbuild/android-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.7.tgz",
"integrity": "sha512-TVhdVtQIFuVpIIR282btcGC2oGQoSfZfmBdTip2anCaVYcqWlZXGcdcKIUklfX2wj0JklNYgz39OBqh2cqXvcQ==", "integrity": "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -84,9 +83,9 @@
} }
}, },
"node_modules/@esbuild/darwin-arm64": { "node_modules/@esbuild/darwin-arm64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.7.tgz",
"integrity": "sha512-Y1giCfM4nlHDWEfSckMzeWNdQS31BQGs9/rouw6Ub91tkK79aIMTH3q9xHvzH8d0wDru5Ci0kWB8b3up/nl16g==", "integrity": "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==",
"cpu": [ "cpu": [
"arm64" "arm64"
], ],
@@ -101,9 +100,9 @@
} }
}, },
"node_modules/@esbuild/darwin-x64": { "node_modules/@esbuild/darwin-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.7.tgz",
"integrity": "sha512-CJsry8ZGM5VFVeyUYB3cdKpd/H69PYez4eJh1W/t38vzutdjEjtP7hB6eLKBoOdxcAlCtEYHzQ/PJ/oU9I4u0A==", "integrity": "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -118,9 +117,9 @@
} }
}, },
"node_modules/@esbuild/freebsd-arm64": { "node_modules/@esbuild/freebsd-arm64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.7.tgz",
"integrity": "sha512-yYq+39NlTRzU2XmoPW4l5Ifpl9fqSk0nAJYM/V/WUGPEFfek1epLHJIkTQM6bBs1swApjO5nWgvr843g6TjxuQ==", "integrity": "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==",
"cpu": [ "cpu": [
"arm64" "arm64"
], ],
@@ -135,9 +134,9 @@
} }
}, },
"node_modules/@esbuild/freebsd-x64": { "node_modules/@esbuild/freebsd-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.7.tgz",
"integrity": "sha512-0FgvOJ6UUMflsHSPLzdfDnnBBVoCDtBTVyn/MrWloUNvq/5SFmh13l3dvgRPkDihRxb77Y17MbqbCAa2strMQQ==", "integrity": "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -152,9 +151,9 @@
} }
}, },
"node_modules/@esbuild/linux-arm": { "node_modules/@esbuild/linux-arm": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.7.tgz",
"integrity": "sha512-kro4c0P85GMfFYqW4TWOpvmF8rFShbWGnrLqlzp4X1TNWjRY3JMYUfDCtOxPKOIY8B0WC8HN51hGP4I4hz4AaQ==", "integrity": "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==",
"cpu": [ "cpu": [
"arm" "arm"
], ],
@@ -169,9 +168,9 @@
} }
}, },
"node_modules/@esbuild/linux-arm64": { "node_modules/@esbuild/linux-arm64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.7.tgz",
"integrity": "sha512-+89UsQTfXdmjIvZS6nUnOOLoXnkUTB9hR5QAeLrQdzOSWZvNSAXAtcRDHWtqAUtAmv7ZM1WPOOeSxDzzzMogiQ==", "integrity": "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==",
"cpu": [ "cpu": [
"arm64" "arm64"
], ],
@@ -186,9 +185,9 @@
} }
}, },
"node_modules/@esbuild/linux-ia32": { "node_modules/@esbuild/linux-ia32": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.7.tgz",
"integrity": "sha512-yTEjoapy8UP3rv8dB0ip3AfMpRbyhSN3+hY8mo/i4QXFeDxmiYbEKp3ZRjBKcOP862Ua4b1PDfwlvbuwY7hIGQ==", "integrity": "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==",
"cpu": [ "cpu": [
"ia32" "ia32"
], ],
@@ -203,9 +202,9 @@
} }
}, },
"node_modules/@esbuild/linux-loong64": { "node_modules/@esbuild/linux-loong64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.7.tgz",
"integrity": "sha512-NeqqYkrcGzFwi6CGRGNMOjWGGSYOpqwCjS9fvaUlX5s3zwOtn1qwg1s2iE2svBe4Q/YOG1q6875lcAoQK/F4VA==", "integrity": "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==",
"cpu": [ "cpu": [
"loong64" "loong64"
], ],
@@ -220,9 +219,9 @@
} }
}, },
"node_modules/@esbuild/linux-mips64el": { "node_modules/@esbuild/linux-mips64el": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.7.tgz",
"integrity": "sha512-IcvTlF9dtLrfL/M8WgNI/qJYBENP3ekgsHbYUIzEzq5XJzzVEV/fXY9WFPfEEXmu3ck2qJP8LG/p3Q8f7Zc2Xg==", "integrity": "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==",
"cpu": [ "cpu": [
"mips64el" "mips64el"
], ],
@@ -237,9 +236,9 @@
} }
}, },
"node_modules/@esbuild/linux-ppc64": { "node_modules/@esbuild/linux-ppc64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.7.tgz",
"integrity": "sha512-HOy0aLTJTVtoTeGZh4HSXaO6M95qu4k5lJcH4gxv56iaycfz1S8GO/5Jh6X4Y1YiI0h7cRyLi+HixMR+88swag==", "integrity": "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==",
"cpu": [ "cpu": [
"ppc64" "ppc64"
], ],
@@ -254,9 +253,9 @@
} }
}, },
"node_modules/@esbuild/linux-riscv64": { "node_modules/@esbuild/linux-riscv64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.7.tgz",
"integrity": "sha512-i8JUDAufpz9jOzo4yIShCTcXzS07vEgWzyX3NH2G7LEFVgrLEhjwL3ajFE4fZI3I4ZgiM7JH3GQ7ReObROvSUA==", "integrity": "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==",
"cpu": [ "cpu": [
"riscv64" "riscv64"
], ],
@@ -271,9 +270,9 @@
} }
}, },
"node_modules/@esbuild/linux-s390x": { "node_modules/@esbuild/linux-s390x": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.7.tgz",
"integrity": "sha512-jFnu+6UbLlzIjPQpWCNh5QtrcNfMLjgIavnwPQAfoGx4q17ocOU9MsQ2QVvFxwQoWpZT8DvTLooTvmOQXkO51g==", "integrity": "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==",
"cpu": [ "cpu": [
"s390x" "s390x"
], ],
@@ -288,9 +287,9 @@
} }
}, },
"node_modules/@esbuild/linux-x64": { "node_modules/@esbuild/linux-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.7.tgz",
"integrity": "sha512-6e0cvXwzOnVWJHq+mskP8DNSrKBr1bULBvnFLpc1KY+d+irZSgZ02TGse5FsafKS5jg2e4pbvK6TPXaF/A6+CA==", "integrity": "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -305,9 +304,9 @@
} }
}, },
"node_modules/@esbuild/netbsd-arm64": { "node_modules/@esbuild/netbsd-arm64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.7.tgz",
"integrity": "sha512-vUnkBYxZW4hL/ie91hSqaSNjulOnYXE1VSLusnvHg2u3jewJBz3YzB9+oCw8DABeVqZGg94t9tyZFoHma8gWZQ==", "integrity": "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==",
"cpu": [ "cpu": [
"arm64" "arm64"
], ],
@@ -322,9 +321,9 @@
} }
}, },
"node_modules/@esbuild/netbsd-x64": { "node_modules/@esbuild/netbsd-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.7.tgz",
"integrity": "sha512-XAg8pIQn5CzhOB8odIcAm42QsOfa98SBeKUdo4xa8OvX8LbMZqEtgeWE9P/Wxt7MlG2QqvjGths+nq48TrUiKw==", "integrity": "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -339,9 +338,9 @@
} }
}, },
"node_modules/@esbuild/openbsd-arm64": { "node_modules/@esbuild/openbsd-arm64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.7.tgz",
"integrity": "sha512-Ct2WcFEANlFDtp1nVAXSNBPDxyU+j7+tId//iHXU2f/lN5AmO4zLyhDcpR5Cz1r08mVxzt3Jpyt4PmXQ1O6+7A==", "integrity": "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==",
"cpu": [ "cpu": [
"arm64" "arm64"
], ],
@@ -356,9 +355,9 @@
} }
}, },
"node_modules/@esbuild/openbsd-x64": { "node_modules/@esbuild/openbsd-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.7.tgz",
"integrity": "sha512-xAGGhyOQ9Otm1Xu8NT1ifGLnA6M3sJxZ6ixylb+vIUVzvvd6GOALpwQrYrtlPouMqd/vSbgehz6HaVk4+7Afhw==", "integrity": "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -372,10 +371,27 @@
"node": ">=18" "node": ">=18"
} }
}, },
"node_modules/@esbuild/openharmony-arm64": {
"version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.7.tgz",
"integrity": "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==",
"cpu": [
"arm64"
],
"dev": true,
"license": "MIT",
"optional": true,
"os": [
"openharmony"
],
"engines": {
"node": ">=18"
}
},
"node_modules/@esbuild/sunos-x64": { "node_modules/@esbuild/sunos-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.7.tgz",
"integrity": "sha512-Mw+tzy4pp6wZEK0+Lwr76pWLjrtjmJyUB23tHKqEDP74R3q95luY/bXqXZeYl4NYlvwOqoRKlInQialgCKy67Q==", "integrity": "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -390,9 +406,9 @@
} }
}, },
"node_modules/@esbuild/win32-arm64": { "node_modules/@esbuild/win32-arm64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.7.tgz",
"integrity": "sha512-AVUP428VQTSddguz9dO9ngb+E5aScyg7nOeJDrF1HPYu555gmza3bDGMPhmVXL8svDSoqPCsCPjb265yG/kLKQ==", "integrity": "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==",
"cpu": [ "cpu": [
"arm64" "arm64"
], ],
@@ -407,9 +423,9 @@
} }
}, },
"node_modules/@esbuild/win32-ia32": { "node_modules/@esbuild/win32-ia32": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.7.tgz",
"integrity": "sha512-i1sW+1i+oWvQzSgfRcxxG2k4I9n3O9NRqy8U+uugaT2Dy7kLO9Y7wI72haOahxceMX8hZAzgGou1FhndRldxRg==", "integrity": "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==",
"cpu": [ "cpu": [
"ia32" "ia32"
], ],
@@ -424,9 +440,9 @@
} }
}, },
"node_modules/@esbuild/win32-x64": { "node_modules/@esbuild/win32-x64": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.4.tgz", "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.7.tgz",
"integrity": "sha512-nOT2vZNw6hJ+z43oP1SPea/G/6AbN6X+bGNhNuq8NtRHy4wsMhw765IKLNmnjek7GvjWBYQ8Q5VBoYTFg9y1UQ==", "integrity": "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==",
"cpu": [ "cpu": [
"x64" "x64"
], ],
@@ -441,19 +457,19 @@
} }
}, },
"node_modules/@types/node": { "node_modules/@types/node": {
"version": "22.15.21", "version": "25.5.2",
"resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.21.tgz", "resolved": "https://registry.npmjs.org/@types/node/-/node-25.5.2.tgz",
"integrity": "sha512-EV/37Td6c+MgKAbkcLG6vqZ2zEYHD7bvSrzqqs2RIhbA6w3x+Dqz8MZM3sP6kGTeLrdoOgKZe+Xja7tUB2DNkQ==", "integrity": "sha512-tO4ZIRKNC+MDWV4qKVZe3Ql/woTnmHDr5JD8UI5hn2pwBrHEwOEMZK7WlNb5RKB6EoJ02gwmQS9OrjuFnZYdpg==",
"dev": true, "dev": true,
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
"undici-types": "~6.21.0" "undici-types": "~7.18.0"
} }
}, },
"node_modules/esbuild": { "node_modules/esbuild": {
"version": "0.25.4", "version": "0.27.7",
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz", "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz",
"integrity": "sha512-8pgjLUcUjcgDg+2Q4NYXnPbo/vncAY4UmyaCm0jZevERqCHZIaWwdJHkf8XQtu4AxSKCdvrUbT0XUr1IdZzI8Q==", "integrity": "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==",
"dev": true, "dev": true,
"hasInstallScript": true, "hasInstallScript": true,
"license": "MIT", "license": "MIT",
@@ -464,31 +480,32 @@
"node": ">=18" "node": ">=18"
}, },
"optionalDependencies": { "optionalDependencies": {
"@esbuild/aix-ppc64": "0.25.4", "@esbuild/aix-ppc64": "0.27.7",
"@esbuild/android-arm": "0.25.4", "@esbuild/android-arm": "0.27.7",
"@esbuild/android-arm64": "0.25.4", "@esbuild/android-arm64": "0.27.7",
"@esbuild/android-x64": "0.25.4", "@esbuild/android-x64": "0.27.7",
"@esbuild/darwin-arm64": "0.25.4", "@esbuild/darwin-arm64": "0.27.7",
"@esbuild/darwin-x64": "0.25.4", "@esbuild/darwin-x64": "0.27.7",
"@esbuild/freebsd-arm64": "0.25.4", "@esbuild/freebsd-arm64": "0.27.7",
"@esbuild/freebsd-x64": "0.25.4", "@esbuild/freebsd-x64": "0.27.7",
"@esbuild/linux-arm": "0.25.4", "@esbuild/linux-arm": "0.27.7",
"@esbuild/linux-arm64": "0.25.4", "@esbuild/linux-arm64": "0.27.7",
"@esbuild/linux-ia32": "0.25.4", "@esbuild/linux-ia32": "0.27.7",
"@esbuild/linux-loong64": "0.25.4", "@esbuild/linux-loong64": "0.27.7",
"@esbuild/linux-mips64el": "0.25.4", "@esbuild/linux-mips64el": "0.27.7",
"@esbuild/linux-ppc64": "0.25.4", "@esbuild/linux-ppc64": "0.27.7",
"@esbuild/linux-riscv64": "0.25.4", "@esbuild/linux-riscv64": "0.27.7",
"@esbuild/linux-s390x": "0.25.4", "@esbuild/linux-s390x": "0.27.7",
"@esbuild/linux-x64": "0.25.4", "@esbuild/linux-x64": "0.27.7",
"@esbuild/netbsd-arm64": "0.25.4", "@esbuild/netbsd-arm64": "0.27.7",
"@esbuild/netbsd-x64": "0.25.4", "@esbuild/netbsd-x64": "0.27.7",
"@esbuild/openbsd-arm64": "0.25.4", "@esbuild/openbsd-arm64": "0.27.7",
"@esbuild/openbsd-x64": "0.25.4", "@esbuild/openbsd-x64": "0.27.7",
"@esbuild/sunos-x64": "0.25.4", "@esbuild/openharmony-arm64": "0.27.7",
"@esbuild/win32-arm64": "0.25.4", "@esbuild/sunos-x64": "0.27.7",
"@esbuild/win32-ia32": "0.25.4", "@esbuild/win32-arm64": "0.27.7",
"@esbuild/win32-x64": "0.25.4" "@esbuild/win32-ia32": "0.27.7",
"@esbuild/win32-x64": "0.27.7"
} }
}, },
"node_modules/fsevents": { "node_modules/fsevents": {
@@ -507,9 +524,9 @@
} }
}, },
"node_modules/get-tsconfig": { "node_modules/get-tsconfig": {
"version": "4.7.6", "version": "4.13.7",
"resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.7.6.tgz", "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.13.7.tgz",
"integrity": "sha512-ZAqrLlu18NbDdRaHq+AKXzAmqIUPswPWKUchfytdAjiRFnCe5ojG2bstg6mRiZabkKfCoL/e98pbBELIV/YCeA==", "integrity": "sha512-7tN6rFgBlMgpBML5j8typ92BKFi2sFQvIdpAqLA2beia5avZDrMs0FLZiM5etShWq5irVyGcGMEA1jcDaK7A/Q==",
"dev": true, "dev": true,
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
@@ -530,13 +547,13 @@
} }
}, },
"node_modules/tsx": { "node_modules/tsx": {
"version": "4.19.4", "version": "4.21.0",
"resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.4.tgz", "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.21.0.tgz",
"integrity": "sha512-gK5GVzDkJK1SI1zwHf32Mqxf2tSJkNx+eYcNly5+nHvWqXUJYUkWBQtKauoESz3ymezAI++ZwT855x5p5eop+Q==", "integrity": "sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==",
"dev": true, "dev": true,
"license": "MIT", "license": "MIT",
"dependencies": { "dependencies": {
"esbuild": "~0.25.0", "esbuild": "~0.27.0",
"get-tsconfig": "^4.7.5" "get-tsconfig": "^4.7.5"
}, },
"bin": { "bin": {
@@ -550,9 +567,9 @@
} }
}, },
"node_modules/typescript": { "node_modules/typescript": {
"version": "5.8.3", "version": "6.0.2",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.2.tgz",
"integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", "integrity": "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==",
"dev": true, "dev": true,
"license": "Apache-2.0", "license": "Apache-2.0",
"bin": { "bin": {
@@ -564,9 +581,9 @@
} }
}, },
"node_modules/undici-types": { "node_modules/undici-types": {
"version": "6.21.0", "version": "7.18.2",
"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
"integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
"dev": true, "dev": true,
"license": "MIT" "license": "MIT"
} }

18
package.json
View File

@@ -6,15 +6,23 @@
"type": "module", "type": "module",
"scripts": { "scripts": {
"start": "tsx src/index.ts", "start": "tsx src/index.ts",
"test": "tsx src/test.ts", "test": "tsx src/test.ts"
"build": "tsc && esbuild --bundle --minify --sourcemap --platform=node --target=node20 --outdir=build src/index.ts"
}, },
"author": "Hervé BECHER", "author": "Hervé BECHER",
"license": "ISC", "license": "ISC",
"devDependencies": { "devDependencies": {
"@types/node": "^22.15.21", "@types/node": "^25.5.0",
"esbuild": "^0.25.4",
"tsx": "^4.19.4", "tsx": "^4.19.4",
"typescript": "^5.8.3" "typescript": "^6.0.2"
},
"exports": {
".": {
"import": "./src/index.ts",
"types": "./src/index.ts"
},
"./*": {
"import": "./src/*.ts",
"types": "./src/*.ts"
}
} }
} }

266
src/async/impl.ts
View File

@@ -1,17 +1,17 @@
import { Collector } from "../collector/types.js"; import { Collector } from "../collector/types.js";
import { asAsyncComparer, combineNullableAsyncComparers, createAsyncComparerUsing, defaultAsyncComparer } from "../comparer/async.js"; import { asAsyncComparer, combineAsyncComparers, createAsyncComparerUsing, defaultAsyncComparer } from "../comparer/async.js";
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js"; import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
import { strictEquals, identity } from "../equality-comparer/index.js"; import { asAsyncEqualityComparer, defaultAsyncEqualityComparer } from "../equality-comparer/async.js";
import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js"; import { AsyncEqualityComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { createAsyncEqualityMap } from "../equality-map.js"; import { createAsyncEqualityMap } from "../equality-map/index.js";
import { createAsyncEqualitySet } from "../equality-set.js"; import { createAsyncEqualitySet } from "../equality-set/index.js";
import { createQueue } from "../queue.js"; import { createQueue } from "../queue.js";
import { getRandomElementAsync } from "../random/index.js"; import { getRandomElementAsync } from "../random/index.js";
import { AsyncRandomOptions } from "../random/types.js"; import { AsyncRandomOptions } from "../random/types.js";
import { selectionSorter } from "../sorting.js"; import { selectionSorter } from "../sorting.js";
import { Sequence } from "../sync/types.js"; import { Sequence } from "../sync/types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybePromise, MaybeAsyncIterable, MaybeAsyncTypePredicate } from "../types.js"; import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybePromiseLike, MaybeAsyncGenerator, MaybePromise, MaybeAsyncIterable, MaybeAsyncTypePredicate } from "../types.js";
import { asAsyncIterable, FindElementResult } from "../utils.js"; import { asAsyncIterable, FindElementResult, identity } from "../utils.js";
import { array, empty, wrap } from "./index.js"; import { array, empty, wrap } from "./index.js";
import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js"; import { AsyncSequence, AsyncSequencePipeline, GroupedAsyncSequence, OrderedAsyncSequence } from "./types.js";
@@ -42,31 +42,29 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new WhereAsyncSequence<TElement, any>(this, predicate); return new WhereAsyncSequence<TElement, any>(this, predicate);
} }
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>; groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>; groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) { groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return new GroupByAsyncSequence<any, any, any>(this, keySelector, elementSelector, keyComparer); return new GroupByAsyncSequence<any, any, any>(this, keySelector, elementSelector, keyComparer);
} }
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<[TElement, TOther]>; join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>; join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) { join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return new JoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer); return new JoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>; groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>; groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) { groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return new GroupJoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer); return new GroupJoinAsyncSequence<any, any, any, any>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
async contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>) { async contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
if (!equater) { equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
equater = strictEquals;
}
for await (const element of this) { for await (const element of this) {
if (await equater(element, obj)) { if (await equater.equals(element, obj)) {
return true; return true;
} }
} }
@@ -74,7 +72,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return false; return false;
} }
async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>) { async sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>) {
if (this === sequence) { if (this === sequence) {
return true; return true;
} }
@@ -88,9 +86,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return false; return false;
} }
if (!equater) { equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
equater = strictEquals;
}
const thisIterator = this.iterator(); const thisIterator = this.iterator();
const thatIterator = that.iterator(); const thatIterator = that.iterator();
@@ -107,7 +103,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return false; return false;
} }
if (!await equater(thisNext.value, thatNext.value)) { if (!await equater.equals(thisNext.value, thatNext.value)) {
return false; return false;
} }
} }
@@ -121,7 +117,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new PrependAsyncSequence<TElement>(this, obj); return new PrependAsyncSequence<TElement>(this, obj);
} }
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> { remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
return new RemoveAsyncSequence<TElement>(this, obj, all, equater); return new RemoveAsyncSequence<TElement>(this, obj, all, equater);
} }
@@ -216,34 +212,36 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
} }
async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> { async #tryGetLast(predicate?: MaybeAsyncAnyPredicate<TElement>): Promise<FindElementResult<TElement>> {
let found = false; let result: FindElementResult<TElement> = {
let result: TElement | undefined = undefined; found: false
};
if (predicate) { if (predicate) {
for await (const element of this) { for await (const element of this) {
if (await predicate(element)) { if (await predicate(element)) {
found = true; result = {
result = element; found: true,
element
};
} }
} }
} else { } else {
for await (const element of this) { for await (const element of this) {
found = true; result = {
result = element; found: true,
element
};
} }
} }
return { return result;
found,
element: result
} as FindElementResult<TElement>;
} }
async last(predicate?: MaybeAsyncAnyPredicate<TElement>) { async last(predicate?: MaybeAsyncAnyPredicate<TElement>) {
const result = await this.#tryGetLast(predicate); const result = await this.#tryGetLast(predicate);
if (result.found) { if (result.found) {
return result.element!; return result.element;
} }
throw new Error("No element was found."); throw new Error("No element was found.");
@@ -306,7 +304,7 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
async single(predicate?: MaybeAsyncAnyPredicate<TElement>) { async single(predicate?: MaybeAsyncAnyPredicate<TElement>) {
const result = await this.#tryGetSingle(predicate); const result = await this.#tryGetSingle(predicate);
if (result.found == true) { if (result.found) {
return result.element; return result.element;
} }
@@ -516,27 +514,27 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer); return new OrderByAsyncSequence<TElement, TBy>(this, true, selector, comparer);
} }
partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>> { partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<AsyncSequence<TElement>> {
return new PartitionAsyncSequence<TElement>(this, equater); return new PartitionAsyncSequence<TElement>(this, equater);
} }
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>> { partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<AsyncSequence<TElement>> {
return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater); return new PartitionByAsyncSequence<TElement, TBy>(this, selector, equater);
} }
distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> { distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
return new DistinctAsyncSequence<TElement>(this, equater); return new DistinctAsyncSequence<TElement>(this, equater);
} }
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> { distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater); return new DistinctByAsyncSequence<TElement, TBy>(this, selector, equater);
} }
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement> { union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement> {
return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater); return new UnionAsyncSequence<TElement>(this, wrap(sequence), equater);
} }
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement> { unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement> {
return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater); return new UnionByAsyncSequence<TElement, TBy>(this, wrap(sequence), selector, equater);
} }
@@ -666,6 +664,10 @@ export abstract class BaseAsyncSequence<TElement> extends AsyncSequenceMarker im
return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence)); return new ZippedAsyncSequence<TElement, TOther>(this, wrap(sequence));
} }
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
return new CartesianProductAsyncSequence<TElement, TOther>(this, wrap(sequence));
}
indexed(): AsyncSequence<[number, TElement]> { indexed(): AsyncSequence<[number, TElement]> {
return new IndexedAsyncSequence<TElement>(this); return new IndexedAsyncSequence<TElement>(this);
} }
@@ -811,29 +813,29 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.where(predicate); return this.#sequence.where(predicate);
} }
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>; groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>; groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) { groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer); return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
} }
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<[TElement, TOther]>; join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>; join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) { join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer); return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>; groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey> | undefined): AsyncSequence<TResult>; groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined): AsyncSequence<TResult>;
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) { groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer); return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> { contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
return this.#sequence.contains(obj, equater); return this.#sequence.contains(obj, equater);
} }
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): Promise<boolean> { sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): Promise<boolean> {
return this.#sequence.sequenceEquals(sequence, equater); return this.#sequence.sequenceEquals(sequence, equater);
} }
@@ -845,7 +847,7 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.prepend(obj); return this.#sequence.prepend(obj);
} }
remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> { remove(obj: TElement, all?: boolean | undefined, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.remove(obj, all, equater); return this.#sequence.remove(obj, all, equater);
} }
@@ -916,59 +918,59 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.boundsBy(selector, comparer); return this.#sequence.boundsBy(selector, comparer);
} }
order(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> { order(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): OrderedAsyncSequence<TElement> {
return this.#sequence.order(comparer); return this.#sequence.order(comparer);
} }
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> { orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): OrderedAsyncSequence<TElement> {
return this.#sequence.orderBy(selector, comparer); return this.#sequence.orderBy(selector, comparer);
} }
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> { orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement> | undefined): OrderedAsyncSequence<TElement> {
return this.#sequence.orderDescending(comparer); return this.#sequence.orderDescending(comparer);
} }
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> { orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy> | undefined): OrderedAsyncSequence<TElement> {
return this.#sequence.orderByDescending(selector, comparer); return this.#sequence.orderByDescending(selector, comparer);
} }
partition(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> { partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<AsyncSequence<TElement>> {
return this.#sequence.partition(equater); return this.#sequence.partition(equater);
} }
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> { partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<AsyncSequence<TElement>> {
return this.#sequence.partitionBy(selector, equater); return this.#sequence.partitionBy(selector, equater);
} }
distinct(equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> { distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.distinct(equater); return this.#sequence.distinct(equater);
} }
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> { distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.distinctBy(selector, equater); return this.#sequence.distinctBy(selector, equater);
} }
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> { union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.union(wrap(sequence), equater); return this.#sequence.union(wrap(sequence), equater);
} }
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> { unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.unionBy(wrap(sequence), selector, equater); return this.#sequence.unionBy(wrap(sequence), selector, equater);
} }
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> { except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.except(wrap(sequence), equater); return this.#sequence.except(wrap(sequence), equater);
} }
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> { exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.exceptBy(wrap(sequence), selector, equater); return this.#sequence.exceptBy(wrap(sequence), selector, equater);
} }
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement> | undefined): AsyncSequence<TElement> { intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement> | undefined): AsyncSequence<TElement> {
return this.#sequence.intersect(wrap(sequence), equater); return this.#sequence.intersect(wrap(sequence), equater);
} }
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy> | undefined): AsyncSequence<TElement> { intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined): AsyncSequence<TElement> {
return this.#sequence.intersectBy(wrap(sequence), selector, equater); return this.#sequence.intersectBy(wrap(sequence), selector, equater);
} }
@@ -1024,6 +1026,10 @@ export class DelegatedAsyncSequence<TElement> extends AsyncSequenceMarker implem
return this.#sequence.zip(wrap(sequence)); return this.#sequence.zip(wrap(sequence));
} }
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]> {
return this.#sequence.cartesianProduct(wrap(sequence));
}
indexed(): AsyncSequence<[number, TElement]> { indexed(): AsyncSequence<[number, TElement]> {
return this.#sequence.indexed(); return this.#sequence.indexed();
} }
@@ -1235,6 +1241,20 @@ export class WrappedObjectAsync<T> extends BaseAsyncSequence<T> {
} }
} }
export class WrappedPromise<T> extends BaseAsyncSequence<T> {
readonly #promise: Promise<MaybeAsyncIterable<T>>;
constructor(promise: Promise<MaybeAsyncIterable<T>>) {
super();
this.#promise = promise;
}
override async *iterator() {
yield* await this.#promise;
}
}
export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> { export class WrappedArrayAsync<T> extends BaseAsyncSequence<T> {
readonly #array: ReadonlyArray<MaybePromiseLike<T>>; readonly #array: ReadonlyArray<MaybePromiseLike<T>>;
@@ -1381,9 +1401,9 @@ export class ConcatAsyncSequence<T> extends BaseAsyncSequence<T> {
class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> { class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #sequence: AsyncSequence<T>; readonly #sequence: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) { constructor(sequence: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
@@ -1404,9 +1424,9 @@ class DistinctAsyncSequence<T> extends BaseAsyncSequence<T> {
class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> { class DistinctByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #sequence: AsyncSequence<T>; readonly #sequence: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>; readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) { constructor(sequence: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
@@ -1687,7 +1707,7 @@ class TakeAsyncSequence<T> extends BaseAsyncSequence<T> {
return; return;
} }
yield next.value as T; yield next.value;
i--; i--;
} }
} }
@@ -1707,13 +1727,13 @@ class OrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
class ThenOrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> { class ThenOrderAsyncSequence<T> extends BaseOrderedAsyncSequence<T> {
constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparisonOrComparer<T>) { constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, sorter?: MaybeAsyncComparisonOrComparer<T>) {
super(sequence, combineNullableAsyncComparers([sequence.comparer, sorter]), descending); super(sequence, combineAsyncComparers([sequence.comparer, sorter]), descending);
} }
} }
class ThenOrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> { class ThenOrderByAsyncSequence<T, U> extends BaseOrderedAsyncSequence<T> {
constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparisonOrComparer<U>) { constructor(sequence: OrderedAsyncSequence<T>, descending: boolean, selector: MaybeAsyncConverter<T, U>, sorter?: MaybeAsyncComparisonOrComparer<U>) {
super(sequence, combineNullableAsyncComparers([sequence.comparer, createAsyncComparerUsing(selector, sorter)]), descending); super(sequence, combineAsyncComparers([sequence.comparer, createAsyncComparerUsing(selector, sorter)]), descending);
} }
} }
@@ -1823,12 +1843,52 @@ class ZippedAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
} }
} }
export class CartesianProductAsyncSequence<T, U> extends BaseAsyncSequence<[T, U]> {
readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<U>;
constructor(first: AsyncSequence<T>, second: AsyncSequence<U>) {
super();
this.#first = first;
this.#second = second;
}
override async nonEnumeratedCount() {
const n1 = await this.#first.nonEnumeratedCount();
if (n1 < 0) {
return -1;
}
const n2 = await this.#second.nonEnumeratedCount();
if (n2 < 0) {
return -1;
}
return n1 * n2;
}
override async maxCount() {
return await this.#first.maxCount() * await this.#second.maxCount();
}
override async *iterator() {
for await (const firstObj of this.#first) {
for await (const secondObj of this.#second) {
yield [firstObj, secondObj] as [T, U];
}
}
}
}
class UnionAsyncSequence<T> extends BaseAsyncSequence<T> { class UnionAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>; readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>; readonly #second: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) { constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super(); super();
this.#first = first; this.#first = first;
@@ -1859,9 +1919,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>; readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>; readonly #second: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>; readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) { constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super(); super();
this.#first = first; this.#first = first;
@@ -1892,9 +1952,9 @@ class UnionByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> { class ExceptAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>; readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>; readonly #second: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) { constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super(); super();
this.#first = first; this.#first = first;
@@ -1923,9 +1983,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>; readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>; readonly #second: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>; readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) { constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super(); super();
this.#first = first; this.#first = first;
@@ -1954,9 +2014,9 @@ class ExceptByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> { class IntersectAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>; readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>; readonly #second: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparison<T>) { constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super(); super();
this.#first = first; this.#first = first;
@@ -1985,9 +2045,9 @@ class IntersectByAsyncSequence<T, U> extends BaseAsyncSequence<T> {
readonly #first: AsyncSequence<T>; readonly #first: AsyncSequence<T>;
readonly #second: AsyncSequence<T>; readonly #second: AsyncSequence<T>;
readonly #selector: MaybeAsyncConverter<T, U>; readonly #selector: MaybeAsyncConverter<T, U>;
readonly #equater: MaybeAsyncEqualityComparison<U> | undefined; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<U> | undefined;
constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparison<U>) { constructor(first: AsyncSequence<T>, second: AsyncSequence<T>, selector: MaybeAsyncConverter<T, U>, equater?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2039,9 +2099,9 @@ class GroupByAsyncSequence<TElement, TKey, TResult> extends BaseAsyncSequence<Gr
readonly #sequence: AsyncSequence<TElement>; readonly #sequence: AsyncSequence<TElement>;
readonly #keySelector: MaybeAsyncConverter<TElement, TKey>; readonly #keySelector: MaybeAsyncConverter<TElement, TKey>;
readonly #elementSelector: MaybeAsyncConverter<TElement, TResult>; readonly #elementSelector: MaybeAsyncConverter<TElement, TResult>;
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey> | undefined; readonly #keyComparer: MaybeAsyncEqualityComparisonOrComparer<TKey> | undefined;
constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) { constructor(sequence: AsyncSequence<TElement>, keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
@@ -2112,9 +2172,9 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>; readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>; readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, TInner, TResult>; readonly #resultSelector: MaybeAsyncBiConverter<TOuter, TInner, TResult>;
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>; readonly #keyComparer: AsyncEqualityComparer<TKey>;
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) { constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, TInner, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2122,7 +2182,7 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
this.#firstKeySelector = firstKeySelector; this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector; this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? identity as MaybeAsyncBiConverter<TOuter, TInner, TResult>; this.#resultSelector = resultSelector ?? identity as MaybeAsyncBiConverter<TOuter, TInner, TResult>;
this.#keyComparer = keyComparer ?? strictEquals; this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
} }
override async *iterator() { override async *iterator() {
@@ -2132,7 +2192,7 @@ class JoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSequence
for await (const secondObj of this.#second) { for await (const secondObj of this.#second) {
const secondKey = await this.#secondKeySelector(secondObj); const secondKey = await this.#secondKeySelector(secondObj);
if (await this.#keyComparer(firstKey, secondKey)) { if (await this.#keyComparer.equals(firstKey, secondKey)) {
yield await this.#resultSelector(firstObj, secondObj); yield await this.#resultSelector(firstObj, secondObj);
} }
} }
@@ -2146,9 +2206,9 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>; readonly #firstKeySelector: MaybeAsyncConverter<TOuter, TKey>;
readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>; readonly #secondKeySelector: MaybeAsyncConverter<TInner, TKey>;
readonly #resultSelector: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>; readonly #resultSelector: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
readonly #keyComparer: MaybeAsyncEqualityComparison<TKey>; readonly #keyComparer: AsyncEqualityComparer<TKey>;
constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>) { constructor(first: AsyncSequence<TOuter>, second: AsyncSequence<TInner>, firstKeySelector: MaybeAsyncConverter<TOuter, TKey>, secondKeySelector: MaybeAsyncConverter<TInner, TKey>, resultSelector?: MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2156,7 +2216,7 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
this.#firstKeySelector = firstKeySelector; this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector; this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>; this.#resultSelector = resultSelector ?? GroupJoinAsyncSequence.#defaultResultSelector as MaybeAsyncBiConverter<TOuter, MaybeAsyncIterable<TInner>, TResult>;
this.#keyComparer = keyComparer ?? strictEquals; this.#keyComparer = keyComparer ? asAsyncEqualityComparer(keyComparer) : defaultAsyncEqualityComparer;
} }
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncSequence<TInner>) { static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: AsyncSequence<TInner>) {
@@ -2171,7 +2231,7 @@ class GroupJoinAsyncSequence<TOuter, TInner, TKey, TResult> extends BaseAsyncSeq
for await (const secondObj of this.#second) { for await (const secondObj of this.#second) {
const secondKey = await this.#secondKeySelector(secondObj); const secondKey = await this.#secondKeySelector(secondObj);
if (await this.#keyComparer(firstKey, secondKey)) { if (await this.#keyComparer.equals(firstKey, secondKey)) {
secondObjs.push(secondObj); secondObjs.push(secondObj);
} }
} }
@@ -2185,22 +2245,22 @@ class RemoveAsyncSequence<T> extends BaseAsyncSequence<T> {
readonly #sequence: AsyncSequence<T>; readonly #sequence: AsyncSequence<T>;
readonly #obj: T; readonly #obj: T;
readonly #all: boolean; readonly #all: boolean;
readonly #equater: MaybeAsyncEqualityComparison<T>; readonly #equater: AsyncEqualityComparer<T>;
constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEqualityComparison<T>) { constructor(sequence: AsyncSequence<T>, obj: T, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<T>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
this.#obj = obj; this.#obj = obj;
this.#all = all ?? false; this.#all = all ?? false;
this.#equater = equater ?? strictEquals; this.#equater = equater ? asAsyncEqualityComparer(equater) : defaultAsyncEqualityComparer;
} }
override async *iterator() { override async *iterator() {
let gotOne = false; let gotOne = false;
for await (const obj of this.#sequence) { for await (const obj of this.#sequence) {
if (await this.#equater(this.#obj, obj)) { if (await this.#equater.equals(this.#obj, obj)) {
if (this.#all) { if (this.#all) {
continue; continue;
} }
@@ -2244,13 +2304,13 @@ class CacheAsyncSequence<T> extends BaseAsyncSequence<T> {
class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> { class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
readonly #sequence: AsyncSequence<T>; readonly #sequence: AsyncSequence<T>;
readonly #equater: MaybeAsyncEqualityComparison<T>; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined;
constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparison<T> | undefined) { constructor(sequence: AsyncSequence<T>, equater: MaybeAsyncEqualityComparisonOrComparer<T> | undefined) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
this.#equater = equater ?? strictEquals; this.#equater = equater;
} }
override async *iterator() { override async *iterator() {
@@ -2275,14 +2335,14 @@ class PartitionAsyncSequence<T> extends BaseAsyncSequence<AsyncSequence<T>> {
class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> { class PartitionByAsyncSequence<TElement, TBy> extends BaseAsyncSequence<AsyncSequence<TElement>> {
readonly #sequence: AsyncSequence<TElement>; readonly #sequence: AsyncSequence<TElement>;
readonly #selector: MaybeAsyncConverter<TElement, TBy>; readonly #selector: MaybeAsyncConverter<TElement, TBy>;
readonly #equater: MaybeAsyncEqualityComparison<TBy>; readonly #equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined;
constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparison<TBy> | undefined) { constructor(sequence: AsyncSequence<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater: MaybeAsyncEqualityComparisonOrComparer<TBy> | undefined) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
this.#selector = selector; this.#selector = selector;
this.#equater = equater ?? strictEquals; this.#equater = equater;
} }
override async *iterator() { override async *iterator() {

6
src/async/index.ts
View File

@@ -2,13 +2,17 @@ import { wrap as wrapSync } from "../sync/index.js";
import { Sequence } from "../sync/types.js"; import { Sequence } from "../sync/types.js";
import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybePromiseLike } from "../types.js"; import { MaybeAsyncGenerator, MaybeAsyncIterable, MaybePromiseLike } from "../types.js";
import { isAsyncIterable } from "../utils.js"; import { isAsyncIterable } from "../utils.js";
import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence } from "./impl.js"; import { WrappedSequence, WrappedAsyncIterable, WrappedObjectAsync, WrappedArrayAsync, WrappedArrayLikeAsync, FunctionAsyncSequence, GeneratorAsyncSequence, RangeAsyncSequence, RepeatForeverAsyncSequence, RepeatAsyncSequence, AsyncSequenceMarker, EMPTY, ConcatAsyncSequence, WrappedPromise } from "./impl.js";
import { AsyncSequence } from "./types.js"; import { AsyncSequence } from "./types.js";
export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> { export function asAsync<T>(sequence: Sequence<MaybePromiseLike<T>>): AsyncSequence<T> {
return new WrappedSequence(sequence); return new WrappedSequence(sequence);
} }
export function wrapPromise<T>(promise: Promise<MaybeAsyncIterable<T>>): AsyncSequence<T> {
return new WrappedPromise(promise);
}
export function wrap<T>(iterable: MaybeAsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> { export function wrap<T>(iterable: MaybeAsyncIterable<MaybePromiseLike<T>>): AsyncSequence<T> {
if (isAsyncSequence<T>(iterable)) { if (isAsyncSequence<T>(iterable)) {
return iterable; return iterable;

50
src/async/types.ts
View File

@@ -1,10 +1,11 @@
import { Collector } from "../collector/types.js"; import { Collector } from "../collector/types.js";
import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js"; import { MaybeAsyncComparisonOrComparer, AsyncComparer } from "../comparer/types.js";
import { MaybeAsyncEqualityComparison } from "../equality-comparer/types.js"; import { MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { AsyncRandomOptions } from "../random/types.js"; import { AsyncRandomOptions } from "../random/types.js";
import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybeAsyncFunction, MaybePromise, MaybeAsyncIterable } from "../types.js"; import { MaybeAsyncAnyPredicate, MaybeAsyncConverter, MaybeAsyncBiConverter, MaybeAsyncAccumulator, MaybeAsyncAction, MaybeAsyncFunction, MaybePromise, MaybeAsyncIterable } from "../types.js";
export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>; export type AsyncSequencePipeline<TElement, TResult> = MaybeAsyncFunction<(sequence: AsyncSequence<TElement>) => TResult>;
export type AsyncSequenceElement<TAsyncSequence extends AsyncSequence<any>> = TAsyncSequence extends AsyncSequence<infer TElement> ? TElement : never;
export interface AsyncSequence<TElement> extends AsyncIterable<TElement> { export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
iterator(): AsyncIterator<TElement>; iterator(): AsyncIterator<TElement>;
@@ -22,24 +23,24 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
where<TFiltered extends TElement>(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TFiltered>; where<TFiltered extends TElement>(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TFiltered>;
where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>; where(predicate: MaybeAsyncAnyPredicate<TElement>): AsyncSequence<TElement>;
groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>; groupBy<TKey>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>; groupBy<TKey, TResult>(keySelector: MaybeAsyncConverter<TElement, TKey>, elementSelector: MaybeAsyncConverter<TElement, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TKey, TResult>>;
join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<[TElement, TOther]>; join<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>; join<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, TOther, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<TResult>;
groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>; groupJoin<TOther, TKey>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector?: undefined, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<GroupedAsyncSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparison<TKey>): AsyncSequence<TResult>; groupJoin<TOther, TKey, TResult>(sequence: MaybeAsyncIterable<TOther>, firstKeySelector: MaybeAsyncConverter<TElement, TKey>, secondKeySelector: MaybeAsyncConverter<TOther, TKey>, resultSelector: MaybeAsyncBiConverter<TElement, MaybeAsyncIterable<TOther>, TResult>, keyComparer?: MaybeAsyncEqualityComparisonOrComparer<TKey>): AsyncSequence<TResult>;
contains(obj: TElement, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>; contains(obj: TElement, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): Promise<boolean>;
sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): Promise<boolean>; sequenceEquals(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): Promise<boolean>;
append(obj: TElement): AsyncSequence<TElement>; append(obj: TElement): AsyncSequence<TElement>;
prepend(obj: TElement): AsyncSequence<TElement>; prepend(obj: TElement): AsyncSequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>; remove(obj: TElement, all?: boolean, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>; concat(...sequences: MaybeAsyncIterable<TElement>[]): AsyncSequence<TElement>;
@@ -68,26 +69,26 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>): Promise<[min: TElement, max: TElement]>; bounds(comparer?: MaybeAsyncComparisonOrComparer<TElement>): Promise<[min: TElement, max: TElement]>;
boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): Promise<[min: TElement, max: TElement]>; boundsBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): Promise<[min: TElement, max: TElement]>;
order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>; order(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>; orderBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): AsyncSequence<TElement>; orderDescending(comparer?: MaybeAsyncComparisonOrComparer<TElement>): OrderedAsyncSequence<TElement>;
orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): AsyncSequence<TElement>; orderByDescending<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, comparer?: MaybeAsyncComparisonOrComparer<TBy>): OrderedAsyncSequence<TElement>;
partition(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<AsyncSequence<TElement>>; partition(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<AsyncSequence<TElement>>;
partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<AsyncSequence<TElement>>; partitionBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<AsyncSequence<TElement>>;
distinct(equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>; distinct(equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>; distinctBy<TBy>(selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>; union(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>; unionBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>; except(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>; exceptBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparison<TElement>): AsyncSequence<TElement>; intersect(sequence: MaybeAsyncIterable<TElement>, equater?: MaybeAsyncEqualityComparisonOrComparer<TElement>): AsyncSequence<TElement>;
intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparison<TBy>): AsyncSequence<TElement>; intersectBy<TBy>(sequence: MaybeAsyncIterable<TElement>, selector: MaybeAsyncConverter<TElement, TBy>, equater?: MaybeAsyncEqualityComparisonOrComparer<TBy>): AsyncSequence<TElement>;
all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>; all(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>; any(predicate: MaybeAsyncAnyPredicate<TElement>): Promise<boolean>;
@@ -108,6 +109,7 @@ export interface AsyncSequence<TElement> extends AsyncIterable<TElement> {
forEach(action: MaybeAsyncAction<TElement>): Promise<void>; forEach(action: MaybeAsyncAction<TElement>): Promise<void>;
zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>; zip<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>;
cartesianProduct<TOther>(sequence: MaybeAsyncIterable<TOther>): AsyncSequence<[TElement, TOther]>;
indexed(): AsyncSequence<[number, TElement]>; indexed(): AsyncSequence<[number, TElement]>;

30
src/comparer/async.ts
View File

@@ -1,16 +1,16 @@
import { MaybeAsyncConverter } from "../types.js"; import { MaybeAsyncConverter } from "../types.js";
import { Nullable } from "../utils.js"; import { Nullable } from "../utils.js";
import { AsyncComparer, MaybeAsyncComparisonOrComparer, Comparer, MaybeAsyncComparison, AsyncComparison } from "./types.js"; import { AsyncComparer, AsyncComparison, Comparer, MaybeAsyncComparison, MaybeAsyncComparisonOrComparer } from "./types.js";
export function isAsyncComparer<T>(obj: any): obj is AsyncComparer<T> { export function isAsyncComparer<T>(obj: any): obj is AsyncComparer<T> {
return obj instanceof BaseAsyncComparer; return obj instanceof BaseAsyncComparer;
} }
export function asAsyncComparer<T>(comparer: MaybeAsyncComparisonOrComparer<T>): AsyncComparer<T> { export function asAsyncComparer<T>(comparer: MaybeAsyncComparisonOrComparer<T>): AsyncComparer<T> {
return typeof comparer === "function" ? createAsyncComparer(comparer) : isAsyncComparer<T>(comparer) ? comparer : new WrappedAsyncComparer(comparer); return typeof comparer === "function" ? createAsyncComparer(comparer) : isAsyncComparer<T>(comparer) ? comparer : fromSyncComparer(comparer);
} }
export function fromSync<T>(comparer: Comparer<T>): AsyncComparer<T> { export function fromSyncComparer<T>(comparer: Comparer<T>): AsyncComparer<T> {
return new WrappedAsyncComparer(comparer); return new WrappedAsyncComparer(comparer);
} }
@@ -22,8 +22,8 @@ export function createAsyncComparerUsing<T, U>(projection: MaybeAsyncConverter<T
return new MappedAsyncComparer(projection, comparison); return new MappedAsyncComparer(projection, comparison);
} }
export function combineNullableAsyncComparers<T>(comparers: Nullable<MaybeAsyncComparisonOrComparer<T>>[]): AsyncComparer<T> | undefined { export function combineAsyncComparers<T>(comparers: Iterable<Nullable<MaybeAsyncComparisonOrComparer<T>>>): AsyncComparer<T> | undefined {
let result = defaultAsyncComparer; let result: AsyncComparer<T> = dummyAsyncComparer;
for (const comparer of comparers) { for (const comparer of comparers) {
if (!comparer) { if (!comparer) {
@@ -33,7 +33,7 @@ export function combineNullableAsyncComparers<T>(comparers: Nullable<MaybeAsyncC
result = result.then(asAsyncComparer(comparer)); result = result.then(asAsyncComparer(comparer));
} }
return result === defaultAsyncComparer ? undefined : result; return result === dummyAsyncComparer ? undefined : result;
} }
export abstract class BaseAsyncComparer<T> implements AsyncComparer<T> { export abstract class BaseAsyncComparer<T> implements AsyncComparer<T> {
@@ -144,6 +144,24 @@ class ThenAsyncComparer<T> extends BaseAsyncComparer<T> {
} }
} }
const dummyAsyncComparer = new class DummyAsyncComparer extends BaseAsyncComparer<any> {
public override async compare(_a: any, _b: any): Promise<number> {
return 0;
}
public override then(comparer: AsyncComparer<any>): AsyncComparer<any> {
return comparer;
}
public override thenCompare(comparison: MaybeAsyncComparison<any>): AsyncComparer<any> {
return createAsyncComparer(comparison);
}
public override thenCompareUsing<U>(projection: MaybeAsyncConverter<any, U>, comparison?: MaybeAsyncComparisonOrComparer<U> | undefined): AsyncComparer<any> {
return createAsyncComparerUsing(projection, comparison);
}
}
export const defaultAsyncComparer: AsyncComparer<any> = new class DefaultAsyncComparer extends BaseAsyncComparer<any> { export const defaultAsyncComparer: AsyncComparer<any> = new class DefaultAsyncComparer extends BaseAsyncComparer<any> {
public override async compare(a: any, b: any): Promise<number> { public override async compare(a: any, b: any): Promise<number> {
if (a === undefined) { if (a === undefined) {

32
src/comparer/sync.ts
View File

@@ -1,6 +1,6 @@
import { Converter } from "../types.js"; import { Converter } from "../types.js";
import { Nullable } from "../utils.js"; import { Nullable } from "../utils.js";
import { fromSync } from "./async.js"; import { fromSyncComparer } from "./async.js";
import { Comparer, ComparisonOrComparer, Comparison, AsyncComparer } from "./types.js"; import { Comparer, ComparisonOrComparer, Comparison, AsyncComparer } from "./types.js";
export function isComparer<T>(obj: any): obj is Comparer<T> { export function isComparer<T>(obj: any): obj is Comparer<T> {
@@ -15,11 +15,11 @@ export function asComparison<T>(comparer: ComparisonOrComparer<T>) {
return typeof comparer === "function" ? comparer : comparer.comparison(); return typeof comparer === "function" ? comparer : comparer.comparison();
} }
export function createComparer<T>(comparison: Comparison<T>): Comparer<T> { export function createComparer<T = any>(comparison: Comparison<T>): Comparer<T> {
return new SimpleComparer(comparison); return new SimpleComparer(comparison);
} }
export function createComparerUsing<T, U>(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>): Comparer<T> { export function createComparerUsing<T = any, U = any>(projection: Converter<T, U>, comparison?: ComparisonOrComparer<U>): Comparer<T> {
return new MappedComparer(projection, comparison); return new MappedComparer(projection, comparison);
} }
@@ -27,8 +27,8 @@ export function reverseComparison<T>(comparison: Comparison<T>): Comparison<T> {
return (a, b) => comparison(b, a); return (a, b) => comparison(b, a);
} }
export function combineNullableComparers<T>(comparers: Nullable<ComparisonOrComparer<T>>[]) { export function combineComparers<T>(comparers: Iterable<Nullable<ComparisonOrComparer<T>>>) {
let result = defaultComparer; let result: Comparer<T> = dummyComparer;
for (const comparer of comparers) { for (const comparer of comparers) {
if (!comparer) { if (!comparer) {
@@ -38,7 +38,7 @@ export function combineNullableComparers<T>(comparers: Nullable<ComparisonOrComp
result = result.then(asComparer(comparer)); result = result.then(asComparer(comparer));
} }
return result === defaultComparer ? undefined : result; return result === dummyComparer ? undefined : result;
} }
export abstract class BaseComparer<T> implements Comparer<T> { export abstract class BaseComparer<T> implements Comparer<T> {
@@ -67,7 +67,7 @@ export abstract class BaseComparer<T> implements Comparer<T> {
} }
public toAsync(): AsyncComparer<T> { public toAsync(): AsyncComparer<T> {
return fromSync<T>(this); return fromSyncComparer<T>(this);
} }
public nullAwareComparer(): Comparer<Nullable<T>> { public nullAwareComparer(): Comparer<Nullable<T>> {
@@ -75,6 +75,24 @@ export abstract class BaseComparer<T> implements Comparer<T> {
} }
} }
const dummyComparer = new class DummyComparer extends BaseComparer<any> {
public override compare(_a: any, _b: any): number {
return 0;
}
public override then(comparer: Comparer<any>): Comparer<any> {
return comparer;
}
public override thenCompare(comparison: Comparison<any>): Comparer<any> {
return createComparer(comparison);
}
public override thenCompareUsing<U>(projection: Converter<any, U>, comparison?: ComparisonOrComparer<U> | undefined): Comparer<any> {
return createComparerUsing(projection, comparison);
}
};
class SimpleComparer<T> extends BaseComparer<T> { class SimpleComparer<T> extends BaseComparer<T> {
readonly #comparison: Comparison<T>; readonly #comparison: Comparison<T>;

3
src/comparer/types.ts
View File

@@ -24,12 +24,9 @@ export interface AsyncComparer<T> {
export type Comparison<T> = (first: T, second: T) => number; export type Comparison<T> = (first: T, second: T) => number;
export type ComparisonOrComparer<T> = Comparison<T> | Comparer<T>; export type ComparisonOrComparer<T> = Comparison<T> | Comparer<T>;
export type Equater<T> = (first: T, second: T) => boolean;
export type AsyncComparison<T> = AsyncFunction<Comparison<T>>; export type AsyncComparison<T> = AsyncFunction<Comparison<T>>;
export type MaybeAsyncComparison<T> = MaybeAsyncFunction<Comparison<T>>; export type MaybeAsyncComparison<T> = MaybeAsyncFunction<Comparison<T>>;
export type AsyncComparisonOrComparer<T> = AsyncComparison<T> | AsyncComparer<T>; export type AsyncComparisonOrComparer<T> = AsyncComparison<T> | AsyncComparer<T>;
export type MaybeAsyncComparisonOrComparer<T> = MaybeAsyncComparison<T> | Comparer<T> | AsyncComparer<T>; export type MaybeAsyncComparisonOrComparer<T> = MaybeAsyncComparison<T> | Comparer<T> | AsyncComparer<T>;
export type AsyncEquater<T> = AsyncFunction<Equater<T>>;
export type MaybeAsyncEquater<T> = MaybeAsyncFunction<Equater<T>>;

217
src/equality-comparer/async.ts Normal file
View File

@@ -0,0 +1,217 @@
import { MaybeAsyncConverter } from "../types.js";
import { Nullable } from "../utils.js";
import { AsyncEqualityComparer, AsyncEqualityComparison, EqualityComparer, MaybeAsyncEqualityComparison, MaybeAsyncEqualityComparisonOrComparer } from "./types.js";
export function isAsyncEqualityComparer<T>(obj: any): obj is AsyncEqualityComparer<T> {
return obj instanceof BaseAsyncEqualityComparer;
}
export function asAsyncEqualityComparer<T>(equalityComparer: MaybeAsyncEqualityComparisonOrComparer<T>): AsyncEqualityComparer<T> {
return typeof equalityComparer === "function" ? createAsyncEqualityComparer(equalityComparer) : isAsyncEqualityComparer<T>(equalityComparer) ? equalityComparer : fromSyncEqualityComparer(equalityComparer);
}
export function fromSyncEqualityComparer<T>(equalityComparer: EqualityComparer<T>): AsyncEqualityComparer<T> {
return new WrappedAsyncEqualityComparer(equalityComparer);
}
export function createAsyncEqualityComparer<T = any>(equalityComparison: MaybeAsyncEqualityComparison<T>): AsyncEqualityComparer<T> {
return new SimpleAsyncEqualityComparer(equalityComparison);
}
export function createAsyncEqualityComparerUsing<T = any, U = any>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T> {
return new MappedAsyncEqualityComparer(projection, equalityComparison);
}
export function combineAsyncEqualityComparers<T>(equalityComparers: Iterable<Nullable<MaybeAsyncEqualityComparisonOrComparer<T>>>) {
let result: AsyncEqualityComparer<T> = alwaysTrueAsyncEqualityComparer;
for (const equalityComparer of equalityComparers) {
if (!equalityComparer) {
continue;
}
result = result.then(asAsyncEqualityComparer(equalityComparer));
}
return result === alwaysTrueAsyncEqualityComparer ? undefined : result;
}
export abstract class BaseAsyncEqualityComparer<T> implements AsyncEqualityComparer<T> {
#cachedBoundEqualityComparison: AsyncEqualityComparison<T> | undefined;
public abstract equals(a: T, b: T): Promise<boolean>;
public equalityComparison(): AsyncEqualityComparison<T> {
return this.#cachedBoundEqualityComparison ??= this.equals.bind(this);
}
public opposite(): AsyncEqualityComparer<T> {
return new OppositeAsyncEqualityComparer(this);
}
public then(equalityComparer: AsyncEqualityComparer<T>): AsyncEqualityComparer<T> {
return new ThenAsyncEqualityComparer(this, equalityComparer);
}
public thenEquals(equalityComparison: MaybeAsyncEqualityComparison<T>): AsyncEqualityComparer<T> {
return this.then(createAsyncEqualityComparer(equalityComparison));
}
public thenEqualsUsing<U>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T> {
return this.then(createAsyncEqualityComparerUsing(projection, equalityComparison));
}
}
class WrappedAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #base: EqualityComparer<T>;
constructor(base: EqualityComparer<T>) {
super();
this.#base = base;
}
public override async equals(a: T, b: T) {
return this.#base.equals(a, b);
}
}
class SimpleAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #equalityComparison: MaybeAsyncEqualityComparison<T>;
public constructor(equalityComparison: MaybeAsyncEqualityComparison<T>) {
super();
this.#equalityComparison = equalityComparison;
}
public override async equals(a: T, b: T): Promise<boolean> {
return await this.#equalityComparison(a, b);
}
}
class MappedAsyncEqualityComparer<T, U> extends BaseAsyncEqualityComparer<T> {
readonly #projection: MaybeAsyncConverter<T, U>;
readonly #equalityComparison: AsyncEqualityComparer<U>;
public constructor(projection: MaybeAsyncConverter<T, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U>) {
super();
this.#projection = projection;
this.#equalityComparison = equalityComparison ? asAsyncEqualityComparer(equalityComparison) : defaultAsyncEqualityComparer;
}
public override async equals(a: T, b: T): Promise<boolean> {
return await this.#equalityComparison.equals(await this.#projection(a), await this.#projection(b));
}
}
class OppositeAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #base: AsyncEqualityComparer<T>;
public constructor(base: AsyncEqualityComparer<T>) {
super();
this.#base = base;
}
public override async equals(a: T, b: T): Promise<boolean> {
return !(await this.#base.equals(a, b));
}
public override opposite(): AsyncEqualityComparer<T> {
return this.#base;
}
}
class ThenAsyncEqualityComparer<T> extends BaseAsyncEqualityComparer<T> {
readonly #base: AsyncEqualityComparer<T>;
readonly #equalityComparer: AsyncEqualityComparer<T>;
public constructor(base: AsyncEqualityComparer<T>, equalityComparer: AsyncEqualityComparer<T>) {
super();
this.#base = base;
this.#equalityComparer = equalityComparer;
}
public override async equals(a: T, b: T) {
return await this.#base.equals(a, b) && await this.#equalityComparer.equals(a, b);
}
}
export const alwaysAsyncFalseEqualityComparer = new class AlwaysFalseAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(_a: any, _b: any): Promise<boolean> {
return false;
}
public override opposite(): AsyncEqualityComparer<any> {
return alwaysTrueAsyncEqualityComparer;
}
public override then(_equalityComparer: AsyncEqualityComparer<any>): AsyncEqualityComparer<any> {
return this;
}
public override thenEquals(_equalityComparison: MaybeAsyncEqualityComparison<any>): AsyncEqualityComparer<any> {
return this;
}
public override thenEqualsUsing<U>(_projection: MaybeAsyncConverter<any, U>, _equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U> | undefined): AsyncEqualityComparer<any> {
return this;
}
};
export const alwaysTrueAsyncEqualityComparer = new class AlwaysTrueAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(_a: any, _b: any): Promise<boolean> {
return true;
}
public override opposite(): AsyncEqualityComparer<any> {
return alwaysAsyncFalseEqualityComparer;
}
public override then(equalityComparer: AsyncEqualityComparer<any>): AsyncEqualityComparer<any> {
return equalityComparer;
}
public override thenEquals(equalityComparison: MaybeAsyncEqualityComparison<any>): AsyncEqualityComparer<any> {
return createAsyncEqualityComparer(equalityComparison);
}
public override thenEqualsUsing<U>(projection: MaybeAsyncConverter<any, U>, equalityComparison?: MaybeAsyncEqualityComparisonOrComparer<U> | undefined): AsyncEqualityComparer<any> {
return createAsyncEqualityComparerUsing(projection, equalityComparison);
}
};
export const looseAsyncEqualityComparer: AsyncEqualityComparer<any> = new class LooseAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return a == b;
}
};
export const strictAsyncEqualityComparer: AsyncEqualityComparer<any> = new class StrictAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return a === b;
}
};
export const sameValueAsyncEqualityComparer: AsyncEqualityComparer<any> = new class SameValueAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return Object.is(a, b);
}
};
export const defaultAsyncEqualityComparer: AsyncEqualityComparer<any> = new class DefaultAsyncEqualityComparer extends BaseAsyncEqualityComparer<any> {
public override async equals(a: any, b: any): Promise<boolean> {
return a === b;
}
};
export function getDefaultAsyncEqualityComparer<T>(): AsyncEqualityComparer<T> {
return defaultAsyncEqualityComparer;
}
export const dateAsyncEqualityComparer: AsyncEqualityComparer<Date> = new class DateAsyncEqualityComparer extends BaseAsyncEqualityComparer<Date> {
public override async equals(a: Date, b: Date): Promise<boolean> {
return a.getTime() === b.getTime();
}
};

15
src/equality-comparer/index.ts
View File

@@ -1,15 +0,0 @@
export function identity<T>(obj: T) {
return obj;
}
export function looseEquals<T>(a: T, b: T) {
return a == b;
}
export function strictEquals<T>(a: T, b: T) {
return a === b;
}
export function sameValue<T>(a: T, b: T) {
return Object.is(a, b);
}

203
src/equality-comparer/sync.ts Normal file
View File

@@ -0,0 +1,203 @@
import { Converter } from "../types.js";
import { Nullable } from "../utils.js";
import { EqualityComparer, EqualityComparison, EqualityComparisonOrComparer } from "./types.js";
export function isEqualityComparer<T>(obj: any): obj is EqualityComparer<T> {
return obj instanceof BaseEqualityComparer;
}
export function asEqualityComparer<T>(equalityComparer: EqualityComparisonOrComparer<T>): EqualityComparer<T> {
return typeof equalityComparer === "function" ? createEqualityComparer(equalityComparer) : equalityComparer;
}
export function createEqualityComparer<T = any>(equalityComparison: EqualityComparison<T>): EqualityComparer<T> {
return new SimpleEqualityComparer(equalityComparison);
}
export function createEqualityComparerUsing<T = any, U = any>(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>): EqualityComparer<T> {
return new MappedEqualityComparer(projection, equalityComparison);
}
export function combineEqualityComparers<T>(equalityComparers: Iterable<Nullable<EqualityComparisonOrComparer<T>>>) {
let result: EqualityComparer<T> = alwaysTrueEqualityComparer;
for (const equalityComparer of equalityComparers) {
if (!equalityComparer) {
continue;
}
result = result.then(asEqualityComparer(equalityComparer));
}
return result === alwaysTrueEqualityComparer ? undefined : result;
}
export abstract class BaseEqualityComparer<T> implements EqualityComparer<T> {
#cachedBoundEqualityComparison: EqualityComparison<T> | undefined;
public abstract equals(a: T, b: T): boolean;
public equalityComparison(): EqualityComparison<T> {
return this.#cachedBoundEqualityComparison ??= this.equals.bind(this);
}
public opposite(): EqualityComparer<T> {
return new OppositeEqualityComparer(this);
}
public then(equalityComparer: EqualityComparer<T>): EqualityComparer<T> {
return new ThenEqualityComparer(this, equalityComparer);
}
public thenEquals(equalityComparison: EqualityComparison<T>): EqualityComparer<T> {
return this.then(createEqualityComparer(equalityComparison));
}
public thenEqualsUsing<U>(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>): EqualityComparer<T> {
return this.then(createEqualityComparerUsing(projection, equalityComparison));
}
}
class SimpleEqualityComparer<T> extends BaseEqualityComparer<T> {
readonly #equalityComparison: EqualityComparison<T>;
public constructor(equalityComparison: EqualityComparison<T>) {
super();
this.#equalityComparison = equalityComparison;
}
public override equals(a: T, b: T): boolean {
return this.#equalityComparison(a, b);
}
public override equalityComparison() {
return this.#equalityComparison;
}
}
class MappedEqualityComparer<T, U> extends BaseEqualityComparer<T> {
readonly #projection: Converter<T, U>;
readonly #equalityComparison: EqualityComparer<U>;
public constructor(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>) {
super();
this.#projection = projection;
this.#equalityComparison = equalityComparison ? asEqualityComparer(equalityComparison) : defaultEqualityComparer;
}
public override equals(a: T, b: T): boolean {
return this.#equalityComparison.equals(this.#projection(a), this.#projection(b));
}
}
class OppositeEqualityComparer<T> extends BaseEqualityComparer<T> {
readonly #base: EqualityComparer<T>;
public constructor(base: EqualityComparer<T>) {
super();
this.#base = base;
}
public override equals(a: T, b: T): boolean {
return !this.#base.equals(a, b);
}
public override opposite(): EqualityComparer<T> {
return this.#base;
}
}
class ThenEqualityComparer<T> extends BaseEqualityComparer<T> {
readonly #base: EqualityComparer<T>;
readonly #equalityComparer: EqualityComparer<T>;
public constructor(base: EqualityComparer<T>, equalityComparer: EqualityComparer<T>) {
super();
this.#base = base;
this.#equalityComparer = equalityComparer;
}
public override equals(a: T, b: T) {
return this.#base.equals(a, b) && this.#equalityComparer.equals(a, b);
}
}
export const alwaysFalseEqualityComparer = new class AlwaysFalseEqualityComparer extends BaseEqualityComparer<any> {
public override equals(_a: any, _b: any): boolean {
return false;
}
public override opposite(): EqualityComparer<any> {
return alwaysTrueEqualityComparer;
}
public override then(_equalityComparer: EqualityComparer<any>): EqualityComparer<any> {
return this;
}
public override thenEquals(_equalityComparison: EqualityComparison<any>): EqualityComparer<any> {
return this;
}
public override thenEqualsUsing<U>(_projection: Converter<any, U>, _equalityComparison?: EqualityComparisonOrComparer<U> | undefined): EqualityComparer<any> {
return this;
}
};
export const alwaysTrueEqualityComparer = new class AlwaysTrueEqualityComparer extends BaseEqualityComparer<any> {
public override equals(_a: any, _b: any): boolean {
return true;
}
public override opposite(): EqualityComparer<any> {
return alwaysFalseEqualityComparer;
}
public override then(equalityComparer: EqualityComparer<any>): EqualityComparer<any> {
return equalityComparer;
}
public override thenEquals(equalityComparison: EqualityComparison<any>): EqualityComparer<any> {
return createEqualityComparer(equalityComparison);
}
public override thenEqualsUsing<U>(projection: Converter<any, U>, equalityComparison?: EqualityComparisonOrComparer<U> | undefined): EqualityComparer<any> {
return createEqualityComparerUsing(projection, equalityComparison);
}
};
export const looseEqualityComparer: EqualityComparer<any> = new class LooseEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return a == b;
}
};
export const strictEqualityComparer: EqualityComparer<any> = new class StrictEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return a === b;
}
};
export const sameValueEqualityComparer: EqualityComparer<any> = new class SameValueEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return Object.is(a, b);
}
};
export const defaultEqualityComparer: EqualityComparer<any> = new class DefaultEqualityComparer extends BaseEqualityComparer<any> {
public override equals(a: any, b: any): boolean {
return a === b;
}
};
export function getDefaultEqualityComparer<T>(): EqualityComparer<T> {
return defaultEqualityComparer;
}
export const dateEqualityComparer: EqualityComparer<Date> = new class DateEqualityComparer extends BaseEqualityComparer<Date> {
public override equals(a: Date, b: Date): boolean {
return a.getTime() === b.getTime();
}
};

24
src/equality-comparer/types.ts
View File

@@ -1,6 +1,28 @@
import { AsyncFunction, MaybeAsyncFunction } from "../types.js"; import { AsyncFunction, Converter, MaybeAsyncConverter, MaybeAsyncFunction } from "../types.js";
export interface EqualityComparer<T> {
equals(a: T, b: T): boolean;
equalityComparison(): EqualityComparison<T>;
opposite(): EqualityComparer<T>;
then(equalityComparer: EqualityComparer<T>): EqualityComparer<T>;
thenEquals(equalityComparison: EqualityComparison<T>): EqualityComparer<T>;
thenEqualsUsing<U>(projection: Converter<T, U>, equalityComparison?: EqualityComparisonOrComparer<U>): EqualityComparer<T>;
}
export interface AsyncEqualityComparer<T> {
equals(a: T, b: T): Promise<boolean>;
equalityComparison(): AsyncEqualityComparison<T>;
opposite(): AsyncEqualityComparer<T>;
then(equalityComparer: AsyncEqualityComparer<T>): AsyncEqualityComparer<T>;
thenEquals(equalityComparison: AsyncEqualityComparison<T>): AsyncEqualityComparer<T>;
thenEqualsUsing<U>(projection: MaybeAsyncConverter<T, U>, equalityComparison?: AsyncEqualityComparisonOrComparer<U>): AsyncEqualityComparer<T>;
}
export type EqualityComparison<T> = (first: T, second: T) => boolean; export type EqualityComparison<T> = (first: T, second: T) => boolean;
export type EqualityComparisonOrComparer<T> = EqualityComparison<T> | EqualityComparer<T>;
export type AsyncEqualityComparison<T> = AsyncFunction<EqualityComparison<T>>; export type AsyncEqualityComparison<T> = AsyncFunction<EqualityComparison<T>>;
export type MaybeAsyncEqualityComparison<T> = MaybeAsyncFunction<EqualityComparison<T>>; export type MaybeAsyncEqualityComparison<T> = MaybeAsyncFunction<EqualityComparison<T>>;
export type AsyncEqualityComparisonOrComparer<T> = AsyncEqualityComparison<T> | AsyncEqualityComparer<T>;
export type MaybeAsyncEqualityComparisonOrComparer<T> = MaybeAsyncEqualityComparison<T> | EqualityComparer<T> | AsyncEqualityComparer<T>;

95
src/equality-map.ts → src/equality-map/impl.ts
View File

@@ -1,22 +1,10 @@
import { EqualityComparison, MaybeAsyncEqualityComparison } from "./equality-comparer/types.js"; import { asAsyncEqualityComparer } from "../equality-comparer/async.js";
import { MaybeAsyncIterable } from "./types.js"; import { asEqualityComparer } from "../equality-comparer/sync.js";
import { AsyncEqualityComparer, EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { MaybeAsyncIterable } from "../types.js";
import { AsyncEqualityMap, EqualityMap, EqualityMapEntry } from "./types.js";
export type Entry<K, V> = [key: K, value: V]; export class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
export interface EqualityMap<K, V> extends Iterable<Entry<K, V>> {
readonly size: number;
get(key: K): V | undefined;
set(key: K, value: V): V | undefined;
setAll(entries: Iterable<Entry<K, V>>): void;
contains(key: K): boolean;
remove(key: K): V | undefined;
clear(): void;
keys(): IterableIterator<K>;
values(): IterableIterator<V>;
entries(): IterableIterator<Entry<K, V>>;
}
class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
readonly #map = new Map<K, V>(); readonly #map = new Map<K, V>();
get size() { get size() {
@@ -33,7 +21,7 @@ class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
return existing; return existing;
} }
setAll(entries: Iterable<Entry<K, V>>) { setAll(entries: Iterable<EqualityMapEntry<K, V>>) {
for (const [key, value] of entries) { for (const [key, value] of entries) {
this.set(key, value); this.set(key, value);
} }
@@ -70,12 +58,12 @@ class NativeEqualityMap<K, V> implements EqualityMap<K, V> {
} }
} }
class CustomEqualityMap<K, V> implements EqualityMap<K, V> { export class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
readonly #list: Entry<K, V>[] = []; readonly #list: EqualityMapEntry<K, V>[] = [];
readonly #keyComparer: EqualityComparison<K>; readonly #keyComparer: EqualityComparer<K>;
constructor(keyComparer: EqualityComparison<K>) { constructor(keyComparer: EqualityComparisonOrComparer<K>) {
this.#keyComparer = keyComparer; this.#keyComparer = asEqualityComparer(keyComparer);
} }
get size() { get size() {
@@ -84,7 +72,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
get(key: K) { get(key: K) {
for (const entry of this.#list) { for (const entry of this.#list) {
if (this.#keyComparer(key, entry[0])) { if (this.#keyComparer.equals(key, entry[0])) {
return entry[1]; return entry[1];
} }
} }
@@ -94,7 +82,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
set(key: K, value: V) { set(key: K, value: V) {
for (const entry of this.#list) { for (const entry of this.#list) {
if (this.#keyComparer(key, entry[0])) { if (this.#keyComparer.equals(key, entry[0])) {
const previous = entry[1]; const previous = entry[1];
entry[1] = value; entry[1] = value;
return previous; return previous;
@@ -106,7 +94,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
return undefined; return undefined;
} }
setAll(entries: Iterable<Entry<K, V>>) { setAll(entries: Iterable<EqualityMapEntry<K, V>>) {
for (const [key, value] of entries) { for (const [key, value] of entries) {
this.set(key, value); this.set(key, value);
} }
@@ -114,7 +102,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
contains(key: K) { contains(key: K) {
for (const entry of this.#list) { for (const entry of this.#list) {
if (this.#keyComparer(key, entry[0])) { if (this.#keyComparer.equals(key, entry[0])) {
return true; return true;
} }
} }
@@ -124,7 +112,7 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
remove(key: K) { remove(key: K) {
for (let i = 0; i < this.#list.length; i++) { for (let i = 0; i < this.#list.length; i++) {
if (this.#keyComparer(key, this.#list[i][0])) { if (this.#keyComparer.equals(key, this.#list[i][0])) {
const removed = this.#list.splice(i, 1); const removed = this.#list.splice(i, 1);
return removed[0][1]; return removed[0][1];
} }
@@ -155,29 +143,12 @@ class CustomEqualityMap<K, V> implements EqualityMap<K, V> {
*[Symbol.iterator]() { *[Symbol.iterator]() {
for (const entry of this.#list) { for (const entry of this.#list) {
yield entry.slice() as Entry<K, V>; // no entry mutation allowed! yield entry.slice() as EqualityMapEntry<K, V>; // no entry mutation allowed!
} }
} }
} }
export function createEqualityMap<K, V>(keyComparer?: EqualityComparison<K>): EqualityMap<K, V> { export class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
return keyComparer ? new CustomEqualityMap<K, V>(keyComparer) : new NativeEqualityMap<K, V>();
}
export interface AsyncEqualityMap<K, V> extends Iterable<Entry<K, V>> {
readonly size: number;
get(key: K): Promise<V | undefined>;
set(key: K, value: V): Promise<V | undefined>;
setAll(entries: MaybeAsyncIterable<Entry<K, V>>): Promise<void>;
contains(key: K): Promise<boolean>;
remove(key: K): Promise<V | undefined>;
clear(): void;
keys(): IterableIterator<K>;
values(): IterableIterator<V>;
entries(): IterableIterator<Entry<K, V>>;
}
class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
readonly #map = new Map<K, V>(); readonly #map = new Map<K, V>();
get size() { get size() {
@@ -194,7 +165,7 @@ class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
return existing; return existing;
} }
async setAll(entries: MaybeAsyncIterable<Entry<K, V>>) { async setAll(entries: MaybeAsyncIterable<EqualityMapEntry<K, V>>) {
for await (const [key, value] of entries) { for await (const [key, value] of entries) {
await this.set(key, value); await this.set(key, value);
} }
@@ -231,12 +202,12 @@ class NativeAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
} }
} }
class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> { export class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
readonly #list: Entry<K, V>[] = []; readonly #list: EqualityMapEntry<K, V>[] = [];
readonly #keyComparer: MaybeAsyncEqualityComparison<K>; readonly #keyComparer: AsyncEqualityComparer<K>;
constructor(keyComparer: MaybeAsyncEqualityComparison<K>) { constructor(keyComparer: MaybeAsyncEqualityComparisonOrComparer<K>) {
this.#keyComparer = keyComparer; this.#keyComparer = asAsyncEqualityComparer(keyComparer);
} }
get size() { get size() {
@@ -245,7 +216,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async get(key: K) { async get(key: K) {
for (const entry of this.#list) { for (const entry of this.#list) {
if (await this.#keyComparer(key, entry[0])) { if (await this.#keyComparer.equals(key, entry[0])) {
return entry[1]; return entry[1];
} }
} }
@@ -255,7 +226,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async set(key: K, value: V) { async set(key: K, value: V) {
for (const entry of this.#list) { for (const entry of this.#list) {
if (await this.#keyComparer(key, entry[0])) { if (await this.#keyComparer.equals(key, entry[0])) {
const previous = entry[1]; const previous = entry[1];
entry[1] = value; entry[1] = value;
return previous; return previous;
@@ -267,7 +238,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
return undefined; return undefined;
} }
async setAll(entries: MaybeAsyncIterable<Entry<K, V>>) { async setAll(entries: MaybeAsyncIterable<EqualityMapEntry<K, V>>) {
for await (const [key, value] of entries) { for await (const [key, value] of entries) {
await this.set(key, value); await this.set(key, value);
} }
@@ -275,7 +246,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async contains(key: K) { async contains(key: K) {
for (const entry of this.#list) { for (const entry of this.#list) {
if (await this.#keyComparer(key, entry[0])) { if (await this.#keyComparer.equals(key, entry[0])) {
return true; return true;
} }
} }
@@ -285,7 +256,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
async remove(key: K) { async remove(key: K) {
for (let i = 0; i < this.#list.length; i++) { for (let i = 0; i < this.#list.length; i++) {
if (await this.#keyComparer(key, this.#list[i][0])) { if (await this.#keyComparer.equals(key, this.#list[i][0])) {
const removed = this.#list.splice(i, 1); const removed = this.#list.splice(i, 1);
return removed[0][1]; return removed[0][1];
} }
@@ -316,11 +287,7 @@ class CustomAsyncEqualityMap<K, V> implements AsyncEqualityMap<K, V> {
*[Symbol.iterator]() { *[Symbol.iterator]() {
for (const entry of this.#list) { for (const entry of this.#list) {
yield entry.slice() as Entry<K, V>; // no entry mutation allowed! yield entry.slice() as EqualityMapEntry<K, V>; // no entry mutation allowed!
} }
} }
} }
export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEqualityComparison<K>): AsyncEqualityMap<K, V> {
return keyComparer ? new CustomAsyncEqualityMap<K, V>(keyComparer) : new NativeAsyncEqualityMap<K, V>();
}

11
src/equality-map/index.ts Normal file
View File

@@ -0,0 +1,11 @@
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { CustomAsyncEqualityMap, CustomEqualityMap, NativeAsyncEqualityMap, NativeEqualityMap } from "./impl.js";
import { AsyncEqualityMap, EqualityMap } from "./types.js";
export function createEqualityMap<K, V>(keyComparer?: EqualityComparisonOrComparer<K>): EqualityMap<K, V> {
return keyComparer ? new CustomEqualityMap<K, V>(keyComparer) : new NativeEqualityMap<K, V>();
}
export function createAsyncEqualityMap<K, V>(keyComparer?: MaybeAsyncEqualityComparisonOrComparer<K>): AsyncEqualityMap<K, V> {
return keyComparer ? new CustomAsyncEqualityMap<K, V>(keyComparer) : new NativeAsyncEqualityMap<K, V>();
}

29
src/equality-map/types.ts Normal file
View File

@@ -0,0 +1,29 @@
import { MaybeAsyncIterable } from "../types.js";
export type EqualityMapEntry<K, V> = [key: K, value: V];
export interface EqualityMap<K, V> extends Iterable<EqualityMapEntry<K, V>> {
readonly size: number;
get(key: K): V | undefined;
set(key: K, value: V): V | undefined;
setAll(entries: Iterable<EqualityMapEntry<K, V>>): void;
contains(key: K): boolean;
remove(key: K): V | undefined;
clear(): void;
keys(): IterableIterator<K>;
values(): IterableIterator<V>;
entries(): IterableIterator<EqualityMapEntry<K, V>>;
}
export interface AsyncEqualityMap<K, V> extends Iterable<EqualityMapEntry<K, V>> {
readonly size: number;
get(key: K): Promise<V | undefined>;
set(key: K, value: V): Promise<V | undefined>;
setAll(entries: MaybeAsyncIterable<EqualityMapEntry<K, V>>): Promise<void>;
contains(key: K): Promise<boolean>;
remove(key: K): Promise<V | undefined>;
clear(): void;
keys(): IterableIterator<K>;
values(): IterableIterator<V>;
entries(): IterableIterator<EqualityMapEntry<K, V>>;
}

63
src/equality-set.ts → src/equality-set/impl.ts
View File

@@ -1,17 +1,10 @@
import { EqualityComparison, MaybeAsyncEqualityComparison } from "./equality-comparer/types.js"; import { asAsyncEqualityComparer } from "../equality-comparer/async.js";
import { MaybeAsyncIterable } from "./types.js"; import { asEqualityComparer } from "../equality-comparer/sync.js";
import { AsyncEqualityComparer, EqualityComparer, EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { MaybeAsyncIterable } from "../types.js";
import { AsyncEqualitySet, EqualitySet } from "./types.js";
export interface EqualitySet<T> extends Iterable<T> { export class NativeEqualitySet<T> implements EqualitySet<T> {
readonly size: number;
add(value: T): boolean;
addAll(values: Iterable<T>): number;
contains(value: T): boolean;
remove(value: T): boolean;
clear(): void;
values(): IterableIterator<T>;
}
class NativeEqualitySet<T> implements EqualitySet<T> {
readonly #set = new Set<T>(); readonly #set = new Set<T>();
get size() { get size() {
@@ -57,12 +50,12 @@ class NativeEqualitySet<T> implements EqualitySet<T> {
} }
} }
class CustomEqualitySet<T> implements EqualitySet<T> { export class CustomEqualitySet<T> implements EqualitySet<T> {
readonly #list: T[] = []; readonly #list: T[] = [];
readonly #equater: EqualityComparison<T>; readonly #equater: EqualityComparer<T>;
constructor(equater: EqualityComparison<T>) { constructor(equater: EqualityComparisonOrComparer<T>) {
this.#equater = equater; this.#equater = asEqualityComparer(equater);
} }
get size() { get size() {
@@ -93,7 +86,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
contains(value: T) { contains(value: T) {
for (const val of this.#list) { for (const val of this.#list) {
if (this.#equater(value, val)) { if (this.#equater.equals(value, val)) {
return true; return true;
} }
} }
@@ -105,7 +98,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
const length = this.#list.length; const length = this.#list.length;
for (let i = 0; i < length; i++) { for (let i = 0; i < length; i++) {
if (this.#equater(value, this.#list[i])) { if (this.#equater.equals(value, this.#list[i])) {
this.#list.splice(i, 1); this.#list.splice(i, 1);
return true; return true;
} }
@@ -127,21 +120,7 @@ class CustomEqualitySet<T> implements EqualitySet<T> {
} }
} }
export function createEqualitySet<T>(equater?: EqualityComparison<T>): EqualitySet<T> { export class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
return equater ? new CustomEqualitySet(equater) : new NativeEqualitySet<T>();
}
export interface AsyncEqualitySet<T> extends Iterable<T> {
readonly size: number;
add(value: T): Promise<boolean>;
addAll(values: MaybeAsyncIterable<T>): Promise<number>;
contains(value: T): Promise<boolean>;
remove(value: T): Promise<boolean>;
clear(): void;
values(): IterableIterator<T>;
}
class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
readonly #set = new Set<T>(); readonly #set = new Set<T>();
get size() { get size() {
@@ -187,12 +166,12 @@ class NativeAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
} }
} }
class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> { export class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
readonly #list: T[] = []; readonly #list: T[] = [];
readonly #equater: MaybeAsyncEqualityComparison<T>; readonly #equater: AsyncEqualityComparer<T>;
constructor(equater: MaybeAsyncEqualityComparison<T>) { constructor(equater: MaybeAsyncEqualityComparisonOrComparer<T>) {
this.#equater = equater; this.#equater = asAsyncEqualityComparer(equater);
} }
get size() { get size() {
@@ -223,7 +202,7 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
async contains(value: T) { async contains(value: T) {
for (const val of this.#list) { for (const val of this.#list) {
if (await this.#equater(value, val)) { if (await this.#equater.equals(value, val)) {
return true; return true;
} }
} }
@@ -235,7 +214,7 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
const length = this.#list.length; const length = this.#list.length;
for (let i = 0; i < length; i++) { for (let i = 0; i < length; i++) {
if (await this.#equater(value, this.#list[i])) { if (await this.#equater.equals(value, this.#list[i])) {
this.#list.splice(i, 1); this.#list.splice(i, 1);
return true; return true;
} }
@@ -256,7 +235,3 @@ class CustomAsyncEqualitySet<T> implements AsyncEqualitySet<T> {
return this.#list[Symbol.iterator](); return this.#list[Symbol.iterator]();
} }
} }
export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEqualityComparison<T>): AsyncEqualitySet<T> {
return equater ? new CustomAsyncEqualitySet(equater) : new NativeAsyncEqualitySet<T>();
}

11
src/equality-set/index.ts Normal file
View File

@@ -0,0 +1,11 @@
import { EqualityComparisonOrComparer, MaybeAsyncEqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { CustomAsyncEqualitySet, CustomEqualitySet, NativeAsyncEqualitySet, NativeEqualitySet } from "./impl.js";
import { AsyncEqualitySet, EqualitySet } from "./types.js";
export function createEqualitySet<T>(equater?: EqualityComparisonOrComparer<T>): EqualitySet<T> {
return equater ? new CustomEqualitySet(equater) : new NativeEqualitySet<T>();
}
export function createAsyncEqualitySet<T>(equater?: MaybeAsyncEqualityComparisonOrComparer<T>): AsyncEqualitySet<T> {
return equater ? new CustomAsyncEqualitySet(equater) : new NativeAsyncEqualitySet<T>();
}

21
src/equality-set/types.ts Normal file
View File

@@ -0,0 +1,21 @@
import { MaybeAsyncIterable } from "../types.js";
export interface EqualitySet<T> extends Iterable<T> {
readonly size: number;
add(value: T): boolean;
addAll(values: Iterable<T>): number;
contains(value: T): boolean;
remove(value: T): boolean;
clear(): void;
values(): IterableIterator<T>;
}
export interface AsyncEqualitySet<T> extends Iterable<T> {
readonly size: number;
add(value: T): Promise<boolean>;
addAll(values: MaybeAsyncIterable<T>): Promise<number>;
contains(value: T): Promise<boolean>;
remove(value: T): Promise<boolean>;
clear(): void;
values(): IterableIterator<T>;
}

9
src/index.ts
View File

@@ -15,5 +15,12 @@ export * as Comparers from "./comparer/sync.js";
export { BaseAsyncComparer } from "./comparer/async.js"; export { BaseAsyncComparer } from "./comparer/async.js";
export * as AsyncComparers from "./comparer/async.js"; export * as AsyncComparers from "./comparer/async.js";
export * from "./comparer/types.js"; export * from "./comparer/types.js";
export * as EqualityComparers from "./equality-comparer/index.js"; export { BaseEqualityComparer } from "./equality-comparer/sync.js";
export * as EqualityComparers from "./equality-comparer/sync.js";
export { BaseAsyncEqualityComparer } from "./equality-comparer/async.js";
export * as AsyncEqualityComparers from "./equality-comparer/async.js";
export * from "./equality-comparer/types.js"; export * from "./equality-comparer/types.js";
export * as EqualityMaps from "./equality-map/index.js";
export * from "./equality-map/types.js";
export * as EqualitySets from "./equality-set/index.js";
export * from "./equality-set/types.js";

14
src/random/index.ts
View File

@@ -1,6 +1,6 @@
import { BitArray } from "../bitarray/index.js"; import { BitArray } from "../bitarray/index.js";
import { asArray } from "../utils.js"; import { asArray } from "../utils.js";
import { AsyncRandomOptions, ElementPredicate, ElementWeight, RandomGenerator, RandomOptions } from "./types.js"; import { AsyncRandomOptions, ElementPredicate, ElementWeight, RandomElement, RandomGenerator, RandomOptions } from "./types.js";
export const alwaysTrue: ElementPredicate = () => true; export const alwaysTrue: ElementPredicate = () => true;
export const weightOfOne: ElementWeight = () => 1.0; export const weightOfOne: ElementWeight = () => 1.0;
@@ -45,9 +45,10 @@ function withDefaultOptions<T>(options: RandomOptions<T> | AsyncRandomOptions<T>
}; };
} }
function _getRandomElement<T>(sequence: Iterable<T>, options: Required<RandomOptions<T>>) { function _getRandomElement<T>(sequence: Iterable<T>, options: Required<RandomOptions<T>>): RandomElement<T> {
const { predicate, weight, random } = options; const { predicate, weight, random } = options;
let found = false;
let result: T | undefined = undefined; let result: T | undefined = undefined;
let resultIndex = -1; let resultIndex = -1;
let index = 0; let index = 0;
@@ -66,22 +67,24 @@ function _getRandomElement<T>(sequence: Iterable<T>, options: Required<RandomOpt
weightAcc += w; weightAcc += w;
if (random() * weightAcc < w) { if (random() * weightAcc < w) {
found = true;
result = element; result = element;
resultIndex = currentIndex; resultIndex = currentIndex;
} }
} }
} }
return { element: result, index: resultIndex }; return { found, element: result, index: resultIndex } as RandomElement<T>;
} }
export function getRandomElement<T>(sequence: Iterable<T>, options?: RandomOptions<T>) { export function getRandomElement<T>(sequence: Iterable<T>, options?: RandomOptions<T>) {
return _getRandomElement(sequence, withDefaultOptions(options)); return _getRandomElement(sequence, withDefaultOptions(options));
} }
async function _getRandomElementAsync<T>(sequence: AsyncIterable<T>, options: Required<AsyncRandomOptions<T>>) { async function _getRandomElementAsync<T>(sequence: AsyncIterable<T>, options: Required<AsyncRandomOptions<T>>): Promise<RandomElement<T>> {
const { predicate, weight, random } = options; const { predicate, weight, random } = options;
let found = false;
let result: T | undefined = undefined; let result: T | undefined = undefined;
let resultIndex = -1; let resultIndex = -1;
let index = 0; let index = 0;
@@ -100,13 +103,14 @@ async function _getRandomElementAsync<T>(sequence: AsyncIterable<T>, options: Re
weightAcc += w; weightAcc += w;
if (random() * weightAcc < w) { if (random() * weightAcc < w) {
found = true;
result = element; result = element;
resultIndex = currentIndex; resultIndex = currentIndex;
} }
} }
} }
return { element: result, index: resultIndex }; return { found, element: result, index: resultIndex } as RandomElement<T>;
} }
export async function getRandomElementAsync<T>(sequence: AsyncIterable<T>, options?: AsyncRandomOptions<T>) { export async function getRandomElementAsync<T>(sequence: AsyncIterable<T>, options?: AsyncRandomOptions<T>) {

16
src/random/types.ts
View File

@@ -4,7 +4,7 @@ export type ElementPredicate<T = any> = (index: number, obj: T) => boolean;
export type ElementWeight<T = any> = (index: number, obj: T) => number; export type ElementWeight<T = any> = (index: number, obj: T) => number;
export type RandomGenerator = () => number; export type RandomGenerator = () => number;
export interface RandomOptions<T = any> { export type RandomOptions<T = any> = {
predicate?: ElementPredicate<T>; predicate?: ElementPredicate<T>;
weight?: ElementWeight<T>; weight?: ElementWeight<T>;
random?: RandomGenerator; random?: RandomGenerator;
@@ -13,8 +13,20 @@ export interface RandomOptions<T = any> {
export type MaybeAsyncElementPredicate<T = any> = MaybeAsyncFunction<ElementPredicate<T>>; export type MaybeAsyncElementPredicate<T = any> = MaybeAsyncFunction<ElementPredicate<T>>;
export type MaybeAsyncElementWeight<T = any> = MaybeAsyncFunction<ElementWeight<T>>; export type MaybeAsyncElementWeight<T = any> = MaybeAsyncFunction<ElementWeight<T>>;
export interface AsyncRandomOptions<T = any> { export type AsyncRandomOptions<T = any> = {
predicate?: MaybeAsyncElementPredicate<T>; predicate?: MaybeAsyncElementPredicate<T>;
weight?: MaybeAsyncElementWeight<T>; weight?: MaybeAsyncElementWeight<T>;
random?: RandomGenerator; random?: RandomGenerator;
}; };
type RandomElementFound<T> = {
found: true;
element: T;
index: number;
};
type RandomElementNotFound = {
found: false;
element: undefined;
index: -1;
};
export type RandomElement<T> = RandomElementFound<T> | RandomElementNotFound;

247
src/sync/impl.ts
View File

@@ -1,17 +1,17 @@
import { BaseAsyncSequence } from "../async/impl.js"; import { BaseAsyncSequence } from "../async/impl.js";
import { AsyncSequence } from "../async/types.js"; import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js"; import { Collector } from "../collector/types.js";
import { asComparer, combineNullableComparers, createComparerUsing, defaultComparer } from "../comparer/sync.js"; import { asComparer, combineComparers, createComparerUsing, defaultComparer } from "../comparer/sync.js";
import { ComparisonOrComparer, Comparer } from "../comparer/types.js"; import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
import { strictEquals, identity } from "../equality-comparer/index.js"; import { asEqualityComparer, defaultEqualityComparer } from "../equality-comparer/sync.js";
import { EqualityComparison } from "../equality-comparer/types.js"; import { EqualityComparer, EqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { createEqualityMap } from "../equality-map.js"; import { createEqualityMap } from "../equality-map/index.js";
import { createEqualitySet } from "../equality-set.js"; import { createEqualitySet } from "../equality-set/index.js";
import { createQueue } from "../queue.js"; import { createQueue } from "../queue.js";
import { getRandomElement } from "../random/index.js"; import { getRandomElement } from "../random/index.js";
import { RandomOptions } from "../random/types.js"; import { RandomOptions } from "../random/types.js";
import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js"; import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";
import { FindElementResult } from "../utils.js"; import { FindElementResult, identity } from "../utils.js";
import { array, empty, wrap } from "./index.js"; import { array, empty, wrap } from "./index.js";
import { Sequence, GroupedSequence, OrderedSequence, SequencePipeline } from "./types.js"; import { Sequence, GroupedSequence, OrderedSequence, SequencePipeline } from "./types.js";
@@ -50,25 +50,23 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new WhereSequence<TElement, any>(this, predicate); return new WhereSequence<TElement, any>(this, predicate);
} }
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>> { groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TResult>> {
return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer); return new GroupBySequence<TElement, TKey, TResult>(this, keySelector, elementSelector, keyComparer);
} }
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> { join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult> {
return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer); return new JoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult> { groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult> {
return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer); return new GroupJoinSequence<TElement, TOther, TKey, TResult>(this, wrap(sequence), firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
contains(obj: TElement, equater?: EqualityComparison<TElement>) { contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>) {
if (!equater) { equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
equater = strictEquals;
}
for (const element of this) { for (const element of this) {
if (equater(element, obj)) { if (equater.equals(element, obj)) {
return true; return true;
} }
} }
@@ -76,7 +74,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false; return false;
} }
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) { sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
if (this === sequence) { if (this === sequence) {
return true; return true;
} }
@@ -90,9 +88,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false; return false;
} }
if (!equater) { equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
equater = strictEquals;
}
const thisIterator = this.iterator(); const thisIterator = this.iterator();
const thatIterator = other.iterator(); const thatIterator = other.iterator();
@@ -109,7 +105,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return false; return false;
} }
if (!equater(thisNext.value, thatNext.value)) { if (!equater.equals(thisNext.value, thatNext.value)) {
return false; return false;
} }
} }
@@ -123,7 +119,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new PrependSequence<TElement>(this, obj); return new PrependSequence<TElement>(this, obj);
} }
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement> { remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
return new RemoveSequence<TElement>(this, obj, all, equater); return new RemoveSequence<TElement>(this, obj, all, equater);
} }
@@ -212,7 +208,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
const result = this.#tryGetFirst(predicate); const result = this.#tryGetFirst(predicate);
if (result.found) { if (result.found) {
return result.element!; return result.element;
} }
throw new Error("No element was found."); throw new Error("No element was found.");
@@ -225,34 +221,36 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
} }
#tryGetLast(predicate?: AnyPredicate<TElement>): FindElementResult<TElement> { #tryGetLast(predicate?: AnyPredicate<TElement>): FindElementResult<TElement> {
let found = false; let result: FindElementResult<TElement> = {
let result: TElement | undefined = undefined; found: false
};
if (predicate) { if (predicate) {
for (const element of this) { for (const element of this) {
if (predicate(element)) { if (predicate(element)) {
found = true; result = {
result = element; found: true,
element
};
} }
} }
} else { } else {
for (const element of this) { for (const element of this) {
found = true; result = {
result = element; found: true,
element
};
} }
} }
return { return result;
found,
element: result
} as FindElementResult<TElement>;
} }
last(predicate?: AnyPredicate<TElement>) { last(predicate?: AnyPredicate<TElement>) {
const result = this.#tryGetLast(predicate); const result = this.#tryGetLast(predicate);
if (result.found) { if (result.found) {
return result.element!; return result.element;
} }
throw new Error("No element was found."); throw new Error("No element was found.");
@@ -316,7 +314,7 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
const result = this.#tryGetSingle(predicate); const result = this.#tryGetSingle(predicate);
if (result.found) { if (result.found) {
return result.element!; return result.element;
} }
let reason: string; let reason: string;
@@ -525,27 +523,27 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new OrderBySequence<TElement, TBy>(this, true, selector, comparer); return new OrderBySequence<TElement, TBy>(this, true, selector, comparer);
} }
partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>> { partition(equater?: EqualityComparisonOrComparer<TElement>): Sequence<Sequence<TElement>> {
return new PartitionSequence<TElement>(this, equater); return new PartitionSequence<TElement>(this, equater);
} }
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>> { partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<Sequence<TElement>> {
return new PartitionBySequence<TElement, TBy>(this, selector, equater); return new PartitionBySequence<TElement, TBy>(this, selector, equater);
} }
distinct(equater?: EqualityComparison<TElement>): Sequence<TElement> { distinct(equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
return new DistinctSequence<TElement>(this, equater); return new DistinctSequence<TElement>(this, equater);
} }
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> { distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement> {
return new DistinctBySequence<TElement, TBy>(this, selector, equater); return new DistinctBySequence<TElement, TBy>(this, selector, equater);
} }
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement> { union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement> {
return new UnionSequence<TElement>(this, wrap(sequence), equater); return new UnionSequence<TElement>(this, wrap(sequence), equater);
} }
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement> { unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement> {
return new UnionBySequence<TElement, TBy>(this, wrap(sequence), selector, equater); return new UnionBySequence<TElement, TBy>(this, wrap(sequence), selector, equater);
} }
@@ -675,6 +673,10 @@ export abstract class BaseSequence<TElement> extends SequenceMarker implements S
return new ZippedSequence<TElement, TOther>(this, wrap(sequence)); return new ZippedSequence<TElement, TOther>(this, wrap(sequence));
} }
cartesianProduct<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]> {
return new CartesianProductSequence<TElement, TOther>(this, wrap(sequence));
}
indexed(): Sequence<[number, TElement]> { indexed(): Sequence<[number, TElement]> {
return new IndexedSequence<TElement>(this); return new IndexedSequence<TElement>(this);
} }
@@ -831,29 +833,29 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.where(predicate); return this.#sequence.where(predicate);
} }
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>; groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>; groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TKey, TResult>>;
groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) { groupBy(keySelector: any, elementSelector?: any, keyComparer?: any) {
return this.#sequence.groupBy(keySelector, elementSelector, keyComparer); return this.#sequence.groupBy(keySelector, elementSelector, keyComparer);
} }
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<[TElement, TOther]>; join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<TResult>; join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<TResult>;
join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) { join(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer); return this.#sequence.join(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>; groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey> | undefined): Sequence<TResult>; groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey> | undefined): Sequence<TResult>;
groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) { groupJoin(sequence: any, firstKeySelector: any, secondKeySelector: any, resultSelector?: any, keyComparer?: any) {
return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer); return this.#sequence.groupJoin(sequence, firstKeySelector, secondKeySelector, resultSelector, keyComparer);
} }
contains(obj: TElement, equater?: EqualityComparison<TElement>) { contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.contains(obj, equater); return this.#sequence.contains(obj, equater);
} }
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) { sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.sequenceEquals(sequence, equater); return this.#sequence.sequenceEquals(sequence, equater);
} }
@@ -865,7 +867,7 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.prepend(obj); return this.#sequence.prepend(obj);
} }
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>) { remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.remove(obj, all, equater); return this.#sequence.remove(obj, all, equater);
} }
@@ -949,43 +951,43 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.orderByDescending(selector, comparer); return this.#sequence.orderByDescending(selector, comparer);
} }
partition(equater?: EqualityComparison<TElement> | undefined): Sequence<Sequence<TElement>> { partition(equater?: EqualityComparisonOrComparer<TElement> | undefined): Sequence<Sequence<TElement>> {
return this.#sequence.partition(equater); return this.#sequence.partition(equater);
} }
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy> | undefined): Sequence<Sequence<TElement>> { partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy> | undefined): Sequence<Sequence<TElement>> {
return this.#sequence.partitionBy(selector, equater); return this.#sequence.partitionBy(selector, equater);
} }
distinct(equater?: EqualityComparison<TElement>) { distinct(equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.distinct(equater); return this.#sequence.distinct(equater);
} }
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) { distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.distinctBy(selector, equater); return this.#sequence.distinctBy(selector, equater);
} }
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) { union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.union(sequence, equater); return this.#sequence.union(sequence, equater);
} }
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) { unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.unionBy(sequence, selector, equater); return this.#sequence.unionBy(sequence, selector, equater);
} }
except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) { except(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.except(sequence, equater); return this.#sequence.except(sequence, equater);
} }
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) { exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.exceptBy(sequence, selector, equater); return this.#sequence.exceptBy(sequence, selector, equater);
} }
intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>) { intersect(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>) {
return this.#sequence.intersect(sequence, equater); return this.#sequence.intersect(sequence, equater);
} }
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>) { intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>) {
return this.#sequence.intersectBy(sequence, selector, equater); return this.#sequence.intersectBy(sequence, selector, equater);
} }
@@ -1041,6 +1043,10 @@ export class DelegatedSequence<TElement> extends SequenceMarker implements Seque
return this.#sequence.zip(sequence); return this.#sequence.zip(sequence);
} }
cartesianProduct<TOther>(sequence: Iterable<TOther>) {
return this.#sequence.cartesianProduct(sequence);
}
indexed() { indexed() {
return this.#sequence.indexed(); return this.#sequence.indexed();
} }
@@ -1368,9 +1374,10 @@ export class WrappedArray<T> extends BaseSequence<T> {
return this.#array.length; return this.#array.length;
} }
override contains(obj: T, equater?: EqualityComparison<T>): boolean { override contains(obj: T, equater?: EqualityComparisonOrComparer<T>): boolean {
if (equater) { if (equater) {
return this.#array.some(x => equater(x, obj)); const equalityComparer = asEqualityComparer(equater);
return this.#array.some(x => equalityComparer.equals(x, obj));
} }
return this.#array.includes(obj); return this.#array.includes(obj);
@@ -1464,7 +1471,7 @@ export class WrappedSet<T> extends BaseSequence<T> {
return this.#set.size; return this.#set.size;
} }
override contains(obj: T, equater?: EqualityComparison<T>) { override contains(obj: T, equater?: EqualityComparisonOrComparer<T>) {
if (equater) { if (equater) {
return super.contains(obj, equater); return super.contains(obj, equater);
} }
@@ -1494,7 +1501,7 @@ export class WrappedMap<K, V> extends BaseSequence<[K, V]> {
return this.#map.size; return this.#map.size;
} }
override contains(obj: [K, V], equater?: EqualityComparison<[K, V]>) { override contains(obj: [K, V], equater?: EqualityComparisonOrComparer<[K, V]>) {
if (equater) { if (equater) {
return super.contains(obj, equater); return super.contains(obj, equater);
} }
@@ -1603,9 +1610,9 @@ export class ConcatSequence<T> extends BaseSequence<T> {
class DistinctSequence<T> extends BaseSequence<T> { class DistinctSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>; readonly #sequence: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined; readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(sequence: Sequence<T>, equater?: EqualityComparison<T>) { constructor(sequence: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
@@ -1630,9 +1637,9 @@ class DistinctSequence<T> extends BaseSequence<T> {
class DistinctBySequence<T, U> extends BaseSequence<T> { class DistinctBySequence<T, U> extends BaseSequence<T> {
readonly #sequence: Sequence<T>; readonly #sequence: Sequence<T>;
readonly #converter: Converter<T, U>; readonly #converter: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined; readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: EqualityComparison<U>) { constructor(sequence: Sequence<T>, converter: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
@@ -1967,13 +1974,13 @@ class OrderBySequence<T, U> extends BaseOrderedSequence<T> {
class ThenOrderSequence<T> extends BaseOrderedSequence<T> { class ThenOrderSequence<T> extends BaseOrderedSequence<T> {
constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: ComparisonOrComparer<T>) { constructor(sequence: OrderedSequence<T>, descending: boolean, sorter?: ComparisonOrComparer<T>) {
super(sequence, combineNullableComparers([sequence.comparer, sorter]), descending); super(sequence, combineComparers([sequence.comparer, sorter]), descending);
} }
} }
class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> { class ThenOrderBySequence<T, U> extends BaseOrderedSequence<T> {
constructor(sequence: OrderedSequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: ComparisonOrComparer<U>) { constructor(sequence: OrderedSequence<T>, descending: boolean, selector: Converter<T, U>, sorter?: ComparisonOrComparer<U>) {
super(sequence, combineNullableComparers([sequence.comparer, createComparerUsing(selector, sorter)]), descending); super(sequence, combineComparers([sequence.comparer, createComparerUsing(selector, sorter)]), descending);
} }
} }
@@ -2095,12 +2102,52 @@ export class ZippedSequence<T, U> extends BaseSequence<[T, U]> {
} }
} }
export class CartesianProductSequence<T, U> extends BaseSequence<[T, U]> {
readonly #first: Sequence<T>;
readonly #second: Sequence<U>;
constructor(first: Sequence<T>, second: Sequence<U>) {
super();
this.#first = first;
this.#second = second;
}
override nonEnumeratedCount() {
const n1 = this.#first.nonEnumeratedCount();
if (n1 < 0) {
return -1;
}
const n2 = this.#second.nonEnumeratedCount();
if (n2 < 0) {
return -1;
}
return n1 * n2;
}
override maxCount() {
return this.#first.maxCount() * this.#second.maxCount();
}
override *iterator() {
for (const firstObj of this.#first) {
for (const secondObj of this.#second) {
yield [firstObj, secondObj] as [T, U];
}
}
}
}
class UnionSequence<T> extends BaseSequence<T> { class UnionSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>; readonly #first: Sequence<T>;
readonly #second: Sequence<T>; readonly #second: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined; readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) { constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2132,9 +2179,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>; readonly #first: Sequence<T>;
readonly #second: Sequence<T>; readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>; readonly #selector: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined; readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) { constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2166,9 +2213,9 @@ class UnionBySequence<T, U> extends BaseSequence<T> {
class ExceptSequence<T> extends BaseSequence<T> { class ExceptSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>; readonly #first: Sequence<T>;
readonly #second: Sequence<T>; readonly #second: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined; readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) { constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2199,9 +2246,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>; readonly #first: Sequence<T>;
readonly #second: Sequence<T>; readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>; readonly #selector: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined; readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) { constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2232,9 +2279,9 @@ class ExceptBySequence<T, U> extends BaseSequence<T> {
class IntersectSequence<T> extends BaseSequence<T> { class IntersectSequence<T> extends BaseSequence<T> {
readonly #first: Sequence<T>; readonly #first: Sequence<T>;
readonly #second: Sequence<T>; readonly #second: Sequence<T>;
readonly #equater: EqualityComparison<T> | undefined; readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparison<T>) { constructor(first: Sequence<T>, second: Sequence<T>, equater?: EqualityComparisonOrComparer<T>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2263,9 +2310,9 @@ class IntersectBySequence<T, U> extends BaseSequence<T> {
readonly #first: Sequence<T>; readonly #first: Sequence<T>;
readonly #second: Sequence<T>; readonly #second: Sequence<T>;
readonly #selector: Converter<T, U>; readonly #selector: Converter<T, U>;
readonly #equater: EqualityComparison<U> | undefined; readonly #equater: EqualityComparisonOrComparer<U> | undefined;
constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparison<U>) { constructor(first: Sequence<T>, second: Sequence<T>, selector: Converter<T, U>, equater?: EqualityComparisonOrComparer<U>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2327,9 +2374,9 @@ class GroupBySequence<TElement, TKey, TResult> extends BaseSequence<GroupedSeque
readonly #sequence: Sequence<TElement>; readonly #sequence: Sequence<TElement>;
readonly #keySelector: Converter<TElement, TKey>; readonly #keySelector: Converter<TElement, TKey>;
readonly #elementSelector: Converter<TElement, TResult>; readonly #elementSelector: Converter<TElement, TResult>;
readonly #keyEquater: EqualityComparison<TKey> | undefined; readonly #keyEquater: EqualityComparisonOrComparer<TKey> | undefined;
constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: EqualityComparison<TKey>) { constructor(sequence: Sequence<TElement>, keySelector: Converter<TElement, TKey>, elementSelector?: Converter<TElement, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
@@ -2446,9 +2493,9 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
readonly #firstKeySelector: Converter<TOuter, TKey>; readonly #firstKeySelector: Converter<TOuter, TKey>;
readonly #secondKeySelector: Converter<TInner, TKey>; readonly #secondKeySelector: Converter<TInner, TKey>;
readonly #resultSelector: BiConverter<TOuter, TInner, TResult>; readonly #resultSelector: BiConverter<TOuter, TInner, TResult>;
readonly #keyEquater: EqualityComparison<TKey>; readonly #keyEquater: EqualityComparer<TKey>;
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: EqualityComparison<TKey>) { constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, TInner, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2456,7 +2503,7 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
this.#firstKeySelector = firstKeySelector; this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector; this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? JoinSequence.#defaultResultSelector as BiConverter<TOuter, TInner, TResult>; this.#resultSelector = resultSelector ?? JoinSequence.#defaultResultSelector as BiConverter<TOuter, TInner, TResult>;
this.#keyEquater = keyEquater ?? strictEquals; this.#keyEquater = keyEquater ? asEqualityComparer(keyEquater) : defaultEqualityComparer;
} }
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: TInner): [TOuter, TInner] { static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: TInner): [TOuter, TInner] {
@@ -2474,7 +2521,7 @@ class JoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TResult>
for (const secondObj of this.#second) { for (const secondObj of this.#second) {
const secondKey = this.#secondKeySelector(secondObj); const secondKey = this.#secondKeySelector(secondObj);
if (this.#keyEquater(firstKey, secondKey)) { if (this.#keyEquater.equals(firstKey, secondKey)) {
yield this.#resultSelector(firstObj, secondObj); yield this.#resultSelector(firstObj, secondObj);
} }
} }
@@ -2488,9 +2535,9 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
readonly #firstKeySelector: Converter<TOuter, TKey>; readonly #firstKeySelector: Converter<TOuter, TKey>;
readonly #secondKeySelector: Converter<TInner, TKey>; readonly #secondKeySelector: Converter<TInner, TKey>;
readonly #resultSelector: BiConverter<TOuter, Sequence<TInner>, TResult>; readonly #resultSelector: BiConverter<TOuter, Sequence<TInner>, TResult>;
readonly #keyEquater: EqualityComparison<TKey>; readonly #keyEquater: EqualityComparer<TKey>;
constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: EqualityComparison<TKey>) { constructor(first: Sequence<TOuter>, second: Sequence<TInner>, firstKeySelector: Converter<TOuter, TKey>, secondKeySelector: Converter<TInner, TKey>, resultSelector?: BiConverter<TOuter, Sequence<TInner>, TResult>, keyEquater?: EqualityComparisonOrComparer<TKey>) {
super(); super();
this.#first = first; this.#first = first;
@@ -2498,7 +2545,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
this.#firstKeySelector = firstKeySelector; this.#firstKeySelector = firstKeySelector;
this.#secondKeySelector = secondKeySelector; this.#secondKeySelector = secondKeySelector;
this.#resultSelector = resultSelector ?? GroupJoinSequence.#defaultResultSelector as BiConverter<TOuter, Sequence<TInner>, TResult>; this.#resultSelector = resultSelector ?? GroupJoinSequence.#defaultResultSelector as BiConverter<TOuter, Sequence<TInner>, TResult>;
this.#keyEquater = keyEquater ?? strictEquals; this.#keyEquater = keyEquater ? asEqualityComparer(keyEquater) : defaultEqualityComparer;
} }
static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: Sequence<TInner>) { static #defaultResultSelector<TOuter, TInner>(first: TOuter, second: Sequence<TInner>) {
@@ -2521,7 +2568,7 @@ class GroupJoinSequence<TOuter, TInner, TKey, TResult> extends BaseSequence<TRes
for (const secondObj of this.#second) { for (const secondObj of this.#second) {
const secondKey = this.#secondKeySelector(secondObj); const secondKey = this.#secondKeySelector(secondObj);
if (this.#keyEquater(firstKey, secondKey)) { if (this.#keyEquater.equals(firstKey, secondKey)) {
secondObjs.push(secondObj); secondObjs.push(secondObj);
} }
} }
@@ -2535,15 +2582,15 @@ class RemoveSequence<T> extends BaseSequence<T> {
readonly #sequence: Sequence<T>; readonly #sequence: Sequence<T>;
readonly #obj: T; readonly #obj: T;
readonly #all: boolean; readonly #all: boolean;
readonly #equater: EqualityComparison<T>; readonly #equater: EqualityComparer<T>;
constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: EqualityComparison<T>) { constructor(sequence: Sequence<T>, obj: T, all?: boolean, equater?: EqualityComparisonOrComparer<T>) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
this.#obj = obj; this.#obj = obj;
this.#all = all ?? false; this.#all = all ?? false;
this.#equater = equater ?? strictEquals; this.#equater = equater ? asEqualityComparer(equater) : defaultEqualityComparer;
} }
override maxCount() { override maxCount() {
@@ -2554,7 +2601,7 @@ class RemoveSequence<T> extends BaseSequence<T> {
let gotOne = false; let gotOne = false;
for (const obj of this.#sequence) { for (const obj of this.#sequence) {
if (this.#equater(this.#obj, obj)) { if (this.#equater.equals(this.#obj, obj)) {
if (this.#all) { if (this.#all) {
continue; continue;
} }
@@ -2598,13 +2645,13 @@ class CacheSequence<T> extends BaseSequence<T> {
class PartitionSequence<T> extends BaseSequence<Sequence<T>> { class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
readonly #sequence: Sequence<T>; readonly #sequence: Sequence<T>;
readonly #equater: EqualityComparison<T>; readonly #equater: EqualityComparisonOrComparer<T> | undefined;
constructor(sequence: Sequence<T>, equater: EqualityComparison<T> | undefined) { constructor(sequence: Sequence<T>, equater: EqualityComparisonOrComparer<T> | undefined) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
this.#equater = equater ?? strictEquals; this.#equater = equater;
} }
override *iterator() { override *iterator() {
@@ -2629,14 +2676,14 @@ class PartitionSequence<T> extends BaseSequence<Sequence<T>> {
class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>> { class PartitionBySequence<TElement, TBy> extends BaseSequence<Sequence<TElement>> {
readonly #sequence: Sequence<TElement>; readonly #sequence: Sequence<TElement>;
readonly #selector: Converter<TElement, TBy>; readonly #selector: Converter<TElement, TBy>;
readonly #equater: EqualityComparison<TBy>; readonly #equater: EqualityComparisonOrComparer<TBy> | undefined;
constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: EqualityComparison<TBy> | undefined) { constructor(sequence: Sequence<TElement>, selector: Converter<TElement, TBy>, equater: EqualityComparisonOrComparer<TBy> | undefined) {
super(); super();
this.#sequence = sequence; this.#sequence = sequence;
this.#selector = selector; this.#selector = selector;
this.#equater = equater ?? strictEquals; this.#equater = equater;
} }
override *iterator() { override *iterator() {

24
src/sync/index.ts
View File

@@ -9,7 +9,7 @@ export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
} }
if (Array.isArray(iterable)) { if (Array.isArray(iterable)) {
return array(iterable); return array<T>(iterable);
} }
if (iterable instanceof Set) { if (iterable instanceof Set) {
@@ -20,7 +20,7 @@ export function wrap<T = any>(iterable: Iterable<T>): Sequence<T> {
return map(iterable) as unknown as Sequence<T>; return map(iterable) as unknown as Sequence<T>;
} }
return sequence(iterable); return sequence<T>(iterable);
} }
export function sequence<T = any>(iterable: Iterable<T>): Sequence<T> { export function sequence<T = any>(iterable: Iterable<T>): Sequence<T> {
@@ -62,10 +62,6 @@ export function of<T>(...elements: T[]): Sequence<T> {
} }
} }
export function ofPropertyKeys<T extends PropertyKey>(...elements: T[]): Sequence<T> {
return of(...elements);
}
export function entries<T>(o: Record<string, T> | ArrayLike<T>): Sequence<[string, T]> { export function entries<T>(o: Record<string, T> | ArrayLike<T>): Sequence<[string, T]> {
return array(Object.entries(o)); return array(Object.entries(o));
} }
@@ -74,7 +70,9 @@ export function keys(o: object): Sequence<string> {
return array(Object.keys(o)); return array(Object.keys(o));
} }
export function values(o: object): Sequence<any> { export function values(o: object): Sequence<any>;
export function values<T>(o: Record<any, T> | ArrayLike<T>): Sequence<T>;
export function values(o: object) {
return array(Object.values(o)); return array(Object.values(o));
} }
@@ -86,9 +84,9 @@ export function generator<T>(generator: () => Iterable<T>): Sequence<T> {
return new GeneratorSequence(generator); return new GeneratorSequence(generator);
} }
export function range(max: number): Sequence<number> export function range(max: number): Sequence<number>;
export function range(min: number, max: number): Sequence<number> export function range(min: number, max: number): Sequence<number>;
export function range(min: number, max: number, step: number): Sequence<number> export function range(min: number, max: number, step: number): Sequence<number>;
export function range(a: number, b?: number, c?: number): Sequence<number> { export function range(a: number, b?: number, c?: number): Sequence<number> {
if (b === undefined) { if (b === undefined) {
b = a; b = a;
@@ -102,9 +100,9 @@ export function range(a: number, b?: number, c?: number): Sequence<number> {
return new RangeSequence(a, b, c); return new RangeSequence(a, b, c);
} }
export function bigintRange(max: bigint): Sequence<bigint> export function bigintRange(max: bigint): Sequence<bigint>;
export function bigintRange(min: bigint, max: bigint): Sequence<bigint> export function bigintRange(min: bigint, max: bigint): Sequence<bigint>;
export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint> export function bigintRange(min: bigint, max: bigint, step: bigint): Sequence<bigint>;
export function bigintRange(a: bigint, b?: bigint, c?: bigint): Sequence<bigint> { export function bigintRange(a: bigint, b?: bigint, c?: bigint): Sequence<bigint> {
if (b === undefined) { if (b === undefined) {
b = a; b = a;

42
src/sync/types.ts
View File

@@ -1,11 +1,12 @@
import { AsyncSequence } from "../async/types.js"; import { AsyncSequence } from "../async/types.js";
import { Collector } from "../collector/types.js"; import { Collector } from "../collector/types.js";
import { ComparisonOrComparer, Comparer } from "../comparer/types.js"; import { ComparisonOrComparer, Comparer } from "../comparer/types.js";
import { EqualityComparison } from "../equality-comparer/types.js"; import { EqualityComparisonOrComparer } from "../equality-comparer/types.js";
import { RandomOptions } from "../random/types.js"; import { RandomOptions } from "../random/types.js";
import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js"; import { AnyPredicate, Converter, TypePredicate, BiConverter, Accumulator, Action } from "../types.js";
export type SequencePipeline<TElement, TResult> = (sequence: Sequence<TElement>) => TResult; export type SequencePipeline<TElement, TResult> = (sequence: Sequence<TElement>) => TResult;
export type SequenceElement<TSequence extends Sequence<any>> = TSequence extends Sequence<infer TElement> ? TElement : never;
export interface Sequence<TElement> extends Iterable<TElement> { export interface Sequence<TElement> extends Iterable<TElement> {
iterator(): Iterator<TElement>; iterator(): Iterator<TElement>;
@@ -25,24 +26,24 @@ export interface Sequence<TElement> extends Iterable<TElement> {
where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>; where<TFiltered extends TElement>(predicate: TypePredicate<TElement, TFiltered>): Sequence<TFiltered>;
where(predicate: AnyPredicate<TElement>): Sequence<TElement>; where(predicate: AnyPredicate<TElement>): Sequence<TElement>;
groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TElement>>; groupBy<TKey>(keySelector: Converter<TElement, TKey>, elementSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TElement>>;
groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TKey, TResult>>; groupBy<TKey, TResult>(keySelector: Converter<TElement, TKey>, elementSelector: Converter<TElement, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TKey, TResult>>;
join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<[TElement, TOther]>; join<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<[TElement, TOther]>;
join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>; join<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, TOther, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;
groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparison<TKey>): Sequence<GroupedSequence<TElement, TOther>>; groupJoin<TOther, TKey>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector?: undefined, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<GroupedSequence<TElement, TOther>>;
groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparison<TKey>): Sequence<TResult>; groupJoin<TOther, TKey, TResult>(sequence: Iterable<TOther>, firstKeySelector: Converter<TElement, TKey>, secondKeySelector: Converter<TOther, TKey>, resultSelector: BiConverter<TElement, Iterable<TOther>, TResult>, keyComparer?: EqualityComparisonOrComparer<TKey>): Sequence<TResult>;
contains(obj: TElement, equater?: EqualityComparison<TElement>): boolean; contains(obj: TElement, equater?: EqualityComparisonOrComparer<TElement>): boolean;
sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): boolean; sequenceEquals(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): boolean;
append(obj: TElement): Sequence<TElement>; append(obj: TElement): Sequence<TElement>;
prepend(obj: TElement): Sequence<TElement>; prepend(obj: TElement): Sequence<TElement>;
remove(obj: TElement, all?: boolean, equater?: EqualityComparison<TElement>): Sequence<TElement>; remove(obj: TElement, all?: boolean, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
concat(...sequences: Iterable<TElement>[]): Sequence<TElement>; concat(...sequences: Iterable<TElement>[]): Sequence<TElement>;
@@ -77,20 +78,20 @@ export interface Sequence<TElement> extends Iterable<TElement> {
orderDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>; orderDescending(comparer?: ComparisonOrComparer<TElement>): OrderedSequence<TElement>;
orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>; orderByDescending<TBy>(selector: Converter<TElement, TBy>, comparer?: ComparisonOrComparer<TBy>): OrderedSequence<TElement>;
partition(equater?: EqualityComparison<TElement>): Sequence<Sequence<TElement>>; partition(equater?: EqualityComparisonOrComparer<TElement>): Sequence<Sequence<TElement>>;
partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<Sequence<TElement>>; partitionBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<Sequence<TElement>>;
distinct(equater?: EqualityComparison<TElement>): Sequence<TElement>; distinct(equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>; distinctBy<TBy>(selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
union(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>; union(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>; unionBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
except(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>; except(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>; exceptBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
intersect(sequence: Iterable<TElement>, equater?: EqualityComparison<TElement>): Sequence<TElement>; intersect(sequence: Iterable<TElement>, equater?: EqualityComparisonOrComparer<TElement>): Sequence<TElement>;
intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparison<TBy>): Sequence<TElement>; intersectBy<TBy>(sequence: Iterable<TElement>, selector: Converter<TElement, TBy>, equater?: EqualityComparisonOrComparer<TBy>): Sequence<TElement>;
all(predicate: AnyPredicate<TElement>): boolean; all(predicate: AnyPredicate<TElement>): boolean;
any(predicate: AnyPredicate<TElement>): boolean; any(predicate: AnyPredicate<TElement>): boolean;
@@ -111,6 +112,7 @@ export interface Sequence<TElement> extends Iterable<TElement> {
forEach(action: Action<TElement>): void; forEach(action: Action<TElement>): void;
zip<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>; zip<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>;
cartesianProduct<TOther>(sequence: Iterable<TOther>): Sequence<[TElement, TOther]>;
indexed(): Sequence<[number, TElement]>; indexed(): Sequence<[number, TElement]>;

5
src/utils.ts
View File

@@ -12,6 +12,10 @@ export function asArray<T>(iterable: Iterable<T>) {
return Array.isArray(iterable) ? <T[]>iterable : Array.from(iterable); return Array.isArray(iterable) ? <T[]>iterable : Array.from(iterable);
} }
export function identity<T>(obj: T) {
return obj;
}
class WrappedAsyncIterator<T> implements AsyncIterable<T> { class WrappedAsyncIterator<T> implements AsyncIterable<T> {
readonly #iterator: AsyncIterator<T>; readonly #iterator: AsyncIterator<T>;
@@ -56,7 +60,6 @@ type FindElementSuccess<T> = {
}; };
type FindElementFail = { type FindElementFail = {
found: false; found: false;
element?: never;
reason?: number; reason?: number;
}; };
export type FindElementResult<T> = FindElementSuccess<T> | FindElementFail; export type FindElementResult<T> = FindElementSuccess<T> | FindElementFail;

21
tsconfig.json
View File

@@ -1,22 +1,17 @@
{ {
"compilerOptions": { "compilerOptions": {
"module": "NodeNext", "module": "nodenext",
"target": "ESNext", "target": "esnext",
"moduleResolution": "nodenext", "moduleResolution": "nodenext",
"rootDir": "src", "lib": [
"outDir": "build", "ESNext"
"outFile": "build/index.ts", ],
"esModuleInterop": true, "types": ["node"],
"alwaysStrict": true, "alwaysStrict": true,
"strict": true, "strict": true,
"allowSyntheticDefaultImports": true, "rootDir": "./src"
"allowUnreachableCode": true,
"declaration": true,
"declarationMap": true,
"emitDeclarationOnly": true,
"composite": true
}, },
"include": [ "include": [
"src" "./src"
] ]
} }