diff --git a/quest/m3/README.md b/quest/m3/README.md index 1c986327b..f2b9b6a4a 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -33,5 +33,5 @@ generic std gap is planned here even when moq never calls it. - [Cow of a slice, and Wrapping](/quest/m3/ts-cow-slices.md) - `Cow<[T]>` and `Wrapping` translate, `PartialEq` included - [LinkedList](/quest/m3/ts-linked-list.md) - `LinkedList` and its methods translate - [Zip's next_back in constant time](/quest/m3/ts-zip-back.md) - a reversed zip of random-access iterators skips the longer side's excess at once -- [Unbounded ranges as iterators adaptors take](/quest/m3/ts-range-from-iter.md) - `iter.zip(0..)` and other adaptors taking a `start..` type-check - [Cloning std's iterators](/quest/m3/ts-iter-clone.md) - `clone` of std's iterators and adaptors translates, each clone reading on independently +- [Comparing iterators](/quest/m3/ts-iter-compare.md) - `eq`, `cmp`, `lt`, and the rest of `Iterator`'s comparisons translate against any `IntoIterator` diff --git a/quest/m3/ts-iter-clone.md b/quest/m3/ts-iter-clone.md index 1d29caea5..d4099bc16 100644 --- a/quest/m3/ts-iter-clone.md +++ b/quest/m3/ts-iter-clone.md @@ -3,8 +3,9 @@ ## Goal [rust2-ts](/ts/README.md) translates `clone` of std's iterators and adaptors, such as a -`zip`, a `map`, a `chars`, and a set operation's iterator, the clone reading on from where -the original was, independently of it, proven by differential tests against native Rust. +`zip`, a `map`, a `chars`, a `start..`, and a set operation's iterator, the clone reading +on from where the original was, independently of it, proven by differential tests against +native Rust. ## Plan diff --git a/quest/m3/ts-iter-compare.md b/quest/m3/ts-iter-compare.md new file mode 100644 index 000000000..6cf58ecbd --- /dev/null +++ b/quest/m3/ts-iter-compare.md @@ -0,0 +1,20 @@ +# [S] Comparing iterators + +## Goal + +[rust2-ts](/ts/README.md) translates `Iterator::eq`, `ne`, `lt`, `le`, `gt`, `ge`, `cmp`, +and `partial_cmp`, and their `_by` forms, against any `IntoIterator`, ranges included, +reading each side as far as std's does, proven by differential tests against native Rust. + +## Plan + +Found while auditing what takes a `start..` as its `IntoIterator`: each refuses today +whatever the iterators are. Planned without a moq consumer, under the maintainer's +2026-10-27 decision that rust2 aims to support all of std. + +- std's `eq` of two `TrustedLen` iterators decides by their size hints before reading + any item where they differ; test it beside a pair that is not both `TrustedLen`. +- Test where a side ends first, where one never ends, and where comparing an item + panics, as stepping a `start..` past its type's maximum does. + +Public API: the translator's output. diff --git a/quest/m3/ts-range-from-iter.md b/quest/m3/ts-range-from-iter.md deleted file mode 100644 index 8146842e8..000000000 --- a/quest/m3/ts-range-from-iter.md +++ /dev/null @@ -1,16 +0,0 @@ -# [S] Unbounded ranges as iterators adaptors take - -## Goal - -An unbounded `start..` that an adaptor takes as its `IntoIterator`, as `iter.zip(0..)` -does, translates to an iterator `tsc` accepts, proven by a differential test against -native Rust, including where `start` reaches its type's maximum. - -## Plan - -Found by `keys::arrays` in the lang fixture: `firsts.iter().zip(0..)` translates to -`rt.iterZip(rt.iterSlice(firsts), { start: 0 })`, which `tsc` rejects, since the range's -struct reaches `iterZip` in place of an `rt.Iter`. Audit every adaptor that takes an -`IntoIterator` (`zip`, `chain`, `extend`, `eq`, `cmp`) for the same. - -Public API: the translator's output. diff --git a/ts/MIGRATE.md b/ts/MIGRATE.md index 704b7a474..e0332ed4c 100644 --- a/ts/MIGRATE.md +++ b/ts/MIGRATE.md @@ -2,6 +2,11 @@ ## Unreleased +- A `start..` is an `rt.RangeFrom`, an iterator as `rt.Range` is, rather than + `{ start }`: a caller passes one as `new rt.RangeFrom(start, rt.u64Step)`, with its + integer type's `Step`, or `rt.charStep`, and none for other types. A binding taking one + still reads its `start`. An `rt.Range` or `rt.RangeInclusive` of `char`s takes + `rt.charStep` too, to step past the surrogates. - A closure, a `fn` pointer, a `dyn Fn`, or a function item as a value returns `undefined` for `()`, not `void`, as in `(a0: rt.u8) => undefined`: a caller passes such a parameter a function typed `=> undefined`. diff --git a/ts/fixtures/bind/expected/harness.ts b/ts/fixtures/bind/expected/harness.ts index acfa6aa8a..98078cfe1 100644 --- a/ts/fixtures/bind/expected/harness.ts +++ b/ts/fixtures/bind/expected/harness.ts @@ -19,7 +19,7 @@ export function run(input: rt.ByteSlice): rt.ByteVec { const bytes: Blob.Blob = Blob.copyFromSlice(input); const mid: rt.usize = rt.usizeDiv(Blob.len(bytes), 2); const head: Blob.Blob = Blob.slice(bytes, { end: mid }); - const tail: Blob.Blob = Blob.slice(bytes, { start: mid }); + const tail: Blob.Blob = Blob.slice(bytes, new rt.RangeFrom(mid, rt.usizeStep)); const _16: rt.Range = new rt.Range(rt.min(1, mid), mid); const inner: Blob.Blob = Blob.slice(bytes, _16); const _20: rt.u8 = Blob.len(head) & 0xff; @@ -110,7 +110,7 @@ export function keys(input: rt.ByteSlice, bytes: Blob.Blob, out: rt.ByteVec): vo rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.hashGet(counts, probe), 0)); rt.byteVecPush(out, rt.btreeContains(sorted, probe) ? 1 : 0); rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.btreeGet(firsts, probe), 255)); - const _81: { start: Blob.Blob } = { start: Blob.clone$Clone(probe) }; + const _81: rt.RangeFrom = new rt.RangeFrom(Blob.clone$Clone(probe)); rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(sorted, _81, Blob.eq$PartialEq, rt.cmpGt(Blob.partialCmp$PartialOrd))) & 0xff); const iter2: rt.Iter<[Blob.Blob, rt.u8]> = rt.btreeIter(firsts); while (true) { diff --git a/ts/fixtures/lang/caller.ts b/ts/fixtures/lang/caller.ts index 6996d31d6..1cc8a9a20 100644 --- a/ts/fixtures/lang/caller.ts +++ b/ts/fixtures/lang/caller.ts @@ -558,4 +558,17 @@ const unlikeEqs = [[], [5], [1, 2], [0, 7, 2, 9], [3, 3, 3, 3, 3, 3, 3, 3, 3]].f const ownNesOp = op("collections::own_nes"); const ownNes = unlikeEqs.map((input) => Uint8Array.of(ownNesOp, ...input.subarray(1))); -export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes]; +/** + * `iters::range_froms` of each case, each way its zips read the range, from each distance + * below its type's last value and from 250, on up to nine bytes: each length its zips + * panic at. + */ +const rangeFromsOp = op("iters::range_froms"); +const rangeFroms = Array.from({ length: 16 * 4 * 4 * 10 }, (_, i) => { + const kind = (i % 16) | ((Math.floor(i / 16) % 4) << 6); + const a = [0, 1, 3, 250][Math.floor(i / 64) % 4]; + const data = Array.from({ length: Math.floor(i / 256) }, (_, j) => (j === 0 ? a : (j * 37) & 0xff)); + return Uint8Array.of(rangeFromsOp, kind, ...data); +}); + +export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms]; diff --git a/ts/fixtures/lang/expected/collections.ts b/ts/fixtures/lang/expected/collections.ts index c5b9a33d9..8b28d5622 100644 --- a/ts/fixtures/lang/expected/collections.ts +++ b/ts/fixtures/lang/expected/collections.ts @@ -685,7 +685,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.byteVecPush(out, _73[0]); rt.byteVecPush(out, _73[1]); } - const iter3: rt.Iter<[rt.u8, rt.u8]> = rt.iterRev(rt.btreeRange(map, { start: 10 })); + const iter3: rt.Iter<[rt.u8, rt.u8]> = rt.iterRev(rt.btreeRange(map, new rt.RangeFrom(10, rt.u8Step))); while (true) { const _88: [rt.u8, rt.u8] | rt.Done = iter3.next(); if (_88 === rt.DONE) { @@ -711,7 +711,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.byteVecPush(out, mapOr$0mmpeqx(rt.iterToOption(rt.btreeIter(map).next()), 255, (_229: [rt.u8, rt.u8]): rt.u8 => { return _229[0] ^ _229[1]; })); - rt.byteVecPush(out, mapOr$0mmpeqx(rt.iterToOption(rt.btreeRange(map, { start: 4 }).nextBack()), 255, (_230: [rt.u8, rt.u8]): rt.u8 => { + rt.byteVecPush(out, mapOr$0mmpeqx(rt.iterToOption(rt.btreeRange(map, new rt.RangeFrom(4, rt.u8Step)).nextBack()), 255, (_230: [rt.u8, rt.u8]): rt.u8 => { return _230[0] ^ _230[1]; })); rt.byteVecPush(out, mapOr$1surhce(rt.iterMax(rt.btreeValues(map), rt.lt), 255, (v6: rt.u8): rt.u8 => { @@ -733,7 +733,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi return _235[0]; }), "next"); } else { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, { start: lo }), (_234: [rt.u8, rt.u8]): rt.u8 => { + within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.RangeFrom(lo, rt.u8Step)), (_234: [rt.u8, rt.u8]): rt.u8 => { return _234[0]; }), "next"); } @@ -797,7 +797,7 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi rt.byteVecPush(out, rt.u8Shl(_276[0][0], 4) | _276[0][1]); rt.byteVecPush(out, _276[1]); } - const _290: { start: rt.u64 } = { start: 4503599627370496 }; + const _290: rt.RangeFrom = new rt.RangeFrom(4503599627370496, rt.u64Step); const iter9: rt.Iter<[rt.u64, rt.u8]> = rt.btreeRange(wides, _290); while (true) { const _295: [rt.u64, rt.u8] | rt.Done = iter9.next(); @@ -1032,7 +1032,7 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_201 === 2) { drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { end: b2 }), "next"); } else { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { start: a }), "next"); + drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.RangeFrom(a, rt.usizeStep)), "next"); } rt.byteVecExtendFromSlice(out, rt.byteVecSlice(drained2)); rt.iterExtendBytes(out, rt.dequeIter(q2), undefined, true); diff --git a/ts/fixtures/lang/expected/core/option.ts b/ts/fixtures/lang/expected/core/option.ts index 971ad7114..3557c2240 100644 --- a/ts/fixtures/lang/expected/core/option.ts +++ b/ts/fixtures/lang/expected/core/option.ts @@ -870,6 +870,13 @@ export function mapOr$0atjiti(self: rt.char | undefined, default_: rt.u32, _: (a return self as rt.u32; } +export function mapOr$0okqj9y(self: rt.char | undefined, default_: rt.u8, f: (a0: rt.char) => rt.u8): rt.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$141aobk(self: rt.char[] | undefined, default_: rt.u8, f: (a0: rt.char[]) => rt.u8): rt.u8 { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/expected/fmt.ts b/ts/fixtures/lang/expected/fmt.ts index f3eed79b5..5a699c281 100644 --- a/ts/fixtures/lang/expected/fmt.ts +++ b/ts/fixtures/lang/expected/fmt.ts @@ -616,14 +616,14 @@ export function wrapped(data: rt.ByteSlice, out: rt.ByteVec): void { const w: rt.usize = rt.u8Rem(at(2), 10) as rt.usize; const _33: rt.Range = new rt.Range(a, b); const _35: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _37: { start: rt.i32 } = { start: a }; + const _37: rt.RangeFrom = new rt.RangeFrom(a, rt.i32Step); const _39: { end: rt.i32 } = { end: b }; const _41: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_33, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(_35, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_37, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeTo(_39, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_41, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeFull(undefined, f)]; put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]])); const _60: rt.Range = new rt.Range(a, b); const _62: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _64: { start: rt.i32 } = { start: a }; + const _64: rt.RangeFrom = new rt.RangeFrom(a, rt.i32Step); const _66: { end: rt.i32 } = { end: b }; const _68: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; const _70: rt.Range = new rt.Range(a, b); @@ -646,7 +646,7 @@ export function wrapped(data: rt.ByteSlice, out: rt.ByteVec): void { const _127: rt.Range = new rt.Range(lo, hi); const _129: rt.RangeInclusive = new rt.RangeInclusive(lo, hi); const _131: { end: Clip.Clip } = { end: hi }; - const _133: { start: Clip.Clip } = { start: lo }; + const _133: rt.RangeFrom = new rt.RangeFrom(lo); const _135: { end: Clip.Clip; inclusive: true } = { end: lo, inclusive: true }; const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_127, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeInclusive(_129, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeTo(_131, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeFrom(_133, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$Debug(value, f)), rt.fmtCount(w), (f: rt.Formatter) => rt.fmtRangeToInclusive(_135, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$Debug(value, f))]; put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ width: 8, precision: 2 }, args6[1]), "|", rt.fmtSpec({ alternate: true }, args6[2]), "|", rt.fmtSpec({ fill: "_", align: ">", width: rt.fmtCountOf(args6[4]), precision: 1 }, args6[3]), "|", rt.fmtSpec({ alternate: true, width: 4 }, args6[5])])); @@ -837,7 +837,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args8[0])])); const it4: rt.Iter = ends$Drain_Hex(rt.vecDrain(rt.iterToArray(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_23: rt.u8): Hex.Hex => { return { _0: rt.u32Mul(_23 as rt.u32, 257) }; - }), undefined, 4, true), { start: 1 }), front, back); + }), undefined, 4, true), new rt.RangeFrom(1, rt.usizeStep)), front, back); const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it4, f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$Debug(value, f), ["Drain"])]; put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true, debugHex: "x" }, args10[0])])); rt.drop(it4); @@ -913,7 +913,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_335, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtIter(_339, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; put(out, rt.fmtFormat([args36[0], "|", args36[1]])); const lo: rt.u8 = rt.u8Rem(at(2), 16); - const _360: rt.Iter<[rt.u8, rt.u8 | undefined]> = ends$Range_u8_Option_u8(rt.btreeRange(map, { start: lo }), front, back); + const _360: rt.Iter<[rt.u8, rt.u8 | undefined]> = ends$Range_u8_Option_u8(rt.btreeRange(map, new rt.RangeFrom(lo, rt.u8Step)), front, back); const _365: rt.Iter<[rt.u8, rt.u8 | undefined]> = ends$Range_u8_Option_u8(rt.btreeRange(map, { end: lo, inclusive: true }), front, back); const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_360, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f)), (f: rt.Formatter) => rt.fmtIter(_365, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; put(out, rt.fmtFormat([args38[0], "|", args38[1]])); @@ -923,7 +923,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = ends$ValuesMut_u8_Option_u8(rt.btreeValuesMut(map), front, back); const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part14, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; put(out, rt.fmtFormat([args42[0]])); - const part15 = ends$RangeMut_u8_Option_u8(rt.btreeRangeMut(map, { start: lo }), front, back); + const part15 = ends$RangeMut_u8_Option_u8(rt.btreeRangeMut(map, new rt.RangeFrom(lo, rt.u8Step)), front, back); const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part15, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; put(out, rt.fmtFormat([args44[0]])); const part16 = ends$IntoIter_u8_Option_u8(rt.btreeIter(rt.btreeClone(map, undefined, undefined)), front, back); @@ -957,7 +957,7 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { const part19 = ends$Iter_u8$2(rt.btreeKeys(set), front, back); const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part19, f, rt.u8Debug, ["Iter"])]; put(out, rt.fmtFormat([args54[0], "|", rt.fmtSpec({ alternate: true }, args54[0])])); - const part20 = ends$Range_u8(rt.btreeRangeKeys(set, { start: lo }), front, back); + const part20 = ends$Range_u8(rt.btreeRangeKeys(set, new rt.RangeFrom(lo, rt.u8Step)), front, back); const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part20, f, rt.fmtSetVal(rt.u8Debug), [["Range", "iter"]])]; put(out, rt.fmtFormat([args56[0], "|", rt.fmtSpec({ alternate: true }, args56[0]), "|", rt.fmtSpec({ debugHex: "x" }, args56[0])])); const part21 = ends$IntoIter_u8$2(rt.btreeKeys(set), front, back); diff --git a/ts/fixtures/lang/expected/harness.ts b/ts/fixtures/lang/expected/harness.ts index 6cee19575..ea380d65d 100644 --- a/ts/fixtures/lang/expected/harness.ts +++ b/ts/fixtures/lang/expected/harness.ts @@ -26,7 +26,7 @@ import { values, random, bytes as hashes_bytes } from "./hashes.ts"; import { hints, reserves } from "./hints.ts"; import { holds } from "./holds.ts"; import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert, parses as ints_parses, widenings } from "./ints.ts"; -import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, own, values as iters_values, returned, zips, zipsBack } from "./iters.ts"; +import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, own, values as iters_values, returned, zips, zipsBack, rangeFroms } from "./iters.ts"; import { keys, overrides, bytes as keys_bytes, lentKeys, lentValues, arrays } from "./keys.ts"; import { locals } from "./locals.ts"; import { locks, relock, rwlocks } from "./locks.ts"; @@ -196,7 +196,7 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) collections(data71, out72); }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", zeros_keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", zips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", zipsBack as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_2172: rt.u8, data72: rt.ByteSlice, out73: rt.ByteVec): undefined => { iters(data72, out73); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", unread as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; + }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", unread as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", rangeFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]; } /** Run one case. */ diff --git a/ts/fixtures/lang/expected/hints.ts b/ts/fixtures/lang/expected/hints.ts index 5ab96b47c..bdb468cde 100644 --- a/ts/fixtures/lang/expected/hints.ts +++ b/ts/fixtures/lang/expected/hints.ts @@ -2018,13 +2018,13 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { walk$Bytes(rt.strBytes(s), steps, out); } else { let t: string = s; - const _379: { start: rt.usize } = { start: rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.usizeDiv(bytes.length, 2)))), (_231: rt.u8): rt.usize => { + const _379: rt.RangeFrom = new rt.RangeFrom(rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.usizeDiv(bytes.length, 2)))), (_231: rt.u8): rt.usize => { const _512: rt.usize = rt.u8Rem(_231, 4) as rt.usize; if (!(_512 < 4)) { rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _512); } return [1, 2, 4, 3][_512]; - }), rt.usizeAdd, 0) }; + }), rt.usizeAdd, 0), rt.usizeStep); walk$Drain(rt.stringDrain(rt.place(() => t, (value) => t = value), _379), steps, out); } } else if (_37 === 17) { @@ -2073,7 +2073,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_422 === 0) { walk$Iter_u8_u8(rt.btreeIter(map2), steps, out); } else if (_422 === 1) { - const _428: { start: rt.u8 } = { start: at(3) }; + const _428: rt.RangeFrom = new rt.RangeFrom(at(3), rt.u8Step); walk$Range_u8_u8(rt.btreeRange(map2, _428), steps, out); } else if (_422 === 2) { walk$Iter_u8$3(rt.btreeKeys(set2), steps, out); @@ -2090,7 +2090,7 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { if (_446 === 0) { walk$Iter_u8$4(rt.dequeIter(deque), steps, out); } else if (_446 === 1) { - walk$Drain_u8(rt.dequeDrain(deque, { start: half2 }), steps, out); + walk$Drain_u8(rt.dequeDrain(deque, new rt.RangeFrom(half2, rt.usizeStep)), steps, out); } else if (_446 === 2) { walk$Drain_u8$2(rt.byteVecDrain(v, { end: half2 }), steps, out); } else { diff --git a/ts/fixtures/lang/expected/iters.ts b/ts/fixtures/lang/expected/iters.ts index 38727d25e..19a5f9902 100644 --- a/ts/fixtures/lang/expected/iters.ts +++ b/ts/fixtures/lang/expected/iters.ts @@ -3,7 +3,7 @@ import * as rt from "./rt.ts"; import { copy$Bumped, copy$u8_u8 } from "./lib.ts"; import { thenSome$0b23a33, thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$1tvry1i, unwrapOr$00uis1j, unwrapOr$0r2bmpr, unwrapOr$14m5xjm, unwrapOrDefault$165pyh5, unwrapOrDefault$0wx44sw, map$1uo1d4o, map$1httady, map$0cs071d, mapOr$1lznlgz, mapOr$0lcrgk1, mapOr$0tmtgfi, mapOr$1kiffmd, mapOr$1a3irjf, mapOr$0atjiti, mapOr$1surhce, mapOr$0ev76sb, mapOr$0mmpeqx, mapOr$1t0muvr, mapOr$0sl5app, mapOr$02k4ito, mapOr$06gg5x7, asDeref$0w8at8i, filter$0v80fk8 } from "./core/option.ts"; +import { unwrapOr$1tvry1i, unwrapOr$0k15iai, unwrapOr$00uis1j, unwrapOr$0r2bmpr, unwrapOr$14m5xjm, unwrapOrDefault$165pyh5, unwrapOrDefault$0wx44sw, map$1uo1d4o, map$1httady, map$0cs071d, mapOr$1lznlgz, mapOr$0lcrgk1, mapOr$0tmtgfi, mapOr$1kiffmd, mapOr$1a3irjf, mapOr$0atjiti, mapOr$0okqj9y, mapOr$1surhce, mapOr$0ev76sb, mapOr$0mmpeqx, mapOr$1t0muvr, mapOr$0sl5app, mapOr$02k4ito, mapOr$06gg5x7, asDeref$0w8at8i, filter$0v80fk8 } from "./core/option.ts"; import { unwrapOr$01jdcm7 } from "./core/result.ts"; import * as Bumped from "./iters.Bumped.ts"; import * as Countdown from "./iters.Countdown.ts"; @@ -3229,4 +3229,1027 @@ export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.refRelease(_141); } +/** + * `start..` of each integer width and `char`, as the iterator an adaptor or consumer + * takes and as its own, stepping up to its type's last value, past which std's debug + * build panics, and ranges of `char` across the surrogates, which they skip. + */ +export function rangeFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const a: rt.u8 = unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const near: rt.u8 = rt.u8Rem(a, 4); + const how: rt.u8 = kind >> 6; + const _12: rt.u8 = rt.u8Rem(kind, 16); + if (_12 === 0) { + fromTop$u8_range_froms_closure0(rt.u8Sub(255, near), data, how, out, (x14: rt.u8, out15: rt.ByteVec): undefined => { + rt.byteVecPush(out15, x14); + }); + } else if (_12 === 1) { + fromTop$u16_range_froms_closure1(rt.u16Sub(65535, near as rt.u16), data, how, out, (x13: rt.u16, out14: rt.ByteVec): undefined => { + rt.iterExtendBytes(out14, rt.iterSlice(rt.u16ToBeBytes(x13).reverse()), undefined, true); + }); + } else if (_12 === 2) { + fromTop$u32_range_froms_closure2(rt.u32Sub(4294967295, near as rt.u32), data, how, out, (x12: rt.u32, out13: rt.ByteVec): undefined => { + rt.iterExtendBytes(out13, rt.iterSlice(rt.u32ToBeBytes(x12).reverse()), undefined, true); + }); + } else if (_12 === 3) { + fromTop$u64_range_froms_closure3(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, near as rt.u64), data, how, out, (x11: rt.u64, out12: rt.ByteVec): undefined => { + rt.iterExtendBytes(out12, rt.iterSlice(rt.u64ToBeBytes(x11).reverse()), undefined, true); + }); + } else if (_12 === 4) { + fromTop$u128_range_froms_closure4(rt.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, near as rt.u128), data, how, out, (x10: rt.u128, out11: rt.ByteVec): undefined => { + rt.iterExtendBytes(out11, rt.iterSlice(rt.u128ToBeBytes(x10).reverse()), undefined, true); + }); + } else if (_12 === 5) { + fromTop$usize_range_froms_closure5(rt.usizeSub(4294967295, near as rt.usize), data, how, out, (x9: rt.usize, out10: rt.ByteVec): undefined => { + rt.iterExtendBytes(out10, rt.iterSlice(rt.usizeToBeBytes(x9).reverse()), undefined, true); + }); + } else if (_12 === 6) { + fromTop$i8_range_froms_closure6(rt.i8Sub(127, (near << 24) >> 24), data, how, out, (x8: rt.i8, out9: rt.ByteVec): undefined => { + rt.iterExtendBytes(out9, rt.iterSlice(rt.i8ToBeBytes(x8).reverse()), undefined, true); + }); + } else if (_12 === 7) { + fromTop$i16_range_froms_closure7(rt.i16Sub(32767, near as rt.i16), data, how, out, (x7: rt.i16, out8: rt.ByteVec): undefined => { + rt.iterExtendBytes(out8, rt.iterSlice(rt.i16ToBeBytes(x7).reverse()), undefined, true); + }); + } else if (_12 === 8) { + fromTop$i32_range_froms_closure8(rt.i32Sub(2147483647, near as rt.i32), data, how, out, (x6: rt.i32, out7: rt.ByteVec): undefined => { + rt.iterExtendBytes(out7, rt.iterSlice(rt.i32ToBeBytes(x6).reverse()), undefined, true); + }); + } else if (_12 === 9) { + fromTop$i64_range_froms_closure9(rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, near as rt.i64), data, how, out, (x5: rt.i64, out6: rt.ByteVec): undefined => { + rt.iterExtendBytes(out6, rt.iterSlice(rt.i64ToBeBytes(x5).reverse()), undefined, true); + }); + } else if (_12 === 10) { + fromTop$i128_range_froms_closure10(rt.i128Sub({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, near as rt.i128), data, how, out, (x4: rt.i128, out5: rt.ByteVec): undefined => { + rt.iterExtendBytes(out5, rt.iterSlice(rt.i128ToBeBytes(x4).reverse()), undefined, true); + }); + } else if (_12 === 11) { + fromTop$isize_range_froms_closure11(rt.isizeSub(2147483647, near as rt.isize), data, how, out, (x3: rt.isize, out4: rt.ByteVec): undefined => { + rt.iterExtendBytes(out4, rt.iterSlice(rt.isizeToBeBytes(x3).reverse()), undefined, true); + }); + } else if (_12 === 12) { + fromTop$u64_range_froms_closure12(rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), near as rt.u64), data, how, out, (x: rt.u64, out2: rt.ByteVec): undefined => { + rt.iterExtendBytes(out2, rt.iterSlice(rt.u64ToBeBytes(x).reverse()), undefined, true); + }); + fromTop$u128_range_froms_closure13(rt.u128Add(rt.u128Sub(rt.u128Shl(1, 64), 2), near as rt.u128), data, how ^ 2, out, (x2: rt.u128, out3: rt.ByteVec): undefined => { + rt.iterExtendBytes(out3, rt.iterSlice(rt.u128ToBeBytes(x2).reverse()), undefined, true); + }); + rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(unwrapOr$00uis1j(rt.iterNth(new rt.RangeFrom(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 2), rt.i64Step), a as rt.usize), 0)).reverse()), undefined, true); + } else if (_12 === 13) { + chars(a, data, how, out); + } else if (_12 === 14) { + adapted(a, data, out); + } else { + overflowed(a, data, out); + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$char_chars_closure0(start: rt.char, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.char, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.char]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"); + while (true) { + const _13: [rt.u8, rt.char] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.char = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"), (_26: [rt.u8, rt.char]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.char = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.char, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.char = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.char, rt.u8]): undefined => { + const x3: rt.char = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$i128_range_froms_closure10(start: rt.i128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i128, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.i128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"); + while (true) { + const _13: [rt.u8, rt.i128] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.i128 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"), (_26: [rt.u8, rt.i128]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.i128 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.i128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.i128, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.i128 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i128, rt.u8]): undefined => { + const x3: rt.i128 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$i16_range_froms_closure7(start: rt.i16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i16, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.i16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"); + while (true) { + const _13: [rt.u8, rt.i16] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.i16 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"), (_26: [rt.u8, rt.i16]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.i16 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.i16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.i16, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.i16 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i16, rt.u8]): undefined => { + const x3: rt.i16 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$i32_range_froms_closure8(start: rt.i32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i32, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.i32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"); + while (true) { + const _13: [rt.u8, rt.i32] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.i32 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"), (_26: [rt.u8, rt.i32]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.i32 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.i32, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.i32 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i32, rt.u8]): undefined => { + const x3: rt.i32 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$i64_range_froms_closure9(start: rt.i64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i64, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.i64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"); + while (true) { + const _13: [rt.u8, rt.i64] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.i64 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"), (_26: [rt.u8, rt.i64]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.i64 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.i64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.i64, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.i64 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i64, rt.u8]): undefined => { + const x3: rt.i64 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$i8_range_froms_closure6(start: rt.i8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i8, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.i8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"); + while (true) { + const _13: [rt.u8, rt.i8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.i8 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"), (_26: [rt.u8, rt.i8]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.i8 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.i8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.i8, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.i8 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i8, rt.u8]): undefined => { + const x3: rt.i8 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$isize_range_froms_closure11(start: rt.isize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.isize, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.isize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"); + while (true) { + const _13: [rt.u8, rt.isize] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.isize = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"), (_26: [rt.u8, rt.isize]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.isize = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.isize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.isize, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.isize = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.isize, rt.u8]): undefined => { + const x3: rt.isize = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$u128_range_froms_closure13(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); + while (true) { + const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.u128 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.u128 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.u128 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { + const x3: rt.u128 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$u128_range_froms_closure4(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); + while (true) { + const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.u128 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.u128 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.u128 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { + const x3: rt.u128 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$u16_range_froms_closure1(start: rt.u16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u16, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"); + while (true) { + const _13: [rt.u8, rt.u16] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.u16 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"), (_26: [rt.u8, rt.u16]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.u16 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.u16, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.u16 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u16, rt.u8]): undefined => { + const x3: rt.u16 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$u32_range_froms_closure2(start: rt.u32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u32, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.u32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"); + while (true) { + const _13: [rt.u8, rt.u32] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.u32 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"), (_26: [rt.u8, rt.u32]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.u32 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.u32, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.u32 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u32, rt.u8]): undefined => { + const x3: rt.u32 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$u64_range_froms_closure12(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); + while (true) { + const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.u64 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.u64 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.u64 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { + const x3: rt.u64 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$u64_range_froms_closure3(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); + while (true) { + const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.u64 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.u64 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.u64 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { + const x3: rt.u64 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$u8_range_froms_closure0(start: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u8, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"); + while (true) { + const _13: [rt.u8, rt.u8] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.u8 = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"), (_26: [rt.u8, rt.u8]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.u8 = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.u8, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.u8 = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u8, rt.u8]): undefined => { + const x3: rt.u8 = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `start..` zipped with `data`, each item written by `put`: the range second or, if `how` + * has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, + * it steps once more than the data has, so it panics one item sooner; folded, std's zip + * of two `TrustedLen` iterators reads only as many pairs as the data has. + */ +export function fromTop$usize_range_froms_closure5(start: rt.usize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.usize, a1: rt.ByteVec) => undefined): void { + b0: { + const _6: rt.u8 = rt.u8Rem(how, 4); + if (_6 === 0) { + const iter: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"); + while (true) { + const _13: [rt.u8, rt.usize] | rt.Done = iter.next(); + if (_13 === rt.DONE) { + break b0; + } + const b: rt.u8 = _13[0]; + const x: rt.usize = _13[1]; + rt.byteVecPush(out, b); + put(x, out); + } + } + if (_6 === 1) { + rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"), (_26: [rt.u8, rt.usize]): undefined => { + const b4: rt.u8 = _26[0]; + const x4: rt.usize = _26[1]; + rt.byteVecPush(out, b4); + put(x4, out); + }); + } else { + if (_6 === 2) { + const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + while (true) { + const _31: [rt.usize, rt.u8] | rt.Done = iter2.next(); + if (_31 === rt.DONE) { + break b0; + } + const x2: rt.usize = _31[0]; + const b2: rt.u8 = _31[1]; + put(x2, out); + rt.byteVecPush(out, b2); + } + } + rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.usize, rt.u8]): undefined => { + const x3: rt.usize = _2[0]; + const b3: rt.u8 = _2[1]; + put(x3, out); + rt.byteVecPush(out, b3); + }); + } + } +} + +/** + * `char` ranges of each kind across the surrogates, which std's `Step` skips, and up to + * `char::MAX`, past which `start..` panics. + */ +export function chars(a: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec): void { + const _8: (a0: rt.char, a1: rt.ByteVec) => undefined = (c2: rt.char, out2: rt.ByteVec): undefined => { + rt.iterExtendBytes(out2, rt.iterSlice(rt.u32ToBeBytes(c2 as rt.u32).reverse()), undefined, true); + }; + const near: rt.u32 = rt.u8Rem(a, 4) as rt.u32; + const gap: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(55293, near))); + fromTop$char_chars_closure0(gap, data, how, out, (c3: rt.char, out3: rt.ByteVec): undefined => { + rt.iterExtendBytes(out3, rt.iterSlice(rt.u32ToBeBytes(c3 as rt.u32).reverse()), undefined, true); + }); + const top: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Sub(1114111 as rt.u32, near))); + fromTop$char_chars_closure0(top, data, how, out, (c4: rt.char, out4: rt.ByteVec): undefined => { + rt.iterExtendBytes(out4, rt.iterSlice(rt.u32ToBeBytes(c4 as rt.u32).reverse()), undefined, true); + }); + const n: rt.usize = data.length; + const end: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(57344, near))); + const iter: rt.Iter = rt.iterStepBy(rt.iterRev(new rt.Range(gap, end, rt.charStep)), 2); + while (true) { + const _30: rt.char | rt.Done = iter.next(); + if (_30 === rt.DONE) { + break; + } + _8(_30, out); + } + const part = unwrapOr$0k15iai(rt.iterNth(new rt.Range(gap, end, rt.charStep), rt.usizeRem(n, 8)), 45); + _8(part, out); + const part2 = unwrapOr$0k15iai(rt.iterNthBack(new rt.RangeInclusive(gap, end, rt.charStep), rt.usizeRem(n, 8)), 45); + _8(part2, out); + const part3 = unwrapOr$0k15iai(rt.iterNth(new rt.RangeFrom(gap, rt.charStep), rt.usizeRem(n, 8)), 45); + _8(part3, out); + const _66: [rt.usize, rt.usize | undefined] = new rt.RangeInclusive(gap, end, rt.charStep).sizeHint(); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_66[0] & 0xff, mapOr$02k4ito(_66[1], 238, (h: rt.usize): rt.u8 => { + return h & 0xff; + }), rt.iterCount(new rt.Range(gap, end, rt.charStep)) & 0xff)), undefined, true); + rt.iterExtendBytes(out, rt.iterMap(new rt.RangeInclusive(gap, end, rt.charStep), (c5: rt.char): rt.u8 => { + return (c5 as rt.u32) & 0xff; + }), undefined, true); + rt.byteVecPush(out, rt.iterCount(new rt.Range(55295, 57344, rt.charStep)) & 0xff); + const last: rt.RangeInclusive = new rt.RangeInclusive(top, 1114111, rt.charStep); + const part4 = unwrapOr$0k15iai(rt.iterNth(last, rt.usizeRem(n, 6)), 45); + _8(part4, out); + const part5 = rt.rangeInclusiveStart(last); + _8(part5, out); + const first: rt.RangeInclusive = new rt.RangeInclusive(0, rt.optionUnwrap(rt.charFromU32(near)), rt.charStep); + const part6 = unwrapOr$0k15iai(rt.iterNthBack(first, rt.usizeRem(n, 6)), 45); + _8(part6, out); + const part7 = rt.rangeInclusiveEnd(first); + _8(part7, out); +} + +/** + * `start..` as what each adaptor and consumer taking an `IntoIterator` takes, and as its + * own receiver. + */ +export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const lo: rt.u8 = rt.u8Rem(a, 64); + const b: rt.u8 = unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); + const it: () => rt.Iter = (): rt.Iter => { + return rt.iterSlice(rt.byteSliceView(data)); + }; + const n: rt.usize = data.length; + rt.iterExtendBytes(out, rt.iterTake(rt.iterChain(it(), new rt.RangeFrom(lo, rt.u8Step)), rt.usizeAdd(n, 3)), undefined, true); + const v: rt.ByteVec = new rt.ByteVec(); + const _22: rt.Iter = rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), 3); + rt.iterExtendBytes(v, _22, undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); + rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.iterSlice([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)])), 5), "next"); + rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatMap(it(), (x: rt.u8): rt.RangeFrom => { + return new rt.RangeFrom(rt.u8Div(x, 4), rt.u8Step); + }), rt.usizeMul(n, 2)), "next"); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(it(), (x2: rt.u8): rt.Range => { + return new rt.Range(rt.u8Div(x2, 32), rt.u8Div(x2, 16)); + })), "next"); + rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(it(), (x3: rt.u8): rt.RangeInclusive => { + return new rt.RangeInclusive(rt.u8Div(x3, 64), rt.u8Div(x3, 32), rt.u8Step); + })), "next"); + const _54: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(it(), new rt.RangeFrom(0, rt.usizeStep), "len"); + rt.iterExtendBytes(out, rt.iterMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rt.u8, rt.usize]): rt.u8 => { + return _24[0] ^ (_24[1] & 0xff); + }), undefined, true); + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next"))), undefined, true); + rt.iterExtendBytes(out, rt.strBytes(rt.stringExtendChars("", rt.iterTake(new rt.RangeFrom(97, rt.charStep), rt.usizeRem(n, 6)))), undefined, true); + const _77: [rt.usize, rt.usize | undefined] = rt.iterZip(it(), new rt.RangeFrom(lo, rt.u8Step), "len").sizeHint(); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_77[0] & 0xff, mapOr$02k4ito(_77[1], 238, (h: rt.usize): rt.u8 => { + return h & 0xff; + }))), undefined, true); + const _89: [rt.usize, rt.usize | undefined] = new rt.RangeFrom(lo, rt.u8Step).sizeHint(); + rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_89[0] & 0xff, mapOr$02k4ito(_89[1], 238, (h2: rt.usize): rt.u8 => { + return h2 & 0xff; + }))), undefined, true); + const r: rt.RangeFrom = new rt.RangeFrom(lo, rt.u8Step); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterToOption(r.next()), 238)); + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterNth(r, rt.u8Rem(b, 8) as rt.usize), 238)); + rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r), 2)) & 0xff); + rt.byteVecPush(out, r.start); + const iter: rt.RangeFrom = new rt.RangeFrom(lo, rt.u8Step); + while (true) { + const _119: rt.u8 | rt.Done = iter.next(); + if (_119 === rt.DONE) { + break; + } + const i: rt.u8 = _119; + if (!(i > rt.u8Add(lo, 5))) { + rt.byteVecPush(out, i); + } else { + break; + } + } + rt.byteVecPush(out, mapOr$02k4ito(rt.iterPosition(new rt.RangeFrom(lo, rt.u8Step), (i2: rt.u8): boolean => { + return ((i2 as rt.usize)) >= rt.usizeAdd(n, lo as rt.usize); + }), 238, (i3: rt.usize): rt.u8 => { + return i3 & 0xff; + })); + rt.iterExtendBytes(out, rt.iterTakeWhile(rt.iterFilter(rt.iterMap(rt.iterSkip(new rt.RangeFrom(lo, rt.u8Step), 2), (i4: rt.u8): rt.u8 => { + return i4 ^ 1; + }), (i5: rt.u8): boolean => { + return rt.u8Rem(i5, 3) !== 0; + }), (_26: rt.u8): boolean => { + return _26 < rt.u8Add(lo, 20); + }), "next"); +} + +/** + * Consumers that step `start..` past its type's last value, which panics in std's + * debug build, as the fixture is built. + */ +export function overflowed(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { + const top: rt.u8 = rt.max(a, 250); + const _5: rt.usize = rt.usizeRem(data.length, 8); + if (_5 === 0) { + rt.iterExtendBytes(out, new rt.RangeFrom(top, rt.u8Step), undefined, true); + } else if (_5 === 1) { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(new rt.RangeFrom(top, rt.u8Step), 10)) & 0xff); + } else if (_5 === 2) { + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterNth(new rt.RangeFrom(a, rt.u8Step), 300), 238)); + } else if (_5 === 3) { + rt.byteVecPush(out, unwrapOr$0r2bmpr(rt.iterNth(new rt.RangeFrom(a, rt.u8Step), rt.u8Sub(255, a) as rt.usize), 238)); + } else if (_5 === 4) { + rt.iterExtendBytes(out, rt.iterTake(rt.iterStepBy(new rt.RangeFrom(a, rt.u8Step), 100), 5), "next"); + } else if (_5 === 5) { + rt.byteVecPush(out, rt.iterCount(rt.iterTake(new rt.RangeFrom(rt.i8Sub(127, (rt.u8Rem(a, 4) << 24) >> 24), rt.i8Step), 5)) & 0xff); + } else if (_5 === 6) { + rt.byteVecPush(out, mapOr$0okqj9y(rt.iterToOption(new rt.RangeFrom(1114111, rt.charStep).next()), 238, (c: rt.char): rt.u8 => { + return c & 0xff; + })); + } else { + rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true))), undefined, true); + } +} + //# sourceMappingURL=iters.ts.map diff --git a/ts/fixtures/lang/expected/keys.ts b/ts/fixtures/lang/expected/keys.ts index 24d81369f..4f4270af0 100644 --- a/ts/fixtures/lang/expected/keys.ts +++ b/ts/fixtures/lang/expected/keys.ts @@ -1278,7 +1278,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_396[0].data[_396[0].start], _396[0].data[_396[0].start + 1], _396[1])), undefined, true); } - const iter13: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.btreeRangeMut(tree, { start: copy$u8s(probe) }), (held11): [rt.ByteSlice, rt.Place] => { + const iter13: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.btreeRangeMut(tree, new rt.RangeFrom(copy$u8s(probe))), (held11): [rt.ByteSlice, rt.Place] => { return [rt.byteSliceFrom(held11[0]), held11[1]]; }); while (true) { @@ -1410,7 +1410,7 @@ export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const none: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterLend(rt.btreeKeys(empty), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.btreeFirst(empty), (held22): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held22[0]), held22[1]]; - }) === undefined ? 1 : 0, rt.iterCount(rt.iterLend(rt.btreeRange(empty, { start: copy$u8s(probe) }), (held23): [rt.ByteSlice, rt.u8] => { + }) === undefined ? 1 : 0, rt.iterCount(rt.iterLend(rt.btreeRange(empty, new rt.RangeFrom(copy$u8s(probe))), (held23): [rt.ByteSlice, rt.u8] => { return [rt.byteSliceFrom(held23[0]), held23[1]]; })) & 0xff, rt.iterCount(rt.iterLend(rt.hashKeys(none), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.hashKey(none, rt.byteSliceView(rt.byteSliceFrom(probe))), rt.byteSliceFrom) === undefined ? 1 : 0)), undefined, true); } @@ -1718,7 +1718,7 @@ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8 rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd)))) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }, rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd))), (k2: Hop.Hop[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key), rt.eqSlice(Hop.eq$PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$PartialOrd))), (k2: Hop.Hop[]): rt.u8 => { const order_ = rt.cmpSlice(Hop.partialCmp$PartialOrd)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -1878,9 +1878,7 @@ export function keyed$Hop_2_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8 const firsts: Hop.Hop[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): Hop.Hop | undefined => { return copy$Option_Hop(rt.sliceFirst(make(_215))); }), "next", 8); - const _560: rt.Iter<[Hop.Hop, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, Hop.Hop]): [Hop.Hop, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [Hop.Hop, rt.u8]; - }); + const _560: rt.Iter<[Hop.Hop, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Hop.cmp$Ord) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Hop.hash$Hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined, Hop.eq$PartialEq)) as rt.HashSet, _566, undefined, undefined, 234881024); @@ -1976,7 +1974,7 @@ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound>, { tag: "Unbounded" } as rt.RangeBound>]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: Array): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: Array): rt.u8 => { const order_ = rt.cmpSlice(rt.cmpOption(rt.cmp))(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -2136,9 +2134,7 @@ export function keyed$Option_u8_2_arrays_closure5(data: rt.ByteSlice, make: (a0: const firsts: Array = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u8 | undefined | rt.None => { return rt.sliceFirst(make(_215), rt.None); }, rt.None), "next", 2); - const _560: rt.Iter<[rt.u8 | undefined, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u8 | undefined]): [rt.u8 | undefined, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [rt.u8 | undefined, rt.u8]; - }); + const _560: rt.Iter<[rt.u8 | undefined, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, _566, undefined, undefined, 234881024); @@ -2234,7 +2230,7 @@ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: boolean[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: boolean[]): rt.u8 => { const order_ = rt.cmpSlice(rt.cmp)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -2393,9 +2389,7 @@ export function keyed$bool_2_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u const firsts: boolean[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): boolean | undefined => { return rt.sliceFirst(make(_215)); }), "next", 1); - const _560: rt.Iter<[boolean, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, boolean]): [boolean, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [boolean, rt.u8]; - }); + const _560: rt.Iter<[boolean, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); @@ -2491,7 +2485,7 @@ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.char[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.char[]): rt.u8 => { const order_ = rt.cmpSlice(rt.cmp)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -2650,9 +2644,7 @@ export function keyed$char_2_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u const firsts: rt.char[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.char | undefined => { return rt.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.char, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.char]): [rt.char, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [rt.char, rt.u8]; - }); + const _560: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); @@ -2748,7 +2740,7 @@ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8 rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.i32[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.i32[]): rt.u8 => { const order_ = rt.cmpSlice(rt.cmp)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -2907,9 +2899,7 @@ export function keyed$i32_2_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8 const firsts: rt.i32[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.i32 | undefined => { return rt.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.i32, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.i32]): [rt.i32, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [rt.i32, rt.u8]; - }); + const _560: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); @@ -3005,7 +2995,7 @@ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8 rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u16[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u16[]): rt.u8 => { const order_ = rt.cmpSlice(rt.cmp)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -3165,9 +3155,7 @@ export function keyed$u16_2_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8 const firsts: rt.u16[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u16 | undefined => { return rt.sliceFirst(make(_215)); }), "next", 2); - const _560: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u16]): [rt.u16, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [rt.u16, rt.u8]; - }); + const _560: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); @@ -3263,7 +3251,7 @@ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8 rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u32[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u32[]): rt.u8 => { const order_ = rt.cmpSlice(rt.cmp)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -3423,9 +3411,7 @@ export function keyed$u32_0_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8 const firsts: rt.u32[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u32 | undefined => { return rt.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u32]): [rt.u32, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [rt.u32, rt.u8]; - }); + const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); @@ -3521,7 +3507,7 @@ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt. rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u32[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u32[]): rt.u8 => { const order_ = rt.cmpSlice(rt.cmp)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -3681,9 +3667,7 @@ export function keyed$u32_275_arrays_closure8(data: rt.ByteSlice, make: (a0: rt. const firsts: rt.u32[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u32 | undefined => { return rt.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u32]): [rt.u32, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [rt.u32, rt.u8]; - }); + const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); @@ -3779,7 +3763,7 @@ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8 rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, { start: key }), (k2: rt.u64[]): rt.u8 => { + rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u64[]): rt.u8 => { const order_ = rt.cmpSlice(rt.cmp)(k2, key); return order_ !== undefined && order_ >= 0 ? 1 : 0; }), rt.u8Add, 0)); @@ -3939,9 +3923,7 @@ export function keyed$u64_2_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8 const firsts: rt.u64[] = rt.iterToArray(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u64 | undefined => { return rt.sliceFirst(make(_215)); }), "next", 8); - const _560: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(firsts)), (_218: [rt.usize, rt.u64]): [rt.u64, rt.u8] => { - return [_218[1], _218[0] & 0xff] as [rt.u64, rt.u8]; - }); + const _560: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(rt.iterSlice(firsts), new rt.RangeFrom(0, rt.u8Step), "len"); const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); const _566: rt.Iter = rt.iterSlice(firsts); const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, _566, undefined, undefined, 234881024); diff --git a/ts/fixtures/lang/expected/slices.ts b/ts/fixtures/lang/expected/slices.ts index 90ffdebf0..37a9e2488 100644 --- a/ts/fixtures/lang/expected/slices.ts +++ b/ts/fixtures/lang/expected/slices.ts @@ -1211,7 +1211,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true))), undefined, true); rt.drop(rt.vecDrain(words, { end: b })); } else if (_31 === 3) { - const drain4: rt.Iter = rt.vecDrain(items, { start: a }, rt.drop); + const drain4: rt.Iter = rt.vecDrain(items, new rt.RangeFrom(a, rt.usizeStep), rt.drop); rt.iterExtendBytes(out, rt.iterOption(map$003seos(rt.iterNth(drain4, 1, rt.drop), (x6: Item.Item): rt.u8 => { const _07: rt.u8 = x6.tag; x6[Symbol.dispose](); @@ -1226,10 +1226,10 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(out); rt.byteVecPush(out, drain4.len() & 0xff); rt.drop(drain4); - const _127: rt.Iter = rt.byteVecDrain(bytes, { start: a }); + const _127: rt.Iter = rt.byteVecDrain(bytes, new rt.RangeFrom(a, rt.usizeStep)); rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(_127, 2)), undefined, true); rt.drop(_127); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.vecDrain(words, { start: a })), (w: rt.u32): rt.u8 => { + rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.vecDrain(words, new rt.RangeFrom(a, rt.usizeStep))), (w: rt.u32): rt.u8 => { return w & 0xff; }), "fold", true); } else if (_31 === 4) { diff --git a/ts/fixtures/lang/expected/strs.ts b/ts/fixtures/lang/expected/strs.ts index 535a3353d..d1e89adfe 100644 --- a/ts/fixtures/lang/expected/strs.ts +++ b/ts/fixtures/lang/expected/strs.ts @@ -574,7 +574,7 @@ export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt const _69: rt.Range = new rt.Range(i, j); s.v = rt.stringReplaceRange(s.v, _69, piece); } else if (_67 === 1) { - const _72: { start: rt.usize } = { start: i }; + const _72: rt.RangeFrom = new rt.RangeFrom(i, rt.usizeStep); s.v = rt.stringReplaceRange(s.v, _72, piece); } else if (_67 === 2) { const _75: { end: rt.usize } = { end: j }; @@ -596,7 +596,7 @@ export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt if (_91 === 0) { s.v = rt.stringExtendFromWithin(s.v, new rt.Range(i, j)); } else if (_91 === 1) { - s.v = rt.stringExtendFromWithin(s.v, { start: i }); + s.v = rt.stringExtendFromWithin(s.v, new rt.RangeFrom(i, rt.usizeStep)); } else if (_91 === 2) { s.v = rt.stringExtendFromWithin(s.v, { end: j, inclusive: true }); } else if (_91 === 3) { @@ -1292,7 +1292,7 @@ export function drainBy(s: rt.Place, form: rt.u8, a: rt.u8, b: rt.u8, st drain = rt.stringDrain(s, new rt.Range(i, j)); _71 = true; } else if (_17 === 1) { - drain = rt.stringDrain(s, { start: i }); + drain = rt.stringDrain(s, new rt.RangeFrom(i, rt.usizeStep)); _71 = true; } else if (_17 === 2) { drain = rt.stringDrain(s, { end: j }); @@ -1385,7 +1385,7 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _56: { end: rt.usize } = { end: offset(s, a) }; put(out, rt.stringExtendChars("", rt.stringDrain(rt.place(() => s, (value5) => s = value5), _56), true)); } else if (_49 === 1) { - const _64: { start: rt.usize } = { start: offset(s, a) }; + const _64: rt.RangeFrom = new rt.RangeFrom(offset(s, a), rt.usizeStep); rt.byteVecPush(out, rt.ownedCount(rt.stringDrain(rt.place(() => s, (value4) => s = value4), _64)) & 0xff); } else if (_49 === 2) { putChar(out, rt.ownedLast(rt.stringDrain(rt.place(() => s, (value3) => s = value3), undefined))); diff --git a/ts/fixtures/lang/expected/wrappers.ts b/ts/fixtures/lang/expected/wrappers.ts index 21263426e..c005191f3 100644 --- a/ts/fixtures/lang/expected/wrappers.ts +++ b/ts/fixtures/lang/expected/wrappers.ts @@ -56,7 +56,7 @@ export function bounds$Bound_u64_Bound_u64(out: rt.ByteVec, r: [rt.RangeBound): void { let start!: rt.u64 | undefined; let end!: rt.u64 | undefined; putBound(out, { tag: "Included", _0: r.start } as rt.RangeBound); @@ -360,15 +360,15 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(narrow) ? 1 : 0); bounds$RangeTo_u64(out, { end: b }); bounds$RangeToInclusive_u64(out, { end: b, inclusive: true }); - bounds$RangeFrom_u64(out, { start: a }); + bounds$RangeFrom_u64(out, new rt.RangeFrom(a, rt.u64Step)); bounds$RangeFull(out, undefined); bounds$Bound_u64_Bound_u64(out, [boundOf(at(2), a), boundOf(at(3), b)] as [rt.RangeBound, rt.RangeBound]); const held2: [rt.RangeBound, rt.RangeBound] = [boundOf(at(3), b), { tag: "Unbounded" } as rt.RangeBound]; bounds$Bound_u64_Bound_u64(out, held2); putBound(out, held2[0]); - const _246: [{ end: rt.usize }, { start: rt.usize }] = [{ end: rt.usizeRem(at(2) as rt.usize, rt.usizeAdd(data.length, 1)) }, { start: rt.usizeRem(at(3) as rt.usize, rt.usizeAdd(data.length, 1)) }]; + const _246: [{ end: rt.usize }, rt.RangeFrom] = [{ end: rt.usizeRem(at(2) as rt.usize, rt.usizeAdd(data.length, 1)) }, new rt.RangeFrom(rt.usizeRem(at(3) as rt.usize, rt.usizeAdd(data.length, 1)), rt.usizeStep)]; const to: { end: rt.usize } = _246[0]; - const from: { start: rt.usize } = _246[1]; + const from: rt.RangeFrom = _246[1]; putU64(out, rt.usizeAdd(to.end, from.start) as rt.u64); putU64(out, b); rt.byteVecPush(out, rt.byteSliceRange(data, 0, to.end).length & 0xff); diff --git a/ts/fixtures/lang/src/harness.rs b/ts/fixtures/lang/src/harness.rs index eb5a7426e..2602f0cdc 100644 --- a/ts/fixtures/lang/src/harness.rs +++ b/ts/fixtures/lang/src/harness.rs @@ -181,6 +181,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("collections::own_nes", collections::own_nes), ("fmt::iters", |_, data, out| fmt::iters(data, out)), ("zeros::unread", zeros::unread), + ("iters::range_froms", iters::range_froms), ] } diff --git a/ts/fixtures/lang/src/iters.rs b/ts/fixtures/lang/src/iters.rs index fece66bd5..fae4bf125 100644 --- a/ts/fixtures/lang/src/iters.rs +++ b/ts/fixtures/lang/src/iters.rs @@ -1201,3 +1201,186 @@ pub fn zips_back(kind: u8, data: &[u8], out: &mut Vec) { } out.extend_from_slice(&log.borrow()); } + +/// `start..` of each integer width and `char`, as the iterator an adaptor or consumer +/// takes and as its own, stepping up to its type's last value, past which std's debug +/// build panics, and ranges of `char` across the surrogates, which they skip. +pub fn range_froms(kind: u8, data: &[u8], out: &mut Vec) { + let a = data.first().copied().unwrap_or(0); + let near = a % 4; + let how = kind >> 6; + match kind % 16 { + 0 => from_top(u8::MAX - near, data, how, out, |x, out| out.push(x)), + 1 => from_top(u16::MAX - u16::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 2 => from_top(u32::MAX - u32::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 3 => from_top(u64::MAX - u64::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 4 => from_top(u128::MAX - u128::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 5 => from_top(usize::MAX - usize::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 6 => from_top(i8::MAX - near as i8, data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 7 => from_top(i16::MAX - i16::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 8 => from_top(i32::MAX - i32::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 9 => from_top(i64::MAX - i64::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 10 => from_top(i128::MAX - i128::from(near), data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + 11 => from_top(isize::MAX - near as isize, data, how, out, |x, out| { + out.extend(x.to_le_bytes()) + }), + // Past 2^53, where a number becomes limbs, and past 2^64 for `u128`. + 12 => { + let past = (1u64 << 53) - 2 + u64::from(near); + from_top(past, data, how, out, |x, out| out.extend(x.to_le_bytes())); + let wide = (1u128 << 64) - 2 + u128::from(near); + from_top(wide, data, how ^ 2, out, |x, out| out.extend(x.to_le_bytes())); + out.extend((-(1i64 << 53) - 2..).nth(usize::from(a)).unwrap_or(0).to_le_bytes()); + } + 13 => chars(a, data, how, out), + 14 => adapted(a, data, out), + _ => overflowed(a, data, out), + } +} + +/// `start..` zipped with `data`, each item written by `put`: the range second or, if `how` +/// has bit 1, first, and read by `next` or, with bit 0, folded. First and read by `next`, +/// it steps once more than the data has, so it panics one item sooner; folded, std's zip +/// of two `TrustedLen` iterators reads only as many pairs as the data has. +fn from_top(start: T, data: &[u8], how: u8, out: &mut Vec, put: impl Fn(T, &mut Vec)) +where + std::ops::RangeFrom: Iterator, +{ + match how % 4 { + 0 => { + for (&b, x) in data.iter().zip(start..) { + out.push(b); + put(x, out); + } + } + 1 => data.iter().zip(start..).for_each(|(&b, x)| { + out.push(b); + put(x, out); + }), + 2 => { + for (x, &b) in (start..).zip(data) { + put(x, out); + out.push(b); + } + } + _ => (start..).zip(data).for_each(|(x, &b)| { + put(x, out); + out.push(b); + }), + } +} + +/// `char` ranges of each kind across the surrogates, which std's `Step` skips, and up to +/// `char::MAX`, past which `start..` panics. +fn chars(a: u8, data: &[u8], how: u8, out: &mut Vec) { + let near = u32::from(a % 4); + let put = |c: char, out: &mut Vec| out.extend((c as u32).to_le_bytes()); + let gap = char::from_u32(0xd7fd + near).unwrap(); + from_top(gap, data, how, out, put); + let top = char::from_u32(char::MAX as u32 - near).unwrap(); + from_top(top, data, how, out, put); + let n = data.len(); + let end = char::from_u32(0xe000 + near).unwrap(); + for c in (gap..end).rev().step_by(2) { + put(c, out); + } + put((gap..end).nth(n % 8).unwrap_or('-'), out); + put((gap..=end).nth_back(n % 8).unwrap_or('-'), out); + put((gap..).nth(n % 8).unwrap_or('-'), out); + let (lo, hi) = (gap..=end).size_hint(); + out.extend([lo as u8, hi.map_or(0xee, |h| h as u8), (gap..end).count() as u8]); + out.extend((gap..=end).map(|c| c as u32 as u8)); + out.push(('\u{d7ff}'..'\u{e000}').count() as u8); + // Inclusive ones stepped past either end of the chars, which leaves the bound there. + let mut last = top..=char::MAX; + put(last.nth(n % 6).unwrap_or('-'), out); + put(*last.start(), out); + let mut first = '\0'..=char::from_u32(near).unwrap(); + put(first.nth_back(n % 6).unwrap_or('-'), out); + put(*first.end(), out); +} + +/// `start..` as what each adaptor and consumer taking an `IntoIterator` takes, and as its +/// own receiver. +fn adapted(a: u8, data: &[u8], out: &mut Vec) { + let lo = a % 64; + let b = data.get(1).copied().unwrap_or(0); + let it = || data.iter().copied(); + let n = data.len(); + out.extend(it().chain(lo..).take(n + 3)); + let mut v: Vec = Vec::new(); + v.extend((lo..).take(3)); + out.extend(v); + out.extend(vec![lo.., b / 2..].into_iter().flatten().take(5)); + out.extend(it().flat_map(|x| x / 4..).take(n * 2)); + out.extend(it().map(|x| x / 32..x / 16).flatten()); + out.extend(it().map(|x| x / 64..=x / 32).flatten()); + let keyed: std::collections::BTreeMap = it().zip(0..).collect(); + out.extend(keyed.into_iter().map(|(k, v)| k ^ v as u8)); + out.extend(Vec::from_iter((lo..).step_by(3).take(4))); + out.extend(String::from_iter(('a'..).take(n % 6)).bytes()); + let (low, high) = it().zip(lo..).size_hint(); + out.extend([low as u8, high.map_or(0xee, |h| h as u8)]); + let (low, high) = (lo..).size_hint(); + out.extend([low as u8, high.map_or(0xee, |h| h as u8)]); + // Its own iterator, read by reference and then by its `start`. + let mut r = lo..; + out.push(r.next().unwrap_or(0xee)); + out.push(r.nth(usize::from(b % 8)).unwrap_or(0xee)); + out.push(r.by_ref().take(2).count() as u8); + out.push(r.start); + for i in lo.. { + if i > lo + 5 { + break; + } + out.push(i); + } + out.push( + (lo..) + .position(|i| usize::from(i) >= n + usize::from(lo)) + .map_or(0xee, |i| i as u8), + ); + out.extend( + (lo..) + .skip(2) + .map(|i| i ^ 1) + .filter(|i| i % 3 != 0) + .take_while(|&i| i < lo + 20), + ); +} + +/// Consumers that step `start..` past its type's last value, which panics in std's +/// debug build, as the fixture is built. +fn overflowed(a: u8, data: &[u8], out: &mut Vec) { + let top = a.max(250); + match data.len() % 8 { + 0 => out.extend(top..), + 1 => out.push((top..).take(10).count() as u8), + 2 => out.push((a..).nth(300).unwrap_or(0xee)), + 3 => out.push((a..).nth(usize::from(255 - a)).unwrap_or(0xee)), + 4 => out.extend((a..).step_by(100).take(5)), + 5 => out.push((i8::MAX - (a % 4) as i8..).take(5).count() as u8), + 6 => out.push((char::MAX..).next().map_or(0xee, |c| c as u8)), + _ => out.extend(Vec::from_iter(top..)), + } +} diff --git a/ts/fixtures/lang/src/keys.rs b/ts/fixtures/lang/src/keys.rs index e7187819b..e807a62f0 100644 --- a/ts/fixtures/lang/src/keys.rs +++ b/ts/fixtures/lang/src/keys.rs @@ -1092,7 +1092,7 @@ fn keyed(data: &[u8], make: impl Fn(u8) - out.push(options.contains(&None) as u8); // Keys that are references to elements, found by what each points at. let firsts: Vec = data.iter().filter_map(|&b| make(b).first().cloned()).collect(); - let refs: BTreeMap<&T, u8> = firsts.iter().enumerate().map(|(i, k)| (k, i as u8)).collect(); + let refs: BTreeMap<&T, u8> = firsts.iter().zip(0..).collect(); let hashed: HashSet<&T> = firsts.iter().collect(); for b in 0..8 { if let Some(first) = make(b).first() { diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 32b5d7db1..f0293f4f4 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -48,7 +48,7 @@ export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { rt.dropAll([_42.start, _42.end]); const _50: rt.RangeInclusive = new rt.RangeInclusive(guard(3), guard(4)); rt.dropAll([_50.lo, _50.hi]); - (({ start: guard(5) }.start[Symbol.dispose]())); + new rt.RangeFrom(guard(5)).start[Symbol.dispose](); (({ end: guard(6) }.end[Symbol.dispose]())); (({ end: guard(7), inclusive: true }.end[Symbol.dispose]())); const r: rt.Range = new rt.Range(guard(8), guard(9)); diff --git a/ts/runtime/rt/int.ts b/ts/runtime/rt/int.ts index 1ff6252c8..7dc7d322d 100644 --- a/ts/runtime/rt/int.ts +++ b/ts/runtime/rt/int.ts @@ -78,6 +78,19 @@ export type IntErrorKind = "Empty" | "InvalidDigit" | "PosOverflow" | "NegOverfl /** `core::num::ParseIntError`: why an integer didn't parse. */ export type ParseIntError = { readonly kind: IntErrorKind }; +/** + * `char`'s `Step`: `n` moved by `by` past the surrogates, which no `char` is, and whether + * that left the chars, past which it stays at the last or first, as std's does. + */ +export const charStep: Step = (n, by) => { + let v = n + by; + if (by > 0 && n < 0xd800 && v >= 0xd800) v += 0x800; + else if (by < 0 && n >= 0xe000 && v < 0xe000) v -= 0x800; + if (v > 0x10ffff) return [0x10ffff as char, true]; + if (v < 0) return [0 as char, true]; + return [v as char, false]; +}; + /** `core::char::CharErrorKind`: why a `char` didn't parse, by variant name. */ export type CharErrorKind = "EmptyString" | "TooManyChars"; diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rt/iter.ts index c1c615417..e96b2caba 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rt/iter.ts @@ -24,7 +24,7 @@ import { ByteSlice, ByteVec, byteVecPush, Err, type None, Ok, type Place, panic, place, type RangeBound, type Result, sliceView } from "../rt.ts"; import { AtIndex, BTreeIter, HashIter, type Ordering } from "./collections.ts"; -import { intToBig, type Limbs, lt as wideLt, type Step } from "./int.ts"; +import { charStep, intToBig, type Limbs, lt as wideLt, type Step } from "./int.ts"; import { drop as dispose, dropRange } from "./task.ts"; /** What `next` returns once an iterator is exhausted, which no item is. */ @@ -3179,24 +3179,32 @@ function lt(a: T, b: T): boolean { /** * `n + by` in the integer type `int` steps, or `undefined` past its range, which a range * stepping past its end only needs to stay past. A narrow integer's sum is an exact - * number whatever its type. + * number whatever its type; a `char`'s skips the surrogates. */ function step(n: T, by: number, int: Step | undefined): T | undefined { - if (typeof n === "number" && Number.isSafeInteger(n + by)) return (n + by) as T; + if (typeof n === "number" && int !== (charStep as unknown) && Number.isSafeInteger(n + by)) return (n + by) as T; if (int === undefined) throw new Error("rust2-ts: stepping a wide range without its type"); const [sum, over] = int(n, by); return over ? undefined : sum; } -/** std's `Step::steps_between` of `a` and `b`, at most `b`: `(usize::MAX, None)` past `usize::MAX`. */ -function stepsBetween(a: T, b: T): SizeHint { +/** + * std's `Step::steps_between` of `a` and `b`, at most `b`, in the type `int` steps: + * `(usize::MAX, None)` past `usize::MAX`, and less the surrogates `char`s skip. + */ +function stepsBetween(a: T, b: T, int: Step | undefined): SizeHint { + if (int === (charStep as unknown)) { + const n = (b as number) - (a as number); + return exactHint((a as number) < 0xd800 && (b as number) >= 0xe000 ? n - 0x800 : n); + } const n = typeof a === "number" && typeof b === "number" ? b - a : intToBig(b as number | Limbs) - intToBig(a as number | Limbs); return n <= USIZE_MAX ? exactHint(Number(n)) : [USIZE_MAX, undefined]; } /** * `ops::Range`: `start..end`, which iterates its integers by moving `start`. A 64- or - * 128-bit range takes its type's `Step`, `rt.u64Step`, to step past 2^53. + * 128-bit range takes its type's `Step`, `rt.u64Step`, to step past 2^53, and a range + * of `char`s `rt.charStep`, to step past the surrogates. */ export class Range extends Iter { start: T; @@ -3250,7 +3258,7 @@ export class Range extends Iter { } override sizeHint(): SizeHint { - return lt(this.start, this.end) ? stepsBetween(this.start, this.end) : [0, 0]; + return lt(this.start, this.end) ? stepsBetween(this.start, this.end, this.int) : [0, 0]; } } @@ -3269,6 +3277,47 @@ export function rangeClone(r: Range): Range { return new Range(r.start, r.end, r.int); } +/** + * `ops::RangeFrom`: `start..`, which iterates by moving `start` and never ends. It takes + * its type's `Step`, `rt.u8Step` or `rt.charStep`, past whose last value it panics, as + * std's does in a debug build. + */ +export class RangeFrom extends Iter { + start: T; + readonly int: Step | undefined; + + constructor(start: T, int?: Step) { + super(); + this.start = start; + this.int = int; + } + + /** std's: the next `start` is found before the item is given, so the last value panics. */ + next(): T | Done { + const start = this.start; + this.start = forward(start, 1, this.int); + return start; + } + + override nth(n: number): T | Done { + const item = forward(this.start, n, this.int); + this.start = forward(item, 1, this.int); + return item; + } + + override sizeHint(): SizeHint { + return [USIZE_MAX, undefined]; + } +} + +/** std's `Step::forward` in a debug build: `n + by`, panicking past `int`'s last value. */ +function forward(n: T, by: number, int: Step | undefined): T { + if (int === undefined) throw new Error("rust2-ts: stepping a range of no integer type"); + const [sum, over] = int(n, by); + if (over) panic(int === (charStep as unknown) ? "overflow in `Step::forward`" : "attempt to add with overflow"); + return sum; +} + /** `ops::RangeInclusive`: `start..=end`, which remembers once it has yielded `end`. */ export class RangeInclusive extends Iter { lo: T; @@ -3309,7 +3358,7 @@ export class RangeInclusive extends Iter { override sizeHint(): SizeHint { if (rangeInclusiveIsEmpty(this)) return [0, 0]; - const [lower, upper] = stepsBetween(this.lo, this.hi); + const [lower, upper] = stepsBetween(this.lo, this.hi, this.int); return [satAdd(lower, 1), addUpper(upper, 1)]; } diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index 799efb467..656b21a2d 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -134,7 +134,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { if values.len() == 3 && matches!(&values[2], Expr::Lit(l) if l == "false") => { values.pop(); - values.extend(crate::lower::num::Int::of(args.type_at(0)).map(|int| int.func("step"))); + values.extend(super::library::range_step(args.type_at(0), true)); Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) } (Std::Ordering, _) => super::collections::ordering_variant(variant), @@ -146,7 +146,10 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { (Std::RangeTo | Std::RangeToInclusive, _) => { super::library::range_to(values.pop().unwrap(), std == Std::RangeToInclusive) } - (Std::RangeFrom, _) => Expr::Object(vec![(Key::Name("start".into()), values.pop().unwrap())]), + (Std::RangeFrom, _) => { + values.extend(super::library::range_step(args.type_at(0), true)); + Expr::New(Box::new(Expr::Rt("RangeFrom".into())), values) + } (Std::RangeFull, _) => Expr::undefined(), (Std::ParseIntError, _) => { Expr::Object(vec![(Key::Name("kind".into()), values.pop().unwrap())]) diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index 770c01a86..7d0187169 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -1418,7 +1418,7 @@ fn mapping<'tcx>( // An integer range wraps within its type's bounds where std's `nth` does. ("RangeInclusive", "new") if range => { let mut values = args; - values.extend(self_ty().and_then(Int::of).map(|int| int.func("step"))); + values.extend(self_ty().and_then(|t| range_step(t, true))); Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) } // JS compares integers as Rust does, and other endpoints by identity. @@ -2232,6 +2232,16 @@ fn range_of(std: Std) -> Option<&'static str> { } } +/// The `Step` a range of `ty`s is made with: a `char`'s, which skips the surrogates, and a +/// wide integer's, which steps past 2^53, or any integer's where `every` integer needs it to +/// step within its type. +pub fn range_step(ty: Ty<'_>, every: bool) -> Option { + match Int::of(ty) { + Some(int) => (every || int.big()).then(|| int.func("step")), + None => ty.is_char().then(|| Expr::Rt("charStep".into())), + } +} + fn int_named(name: &str) -> Option { let (signed, bits, pointer) = match name { "u8" => (false, 8, false), diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index b6195f9e4..c284bc467 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -3569,7 +3569,9 @@ fn parts_of(value: &Expr) -> Option> { Some(items.clone()) } Expr::Object(props) => Some(props.iter().map(|(_, v)| v.clone()).collect()), - Expr::New(f, items) if matches!(&**f, Expr::Rt(name) if name == "Range") => Some(items.clone()), + Expr::New(f, items) if matches!(&**f, Expr::Rt(name) if name == "Range" || name == "RangeFrom") => { + Some(items.clone()) + } _ => None, } } diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 4ecc2d4e4..07752015f 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -585,7 +585,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let ts_ty = self.b.t.ty(ty, span); crate::lower::library::tagged(def.name.as_str(), values.pop(), ts_ty) } - (Std::RangeFrom, _) => Expr::Object(vec![(Key::Name("start".into()), values.pop().unwrap())]), + (Std::RangeFrom, _) => { + values.extend(crate::lower::library::range_step(args.type_at(0), true)); + Expr::New(Box::new(Expr::Rt("RangeFrom".into())), values) + } (Std::RangeFull, _) => Expr::undefined(), (Std::ParseIntError, _) => Expr::Object(vec![(Key::Name("kind".into()), values.pop().unwrap())]), (Std::ErrorKind, _) => Expr::As(Box::new(Expr::Str(def.name.to_string())), self.b.t.ty(ty, span)), @@ -593,14 +596,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { (Std::AtomicOrdering, _) => crate::lower::task::atomic_ordering(variant), (Std::ControlFlow, _) => super::call::control_flow(self, ty, variant, values), (Std::Range, _) => { - let ty::Adt(_, gargs) = ty.kind() else { - unreachable!("a range is a struct") - }; - if let Some(int) = Int::of(gargs.type_at(0)) - && int.big() - { - values.push(int.func("step")); - } + values.extend(crate::lower::library::range_step(args.type_at(0), false)); Expr::New(Box::new(Expr::Rt("Range".into())), values) } (Std::AssertKind, _) => match def.name.as_str() { diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index a69f4a56e..1cd27543b 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -1176,6 +1176,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { | library::Std::Pending | library::Std::Range | library::Std::RangeInclusive + | library::Std::RangeFrom | library::Std::Peekable | library::Std::HashMap | library::Std::HashSet @@ -1514,7 +1515,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ("end".into(), self.ty(args.type_at(0), span)), ("inclusive".into(), Type::Builtin("true")), ]), - library::Std::RangeFrom => Type::Object(vec![("start".into(), self.ty(args.type_at(0), span))]), + library::Std::RangeFrom => Type::Rt("RangeFrom", vec![self.ty(args.type_at(0), span)]), library::Std::RangeFull => Type::Builtin("undefined"), library::Std::Argument => Type::Rt("Fmt", vec![]), library::Std::NonNull => self.pointer_ty(args.type_at(0), span),