diff --git a/quest/m2/ts-model/README.md b/quest/m2/ts-model/README.md index ff6fcbded..f525b8295 100644 --- a/quest/m2/ts-model/README.md +++ b/quest/m2/ts-model/README.md @@ -45,7 +45,7 @@ Decided with the maintainer on 2026-10-27, from a census of the model's 22 publi - The end-to-end work stays here: the model's roots, its differential harness, and the `frames.ts` workload. moq writes the binding files `model.toml` names, in its own tree. -The census at the pin on 2026-11-04: 82 refusals. `Timestamp` alone refuses nothing, and +The census at the pin on 2026-11-06: 73 refusals. `Timestamp` alone refuses nothing, and the [model fixture](/ts/README.md#tests)'s harness runs it against native moq-net at the pin; each case it adds as a type translates. Every other root reaches the rest of the model, so each child below unblocks all of them together. The rest is moq's, for its @@ -63,7 +63,6 @@ kept separate since each lands alone; rejected: one quest for `ArrayString`. ## Required - [Bytes from an owner that drops](/quest/m2/ts-model/bytes-owner.md) - `Bytes::from_owner` of a frame's segment -- [rangemap](/quest/m2/ts-model/rangemap.md) - B-tree ranges by a borrowed key, and std's iterators in a crate's fields - [Addresses as identity](/quest/m2/ts-model/addresses.md) - `Arc::as_ptr(a) as usize` as a key, which needs a decision - [Option fields at a unit instance](/quest/m2/ts-model/unit-option-fields.md) - `Idle<()>`'s `Option` field tells `Some(())` from `None` - [Const generic types](/quest/m2/ts-model/const-generics.md) - `ArrayString` and other types with const parameters diff --git a/quest/m2/ts-model/rangemap.md b/quest/m2/ts-model/rangemap.md deleted file mode 100644 index 88a77a3b9..000000000 --- a/quest/m2/ts-model/rangemap.md +++ /dev/null @@ -1,16 +0,0 @@ -# [M] rangemap - -## Goal - -[rust2-ts](/ts/README.md) translates rangemap as it is, as moq-net's model uses it, -proven by differential tests against native Rust. At the pin it refuses 11 times: - -- `BTreeMap::range` by a type other than the key, which the key borrows as, ordered by - the crate's own `Ord` (`RangeStartWrapper` keys searched by a `RangeEndWrapper`). -- std's `btree_map::Iter` and `Range` held in a field of the crate's own iterators. - -## Plan - -The runtime's B-tree calls `Ord::cmp` as std's does, `key.cmp(k)` node by node, so a -search by a borrowed form calls that form's `Ord` where std's would. A field of std's iterator type is the runtime's `rs.Iter`, as a local -of that type already is. diff --git a/ts/Cargo.lock b/ts/Cargo.lock index ea1392743..1f61c15c4 100644 --- a/ts/Cargo.lock +++ b/ts/Cargo.lock @@ -549,6 +549,12 @@ version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" +[[package]] +name = "rangemap" +version = "1.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a611d15b50743feb4c76b7d03edcb0e64f399c26961e4efe6975bc398be6aa3d" + [[package]] name = "reject-fixture" version = "0.0.0" @@ -645,6 +651,7 @@ dependencies = [ "hashbrown", "hashlink", "rand", + "rangemap", "tracing", ] diff --git a/ts/README.md b/ts/README.md index 1ad22f88b..3a9cb0857 100644 --- a/ts/README.md +++ b/ts/README.md @@ -991,7 +991,9 @@ they need. children below internal ones, each searched from its first key by `key.cmp(k)`, split, merged, and evened out with a sibling where std's are, built by `collect` and `split_off` as std's builds them, and cloned node for node, so a key's own `cmp` runs - on the same keys in the same order as std's. Iterators climb and descend leaf edges as + on the same keys in the same order as std's. A search by another type the keys lend by + the crate's own `Borrow` is an `rs.By`, which orders that type by its own `cmp` against + each key's `borrow`, as std's does. Iterators climb and descend leaf edges as std's do. On `just ts bench`'s `btree/` workloads it takes 0.8-1.0x the time the B+ tree of 64-key nodes it replaced did in Chrome, 1.0-1.3x in Node and Firefox, within their noise, and 1.3-1.6x in Bun, from 16 keys to 4096; bisecting a node's keys measured @@ -1159,8 +1161,8 @@ so adding, removing, or reordering a case changes no other case's inputs. impls, beside values that drop inside std's types. Its caller is hand-written TS (`tests/task.ts`): a FIFO executor that runs a script of spawns, sends, polls, and drops, and logs every poll, wake, and drop, as the fixture's native executor does. The logs must match byte for byte. -- `stock` calls `bytes`, `hashbrown`, `rand`, and `tracing` with no config, and `hashlink` - over `hashbrown`, against native Rust, whose +- `stock` calls `bytes`, `hashbrown`, `rand`, and `tracing` with no config, `hashlink` + over `hashbrown`, and `rangemap` over std's B-tree, against native Rust, whose `rand::rng()` reads the fixture's own getrandom backend on wasm32. It checks `Bytes`'s slices and panics, how each is made and printed, that no event evaluates a field, and that each random value is in its range, every value of a small range drawn. It splits, @@ -1171,7 +1173,9 @@ so adding, removing, or reordering a case changes no other case's inputs. `dyn Buf`s, at either end of each half and past the end. It changes hashbrown's maps and sets, keyed by JS primitives and by tuples, and `HashTable`s of tuples and of numbers, whose places it writes, under hashes that collide and that pass 2^53, checks their capacity by std's guarantees, and writes a - `hashlink::LinkedHashMap` in its own order. `caller.ts` names the inputs that read a `BytesMut` past + `hashlink::LinkedHashMap` in its own order. It inserts, removes, looks up, overlaps, and + gaps `rangemap`'s maps and sets, which search their B-trees by what each key lends by + rangemap's own `Borrow`. `caller.ts` names the inputs that read a `BytesMut` past where `bytes` shares a vector's storage, 128 MiB, and drop each pick of a storage's handles before reserving. - `bind` binds `buf::Blob`, a renamed dependency's type with `unsafe` inside, and a function and a type of its own that read through raw diff --git a/ts/fixtures/lang/collections/expected/collections.Lent.ts b/ts/fixtures/lang/collections/expected/collections.Lent.ts new file mode 100644 index 000000000..5d1d6c90e --- /dev/null +++ b/ts/fixtures/lang/collections/expected/collections.Lent.ts @@ -0,0 +1,28 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; +import * as Probe from "./collections.Probe.ts"; + +/** + * A B-tree key ordered by its `start`, which lends its `end`, as rangemap's start wrapper + * lends its end wrapper, and its `id`, a form of std's. + */ +export interface Lent { + start: Probe.Probe; + end: Probe.Probe; + id: rs.u16; +} + +export function cmp$cmp_Ord(self: Lent, other: Lent): rs.Ordering { + return Probe.cmp$cmp_Ord(self.start, other.start); +} + +export function borrow$Borrow_collections_Probe(self: Lent): Probe.Probe { + return self.end; +} + +export function borrow$Borrow_u16(self: Lent): rs.u16 { + return self.id; +} + +//# sourceMappingURL=collections.Lent.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index a7e9efab2..2b0fbf77c 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -12,6 +12,7 @@ import * as Dir from "./collections.Dir.ts"; import * as Fussy from "./collections.Fussy.ts"; import type * as Holder from "./collections.Holder.ts"; import * as Left from "./collections.Left.ts"; +import * as Lent from "./collections.Lent.ts"; import * as Logged from "./collections.Logged.ts"; import * as Mixed from "./collections.Mixed.ts"; import * as Nibble from "./collections.Nibble.ts"; @@ -26,7 +27,7 @@ import * as Tally from "./collections.Tally.ts"; import * as Window from "./collections.Window.ts"; import * as Wrap from "./collections.Wrap.ts"; import { thenSome$0quywni } from "./core/bool.ts"; -import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pdxnel as option_map$1pdxnel, map$093awy8 as option_map$093awy8, map$0aug5m6 as option_map$0aug5m6, map$16w3l9s as option_map$16w3l9s, map$1y26nmr as option_map$1y26nmr, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$0f7cus0 as option_mapOr$0f7cus0, mapOr$0vkblkh as option_mapOr$0vkblkh, mapOr$07jk2xl as option_mapOr$07jk2xl, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0pgapuk as option_mapOr$0pgapuk, mapOr$13kt6x8 as option_mapOr$13kt6x8, mapOr$1wei0sy as option_mapOr$1wei0sy, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$18dcmgz as option_mapOr$18dcmgz, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt, mapOr$05q90i2 as option_mapOr$05q90i2, mapOr$0955beb as option_mapOr$0955beb, mapOr$1h9hu6n as option_mapOr$1h9hu6n, clone$14nprly as option_clone$14nprly, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; +import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pdxnel as option_map$1pdxnel, map$093awy8 as option_map$093awy8, map$0aug5m6 as option_map$0aug5m6, map$16w3l9s as option_map$16w3l9s, map$1y26nmr as option_map$1y26nmr, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$0tj0y3q as option_mapOr$0tj0y3q, mapOr$0f7cus0 as option_mapOr$0f7cus0, mapOr$0vkblkh as option_mapOr$0vkblkh, mapOr$07jk2xl as option_mapOr$07jk2xl, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0pgapuk as option_mapOr$0pgapuk, mapOr$13kt6x8 as option_mapOr$13kt6x8, mapOr$1wei0sy as option_mapOr$1wei0sy, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$18dcmgz as option_mapOr$18dcmgz, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt, mapOr$1f8lrju as option_mapOr$1f8lrju, mapOr$05q90i2 as option_mapOr$05q90i2, mapOr$0955beb as option_mapOr$0955beb, mapOr$1h9hu6n as option_mapOr$1h9hu6n, clone$14nprly as option_clone$14nprly, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; import { eq$1a91ieh as result_eq$1a91ieh, eq$122baxc as result_eq$122baxc } from "./core/result.ts"; import { put } from "./harness.ts"; @@ -6261,4 +6262,193 @@ export function btreeSearches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): } } +/** + * std's B-tree searched by a form its keys lend by the crate's own `Borrow`, which it + * orders by that form's `Ord` against what each key lends, as `Probe` logs: of a map and a + * set whose keys' ends and ids rise with their starts, or of odd `kind`s fall, so a search + * by one disagrees with the tree's order. Each answer is followed by the log. + */ +export function btreeBorrows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _29!: rs.usize; + let _199!: [rs.u8, rs.u8]; + const _22: (a0: rs.u8) => rs.u16 = (b2: rs.u8): rs.u16 => { + return rs.u16Mul(b2 as rs.u16, 4) ^ 256; + }; + const _23: (a0: rs.u16 | undefined) => rs.u16 = (v: rs.u16 | undefined): rs.u16 => { + return option_mapOr$1wei0sy(v, 65535, (v2: rs.u16): rs.u16 => { + return v2; + }); + }; + const log: rs.Cell = new rs.Cell(0); + const at: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), 0); + }; + const put: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, answer: rs.u16): undefined => { + rs.iterExtendBytes(out2, rs.iterSlice(rs.u16ToBeBytes(answer).reverse()), undefined, true); + rs.iterExtendBytes(out2, rs.iterSlice(rs.u32ToBeBytes(rs.cellReplace(log, 0)).reverse()), undefined, true); + }; + const n: rs.usize = rs.usizeAdd(at(0) as rs.usize, 1); + const falls: boolean = rs.u8Rem(kind, 2) === 1; + const lent: (a0: rs.usize) => Lent.Lent = (i3: rs.usize): Lent.Lent => { + let end!: rs.u16; + const start: rs.u16 = rs.usizeMul(i3, 7) & 0xffff & 1023; + if (!falls) { + end = rs.u16Add(start, 3); + } else { + end = rs.u16Sub(1023, start); + } + return { start: { _0: start, _1: log }, end: { _0: end, _1: log }, id: end ^ 256 }; + }; + const probe: (a0: rs.u8) => Probe.Probe = (b3: rs.u8): Probe.Probe => { + return { _0: rs.u16Add(rs.u16Mul(b3 as rs.u16, 4), b3 >> 6 as rs.u16), _1: log }; + }; + const map: rs.BTreeMap = rs.btreeNew(Lent.cmp$cmp_Ord) as rs.BTreeMap; + const set: rs.BTreeSet = rs.btreeNew(Lent.cmp$cmp_Ord) as rs.BTreeSet; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = n; + while ((_29 = iterStart++) < iterEnd) { + const i: rs.usize = _29; + const _35: Lent.Lent = lent(i); + rs.btreeInsert(map, _35, i & 0xffff); + const _41: Lent.Lent = lent(rs.usizeMul(i, 2)); + rs.btreeAdd(set, _41); + } + const part2 = rs.btreeLen(map) & 0xffff; + put(out, part2); + for (const b of rs.byteSliceView(rs.byteSliceRange(data, rs.min(data.length, 4)))) { + const _72: Probe.Probe = probe(b); + const part4 = rs.btreeGet(map, rs.by(_72, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)); + const part5 = _23(part4); + put(out, part5); + const _84: rs.u16 = _22(b); + const part6 = rs.btreeGet(map, rs.by(_84, rs.cmp, Lent.borrow$Borrow_u16)); + const part7 = _23(part6); + put(out, part7); + const _90: Probe.Probe = probe(b ^ 1); + const _87: rs.Place | undefined = rs.btreeGetMut(map, rs.by(_90, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)); + if (_87 !== undefined) { + _87.v = rs.u16Add(_87.v, 1); + } + const _104: Probe.Probe = probe(b); + const part8 = option_mapOr$1f8lrju(rs.btreeGetKeyValue(map, rs.by(_104, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)), 65535, (_2: [Lent.Lent, rs.u16]): rs.u16 => { + return _2[0].start._0 ^ _2[1]; + }); + put(out, part8); + const _114: rs.u16 = _22(b ^ 2); + const part9 = rs.btreeContains(map, rs.by(_114, rs.cmp, Lent.borrow$Borrow_u16)) ? 1 : 0; + put(out, part9); + const _121: Probe.Probe = probe(b); + if (rs.btreeContains(map, rs.by(_121, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe))) { + const _131: Probe.Probe = probe(b); + const part10 = rs.btreeIndex(map, rs.by(_131, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)); + put(out, part10); + } + const _141: Probe.Probe = probe(b); + const part11 = rs.btreeContains(set, rs.by(_141, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)) ? 1 : 0; + put(out, part11); + const _151: rs.u16 = _22(b); + const part12 = option_mapOr$0tj0y3q(rs.btreeKey(set, rs.by(_151, rs.cmp, Lent.borrow$Borrow_u16)), 65535, (k: Lent.Lent): rs.u16 => { + return k.start._0; + }); + put(out, part12); + const _154: rs.u8 = rs.u8Rem(b, 5); + if (_154 === 0) { + const _162: Probe.Probe = probe(b); + const part17 = option_unwrapOr$1szdyfq(rs.btreeRemove(map, rs.by(_162, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)), 65535); + put(out, part17); + } else if (_154 === 1) { + const _171: rs.u16 = _22(b); + const part16 = option_mapOr$1f8lrju(rs.btreeRemoveEntry(map, rs.by(_171, rs.cmp, Lent.borrow$Borrow_u16)), 65535, (_24: [Lent.Lent, rs.u16]): rs.u16 => { + return _24[0].id ^ _24[1]; + }); + put(out, part16); + } else if (_154 === 2) { + const _180: Probe.Probe = probe(b); + const part15 = rs.btreeDelete(set, rs.by(_180, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)) ? 1 : 0; + put(out, part15); + } else if (_154 === 3) { + const _189: rs.u16 = _22(b); + const part14 = option_mapOr$0tj0y3q(rs.btreeKey(set, rs.by(_189, rs.cmp, Lent.borrow$Borrow_u16), true), 65535, (k2: Lent.Lent): rs.u16 => { + return k2.id; + }); + put(out, part14); + } else { + const part13 = rs.btreeLen(map) & 0xffff; + put(out, part13); + } + } + if (!(rs.u8Rem(kind, 4) < 2)) { + _199 = [at(1), at(2)] as [rs.u8, rs.u8]; + } else { + _199 = [rs.min(at(1), at(2)), rs.max(at(1), at(2))] as [rs.u8, rs.u8]; + } + const lo: rs.u8 = _199[0]; + const hi: rs.u8 = _199[1]; + const iter3: rs.Iter<[rs.RangeBound, rs.RangeBound]> = rs.iterSlice([[{ tag: "Excluded", _0: probe(lo) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], [{ tag: "Included", _0: probe(lo) } as rs.RangeBound, { tag: "Excluded", _0: probe(hi) } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: probe(hi) } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], [{ tag: "Excluded", _0: probe(lo) } as rs.RangeBound, { tag: "Included", _0: probe(hi) } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]]); + l8: while (true) { + const _256: [rs.RangeBound, rs.RangeBound] | rs.Done = iter3.next(); + if (_256 === rs.DONE) { + break; + } + const iter4: rs.Iter<[Lent.Lent, rs.u16]> = rs.btreeRange(map, rs.by(_256, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe), Probe.eq$cmp_PartialEq, Probe.gt$cmp_PartialOrd); + while (true) { + const _264: [Lent.Lent, rs.u16] | rs.Done = iter4.next(); + if (_264 === rs.DONE) { + continue l8; + } + put(out, _264[0].start._0 ^ _264[1]); + } + } + const _280: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: probe(lo) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + const iter5: rs.Iter<[Lent.Lent, rs.u16]> = rs.btreeRange(map, rs.by(_280, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe), Probe.eq$cmp_PartialEq, Probe.gt$cmp_PartialOrd); + while (true) { + const _285: [Lent.Lent, rs.u16] | rs.Done = iter5.next(); + if (_285 === rs.DONE) { + break; + } + put(out, _285[0].start._0 ^ _285[1]); + } + const _298: rs.RangeInclusive = new rs.RangeInclusive(_22(lo), _22(hi), rs.u16Step); + const iter6: rs.Iter<[Lent.Lent, rs.Place]> = rs.btreeRangeMut(map, rs.by(_298, rs.cmp, Lent.borrow$Borrow_u16)); + while (true) { + const _306: [Lent.Lent, rs.Place] | rs.Done = iter6.next(); + if (_306 === rs.DONE) { + break; + } + _306[1].v = _306[1].v ^ 85; + } + const _313: rs.Range = new rs.Range(_22(lo), _22(hi)); + const iter7: rs.Iter = rs.btreeRangeKeys(set, rs.by(_313, rs.cmp, Lent.borrow$Borrow_u16)); + while (true) { + const _321: Lent.Lent | rs.Done = iter7.next(); + if (_321 === rs.DONE) { + break; + } + put(out, _321.id); + } + const _333: { end: Probe.Probe } = { end: probe(hi) }; + const iter8: rs.Iter = rs.iterRev(rs.btreeRangeKeys(set, rs.by(_333, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe), Probe.eq$cmp_PartialEq, Probe.gt$cmp_PartialOrd)); + while (true) { + const _338: Lent.Lent | rs.Done = iter8.next(); + if (_338 === rs.DONE) { + break; + } + put(out, _338.start._0); + } + const part21 = at(3); + const _349: Probe.Probe = probe(part21); + const right: rs.BTreeMap = rs.btreeSplitOff(map, rs.by(_349, Probe.cmp$cmp_Ord, Lent.borrow$Borrow_collections_Probe)); + const part22 = rs.usizeAdd(rs.usizeMul(rs.btreeLen(map), 1000), rs.btreeLen(right)) & 0xffff; + put(out, part22); + const part23 = at(3); + const _370: rs.u16 = _22(part23); + const high: rs.BTreeSet = rs.btreeSplitOff(set, rs.by(_370, rs.cmp, Lent.borrow$Borrow_u16)); + const part24 = rs.usizeAdd(rs.usizeMul(rs.btreeLen(set), 1000), rs.btreeLen(high)) & 0xffff; + put(out, part24); + const part25 = rs.iterFold(rs.btreeValues(right), 0, (a: rs.u16, v4: rs.u16): rs.u16 => { + return a ^ v4; + }); + put(out, part25); +} + //# sourceMappingURL=collections.ts.map diff --git a/ts/fixtures/lang/collections/expected/core/option.ts b/ts/fixtures/lang/collections/expected/core/option.ts index 0210b408c..6af90f86a 100644 --- a/ts/fixtures/lang/collections/expected/core/option.ts +++ b/ts/fixtures/lang/collections/expected/core/option.ts @@ -3,6 +3,7 @@ import * as rs from "../rs.ts"; import type * as ByRef from "../collections.ByRef.ts"; import type * as ByVal from "../collections.ByVal.ts"; +import type * as Lent from "../collections.Lent.ts"; import type * as Mixed from "../collections.Mixed.ts"; import type * as Nibble from "../collections.Nibble.ts"; import type * as Picky from "../collections.Picky.ts"; @@ -73,6 +74,13 @@ export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: return f(self); } +export function mapOr$0tj0y3q(self: Lent.Lent | undefined, default_: rs.u16, f: (a0: Lent.Lent) => rs.u16): rs.u16 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0f7cus0(self: Nibble.Nibble | undefined, default_: rs.u8, f: (a0: Nibble.Nibble) => rs.u8): rs.u8 { if (self === undefined) { return default_; @@ -164,6 +172,13 @@ export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a return f(self); } +export function mapOr$1f8lrju(self: [Lent.Lent, rs.u16] | undefined, default_: rs.u16, f: (a0: [Lent.Lent, rs.u16]) => rs.u16): rs.u16 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$05q90i2(self: [Probe.Probe, rs.u16] | undefined, default_: rs.u16, f: (a0: [Probe.Probe, rs.u16]) => rs.u16): rs.u16 { if (self === undefined) { return default_; diff --git a/ts/fixtures/lang/collections/expected/lib.ts b/ts/fixtures/lang/collections/expected/lib.ts index 135eb357a..c88f821e8 100644 --- a/ts/fixtures/lang/collections/expected/lib.ts +++ b/ts/fixtures/lang/collections/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { hashMaps, sets, btreeMaps, deques, dequeRanges, vecs, stores, optionals, setOps, unlikeEqs, ownNes, cellEqs, unlikeCompares, refOrders, extracts, btreeExtracts, btreeSearches } from "./collections.ts"; +import { hashMaps, sets, btreeMaps, deques, dequeRanges, vecs, stores, optionals, setOps, unlikeEqs, ownNes, cellEqs, unlikeCompares, refOrders, extracts, btreeExtracts, btreeSearches, btreeBorrows } from "./collections.ts"; import type * as Bumped from "./collections.Bumped.ts"; import type * as Logged from "./collections.Logged.ts"; import type * as Picky from "./collections.Picky.ts"; @@ -100,7 +100,7 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By vecs(data2, out2); }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::stores", (_212: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { stores(data3, out3); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::optionals", optionals as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::cell_eqs", cellEqs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::unlike_compares", unlikeCompares as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::ref_orders", refOrders as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::deque_ranges", dequeRanges as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::extracts", extracts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::btree_extracts", btreeExtracts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::btree_searches", btreeSearches as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::optionals", optionals as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::cell_eqs", cellEqs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::unlike_compares", unlikeCompares as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::ref_orders", refOrders as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::deque_ranges", dequeRanges as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::extracts", extracts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::btree_extracts", btreeExtracts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::btree_searches", btreeSearches as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::btree_borrows", btreeBorrows as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/collections/src/collections.rs b/ts/fixtures/lang/collections/src/collections.rs index 113a87279..814aeedc2 100644 --- a/ts/fixtures/lang/collections/src/collections.rs +++ b/ts/fixtures/lang/collections/src/collections.rs @@ -2552,3 +2552,133 @@ pub fn btree_searches(kind: u8, data: &[u8], out: &mut Vec) { } } } + +/// A B-tree key ordered by its `start`, which lends its `end`, as rangemap's start wrapper +/// lends its end wrapper, and its `id`, a form of std's. +struct Lent<'a> { + start: Probe<'a>, + end: Probe<'a>, + id: u16, +} + +impl PartialEq for Lent<'_> { + fn eq(&self, other: &Self) -> bool { + self.start == other.start + } +} + +impl Eq for Lent<'_> {} + +impl PartialOrd for Lent<'_> { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for Lent<'_> { + fn cmp(&self, other: &Self) -> Ordering { + self.start.cmp(&other.start) + } +} + +impl<'a> std::borrow::Borrow> for Lent<'a> { + fn borrow(&self) -> &Probe<'a> { + &self.end + } +} + +impl std::borrow::Borrow for Lent<'_> { + fn borrow(&self) -> &u16 { + &self.id + } +} + +/// std's B-tree searched by a form its keys lend by the crate's own `Borrow`, which it +/// orders by that form's `Ord` against what each key lends, as `Probe` logs: of a map and a +/// set whose keys' ends and ids rise with their starts, or of odd `kind`s fall, so a search +/// by one disagrees with the tree's order. Each answer is followed by the log. +pub fn btree_borrows(kind: u8, data: &[u8], out: &mut Vec) { + let log = std::cell::Cell::new(0u32); + let at = |i: usize| data.get(i).copied().unwrap_or(0); + let put = |out: &mut Vec, answer: u16| { + out.extend(answer.to_le_bytes()); + out.extend(log.replace(0).to_le_bytes()); + }; + let n = usize::from(at(0)) + 1; + let falls = kind % 2 == 1; + let lent = |i: usize| { + let start = (i * 7) as u16 & 0x3ff; + let end = if falls { 0x3ff - start } else { start + 3 }; + Lent { + start: Probe(start, &log), + end: Probe(end, &log), + id: end ^ 0x100, + } + }; + let probe = |b: u8| Probe(u16::from(b) * 4 + u16::from(b >> 6), &log); + let id = |b: u8| (u16::from(b) * 4) ^ 0x100; + let some = |v: Option<&u16>| v.map_or(0xffff, |v| *v); + let mut map: BTreeMap = BTreeMap::new(); + let mut set: BTreeSet = BTreeSet::new(); + for i in 0..n { + map.insert(lent(i), i as u16); + set.insert(lent(i * 2)); + } + put(out, map.len() as u16); + for &b in &data[data.len().min(4)..] { + put(out, some(map.get(&probe(b)))); + put(out, some(map.get(&id(b)))); + if let Some(v) = map.get_mut(&probe(b ^ 1)) { + *v += 1; + } + put(out, map.get_key_value(&probe(b)).map_or(0xffff, |(k, v)| k.start.0 ^ v)); + put(out, map.contains_key(&id(b ^ 2)) as u16); + if map.contains_key(&probe(b)) { + put(out, map[&probe(b)]); + } + put(out, set.contains(&probe(b)) as u16); + put(out, set.get(&id(b)).map_or(0xffff, |k| k.start.0)); + match b % 5 { + 0 => put(out, map.remove(&probe(b)).unwrap_or(0xffff)), + 1 => put(out, map.remove_entry(&id(b)).map_or(0xffff, |(k, v)| k.id ^ v)), + 2 => put(out, set.remove(&probe(b)) as u16), + 3 => put(out, set.take(&id(b)).map_or(0xffff, |k| k.id)), + _ => put(out, map.len() as u16), + } + } + // Backwards with `kind` 2, which std's checks by the form's `gt` and panics on. + let (lo, hi) = match kind % 4 < 2 { + true => (at(1).min(at(2)), at(1).max(at(2))), + false => (at(1), at(2)), + }; + let ranges: [(Bound, Bound); 4] = [ + (Bound::Excluded(probe(lo)), Bound::Unbounded), + (Bound::Included(probe(lo)), Bound::Excluded(probe(hi))), + (Bound::Unbounded, Bound::Included(probe(hi))), + (Bound::Excluded(probe(lo)), Bound::Included(probe(hi))), + ]; + for range in ranges { + for (k, v) in map.range::(range) { + put(out, k.start.0 ^ v); + } + } + // rangemap's form: a bound of a reference. + let sliver = probe(lo); + for (k, v) in map.range::, Bound<_>)>((Bound::Excluded(&sliver), Bound::Unbounded)) { + put(out, k.start.0 ^ v); + } + for (_, v) in map.range_mut::(id(lo)..=id(hi)) { + *v ^= 0x55; + } + for k in set.range::(id(lo)..id(hi)) { + put(out, k.id); + } + for k in set.range::(..probe(hi)).rev() { + put(out, k.start.0); + } + let right = map.split_off(&probe(at(3))); + put(out, (map.len() * 1000 + right.len()) as u16); + let high = set.split_off(&id(at(3))); + put(out, (set.len() * 1000 + high.len()) as u16); + put(out, right.values().fold(0, |a, v| a ^ v)); +} diff --git a/ts/fixtures/lang/collections/src/lib.rs b/ts/fixtures/lang/collections/src/lib.rs index 9b0d32573..7d5d7e685 100644 --- a/ts/fixtures/lang/collections/src/lib.rs +++ b/ts/fixtures/lang/collections/src/lib.rs @@ -33,5 +33,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("collections::extracts", collections::extracts), ("collections::btree_extracts", collections::btree_extracts), ("collections::btree_searches", collections::btree_searches), + ("collections::btree_borrows", collections::btree_borrows), ] } diff --git a/ts/fixtures/lang/drops/expected/drops.ts b/ts/fixtures/lang/drops/expected/drops.ts index 6d266fee6..2f8c54a0d 100644 --- a/ts/fixtures/lang/drops/expected/drops.ts +++ b/ts/fixtures/lang/drops/expected/drops.ts @@ -519,7 +519,7 @@ export function drops(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { }, how, log); } else if (_27 === 4) { ways$drops_InPlain_drops_Logged_drops_drops_closure7((b8: rs.u8): InPlain.InPlain => { - return new InPlain.InPlain(new Plain.Plain(rs.vecFrom([l(rs.u8Add(b8, 1)), l(rs.u8Add(b8, 2))]), b8), [either(rs.u8Add(b8, 3)), l(rs.u8Add(b8, 5))] as [Either.Either, Logged.Logged]); + return new InPlain.InPlain(new Plain.Plain(rs.vecFrom([l(rs.u8Add(b8, 1)), l(rs.u8Add(b8, 2))]), b8) as Plain.Plain>, [either(rs.u8Add(b8, 3)), l(rs.u8Add(b8, 5))] as [Either.Either, Logged.Logged]); }, how, log); } else if (_27 === 5) { ways$drops_InBox_drops_Logged_drops_drops_closure8((b7: rs.u8): InBox.InBox => { diff --git a/ts/fixtures/lang/iters/expected/core/option.ts b/ts/fixtures/lang/iters/expected/core/option.ts index 9038bc655..ffb5a6222 100644 --- a/ts/fixtures/lang/iters/expected/core/option.ts +++ b/ts/fixtures/lang/iters/expected/core/option.ts @@ -75,6 +75,20 @@ export function map$167hjon(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => s return rs.strCowStr(self); } +export function map$0og67wk(self: [rs.u8, string] | undefined, f: (a0: [rs.u8, string]) => string): string | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$1oqs2fe(self: [rs.u8, rs.u16] | undefined, f: (a0: [rs.u8, rs.u16]) => rs.u16): rs.u16 | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function map$0vu84i0(self: rs.u8 | undefined, f: (a0: rs.u8) => Badge.Badge): Badge.Badge | undefined { if (self === undefined) { return undefined; @@ -181,6 +195,13 @@ export function mapOr$02sqh24(self: rs.Place | undefined, default_: rs.u8 return f(self); } +export function mapOr$0g9tml1(self: string | undefined, default_: rs.u32, f: (a0: string) => rs.u32): rs.u32 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; @@ -188,6 +209,13 @@ export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: return f(self); } +export function mapOr$164lw4w(self: rs.u16 | undefined, default_: rs.u32, f: (a0: rs.u16) => rs.u32): rs.u32 { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; @@ -270,6 +298,20 @@ export function asDeref$0pg0e8a(self: rs.StrCow | undefined): string | undefined }); } +export function andThen$1g5wbds(self: rs.u8 | undefined, f: (a0: rs.u8) => string | undefined): string | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function andThen$1fnqvxl(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u16 | undefined): rs.u16 | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) => boolean): rs.u8 | undefined { if (self !== undefined) { const x: rs.u8 = self; @@ -280,4 +322,11 @@ export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) = return undefined; } +export function clone$14nprly(self: string | undefined): string | undefined { + if (self === undefined) { + return undefined; + } + return self; +} + //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Holder.ts b/ts/fixtures/lang/iters/expected/iters.Holder.ts new file mode 100644 index 000000000..1993ee4ce --- /dev/null +++ b/ts/fixtures/lang/iters/expected/iters.Holder.ts @@ -0,0 +1,100 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; +import { map$0og67wk as option_map$0og67wk, map$1oqs2fe as option_map$1oqs2fe, mapOr$0g9tml1 as option_mapOr$0g9tml1, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$164lw4w as option_mapOr$164lw4w, andThen$1g5wbds as option_andThen$1g5wbds, andThen$1fnqvxl as option_andThen$1fnqvxl, clone$14nprly as option_clone$14nprly } from "./core/option.ts"; + +/** + * std's iterators held in the crate's own fields, over a parameter's items, as rangemap's + * iterators hold a B-tree's. + */ +export class Holder { + slice: rs.Iter>; + tree: rs.Iter<[rs.u8, rs.Ptr]>; + owned: rs.Iter; + peeked: rs.Peekable; + last: T | undefined; + + constructor(slice: rs.Iter>, tree: rs.Iter<[rs.u8, rs.Ptr]>, owned: rs.Iter, peeked: rs.Peekable, last: T | undefined) { + this.slice = slice; + this.tree = tree; + this.owned = owned; + this.peeked = peeked; + this.last = last; + } +} + +/** One step of each by `op`, writing what it yields by `code`, and the item it last took. */ +export function step$String_slice_Iter_u8(self: Holder>, op: rs.u8, code: (a0: string) => rs.u32, out: rs.ByteVec): void { + let item!: string | undefined; + const _6: rs.u8 = rs.u8Rem(op, 6); + if (_6 === 0) { + const _8: string | undefined = rs.iterToOption((self.slice as rs.Iter).next()); + item = _8 === undefined ? undefined : _8; + } else if (_6 === 1) { + const _10: string | undefined = rs.iterToOption((self.slice as rs.Iter).nextBack()); + item = _10 === undefined ? undefined : _10; + } else if (_6 === 2) { + item = option_map$0og67wk(rs.iterToOption((self.tree as rs.Iter<[rs.u8, string]>).next()), (_210: [rs.u8, string]): string => { + return _210[1]; + }); + } else if (_6 === 3) { + item = option_map$0og67wk(rs.iterToOption((self.tree as rs.Iter<[rs.u8, string]>).nextBack()), (_25: [rs.u8, string]): string => { + return _25[1]; + }); + } else if (_6 === 4) { + item = rs.iterToOption(self.owned.next()); + } else { + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.peekablePeek(self.peeked), 255, (_2: rs.u8): rs.u8 => { + return _2; + })); + item = option_andThen$1g5wbds(rs.peekableNextIf(self.peeked, (_22: rs.u8): boolean => { + return rs.u8Rem(_22, 2) === 0; + }), (_24: rs.u8): string | undefined => { + return option_clone$14nprly(self.last); + }); + } + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$0g9tml1(item, 4294967295, code)).reverse()), undefined, true); + if (item !== undefined) { + self.last = item; + } + rs.byteVecPush(out, (self.slice as rs.Iter).len() & 0xff); + rs.byteVecPush(out, self.owned.len() & 0xff); +} + +/** One step of each by `op`, writing what it yields by `code`, and the item it last took. */ +export function step$u16_slice_Iter_u8(self: Holder>, op: rs.u8, code: (a0: rs.u16) => rs.u32, out: rs.ByteVec): void { + let item!: rs.u16 | undefined; + const _6: rs.u8 = rs.u8Rem(op, 6); + if (_6 === 0) { + item = rs.iterToOption((self.slice as rs.Iter).next()); + } else if (_6 === 1) { + item = rs.iterToOption((self.slice as rs.Iter).nextBack()); + } else if (_6 === 2) { + item = option_map$1oqs2fe(rs.iterToOption((self.tree as rs.Iter<[rs.u8, rs.u16]>).next()), (_210: [rs.u8, rs.u16]): rs.u16 => { + return _210[1]; + }); + } else if (_6 === 3) { + item = option_map$1oqs2fe(rs.iterToOption((self.tree as rs.Iter<[rs.u8, rs.u16]>).nextBack()), (_25: [rs.u8, rs.u16]): rs.u16 => { + return _25[1]; + }); + } else if (_6 === 4) { + item = rs.iterToOption(self.owned.next()); + } else { + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.peekablePeek(self.peeked), 255, (_2: rs.u8): rs.u8 => { + return _2; + })); + item = option_andThen$1fnqvxl(rs.peekableNextIf(self.peeked, (_22: rs.u8): boolean => { + return rs.u8Rem(_22, 2) === 0; + }), (_24: rs.u8): rs.u16 | undefined => { + return self.last; + }); + } + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$164lw4w(item, 4294967295, code)).reverse()), undefined, true); + if (item !== undefined) { + self.last = item; + } + rs.byteVecPush(out, (self.slice as rs.Iter).len() & 0xff); + rs.byteVecPush(out, self.owned.len() & 0xff); +} + +//# sourceMappingURL=iters.Holder.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index a6b5eeba6..a454fea78 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -3,7 +3,7 @@ import * as rs from "./rs.ts"; import { drop$iters_Ticks, of$u8 } from "./lib.ts"; import { thenSome$1ctlqen, thenSome$1gvhopg, thenSome$0quywni, thenSome$1n1oy1h } from "./core/bool.ts"; -import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$00tqxtm as option_unwrapOr$00tqxtm, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$1g3ltyz as option_unwrapOr$1g3ltyz, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$1uo1d4o as option_map$1uo1d4o, map$1bpbukm as option_map$1bpbukm, map$0vu84i0 as option_map$0vu84i0, map$1806e7m as option_map$1806e7m, map$1yjmt5m as option_map$1yjmt5m, map$057a36e as option_map$057a36e, map$14ju55r as option_map$14ju55r, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$127irwp as option_mapOr$127irwp, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1i4rvy8 as option_mapOr$1i4rvy8, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$041x3r2 as option_mapOr$041x3r2, mapOr$14runhi as option_mapOr$14runhi, mapOr$0dfpyun as option_mapOr$0dfpyun, mapOr$0p9po8x as option_mapOr$0p9po8x, mapOr$02sqh24 as option_mapOr$02sqh24, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0llggqq as option_mapOr$0llggqq, mapOr$1ifh11y as option_mapOr$1ifh11y, mapOr$1r07vli as option_mapOr$1r07vli, mapOr$0olig48 as option_mapOr$0olig48, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$17ts8jj as option_mapOr$17ts8jj, mapOr$07pvkk0 as option_mapOr$07pvkk0, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0pg0e8a as option_asDeref$0pg0e8a, filter$0hq86nl } from "./core/option.ts"; +import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$00tqxtm as option_unwrapOr$00tqxtm, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$1g3ltyz as option_unwrapOr$1g3ltyz, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$1uo1d4o as option_map$1uo1d4o, map$1bpbukm as option_map$1bpbukm, map$0vu84i0 as option_map$0vu84i0, map$1806e7m as option_map$1806e7m, map$1yjmt5m as option_map$1yjmt5m, map$057a36e as option_map$057a36e, map$14ju55r as option_map$14ju55r, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$127irwp as option_mapOr$127irwp, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1i4rvy8 as option_mapOr$1i4rvy8, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$041x3r2 as option_mapOr$041x3r2, mapOr$14runhi as option_mapOr$14runhi, mapOr$0dfpyun as option_mapOr$0dfpyun, mapOr$0p9po8x as option_mapOr$0p9po8x, mapOr$02sqh24 as option_mapOr$02sqh24, mapOr$0g9tml1 as option_mapOr$0g9tml1, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$164lw4w as option_mapOr$164lw4w, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0llggqq as option_mapOr$0llggqq, mapOr$1ifh11y as option_mapOr$1ifh11y, mapOr$1r07vli as option_mapOr$1r07vli, mapOr$0olig48 as option_mapOr$0olig48, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$17ts8jj as option_mapOr$17ts8jj, mapOr$07pvkk0 as option_mapOr$07pvkk0, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0pg0e8a as option_asDeref$0pg0e8a, filter$0hq86nl } from "./core/option.ts"; import { unwrapOr$0a3q6xs as result_unwrapOr$0a3q6xs } from "./core/result.ts"; import type * as Badge from "./iters.Badge.ts"; import * as Bag from "./iters.Bag.ts"; @@ -14,6 +14,7 @@ import * as Evens from "./iters.Evens.ts"; import * as Gaps from "./iters.Gaps.ts"; import * as Halving from "./iters.Halving.ts"; import * as Held from "./iters.Held.ts"; +import * as Holder from "./iters.Holder.ts"; import * as Logged from "./iters.Logged.ts"; import * as Noted from "./iters.Noted.ts"; import * as Phase from "./iters.Phase.ts"; @@ -11642,4 +11643,68 @@ export function byValue(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void rs.refRelease(_258); } +/** `Holder` over items `make` makes of the input, stepped by its bytes. */ +export function held$String_iters_held_fields_closure2(data: rs.ByteSlice, make: (a0: rs.u8) => string, code: (a0: string) => rs.u32, out: rs.ByteVec): void { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): string => { + return make(_2); + }), undefined, 12, true); + const _11: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, string] => { + const b2: rs.u8 = _24; + return [b2, make(b2)] as [rs.u8, string]; + }); + const tree: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _11, true, undefined, undefined, undefined, 16, true); + const _17: [rs.u8, rs.u8] = [option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), option_unwrapOr$1fr498u(rs.byteSliceLast(data), 0)]; + const lo: rs.u8 = _17[0]; + const hi: rs.u8 = _17[1]; + const held: Holder.Holder> = new Holder.Holder(rs.iterSlice(items.items) as rs.Iter>, rs.btreeRange(tree, new rs.RangeInclusive(rs.min(lo, hi), rs.max(lo, hi), rs.u8Step)) as rs.Iter<[rs.u8, rs.Ptr]>, rs.vecIntoIter(rs.vecFrom(items.items.slice())), rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))), undefined); + for (const _41 of rs.byteSliceView(data)) { + Holder.step$String_slice_Iter_u8(held, _41, code, out); + } + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$0g9tml1(held.last, 4294967295, code)).reverse()), undefined, true); +} + +/** `Holder` over items `make` makes of the input, stepped by its bytes. */ +export function held$u16_iters_held_fields_closure0(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u16, code: (a0: rs.u16) => rs.u32, out: rs.ByteVec): void { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return make(_2); + }), undefined, 2, true); + const _11: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, rs.u16] => { + const b2: rs.u8 = _24; + return [b2, make(b2)] as [rs.u8, rs.u16]; + }); + const tree: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _11, true, undefined, undefined, undefined, 4, true); + const _17: [rs.u8, rs.u8] = [option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), option_unwrapOr$1fr498u(rs.byteSliceLast(data), 0)]; + const lo: rs.u8 = _17[0]; + const hi: rs.u8 = _17[1]; + const held: Holder.Holder> = new Holder.Holder(rs.iterSlice(items.items) as rs.Iter>, rs.btreeRange(tree, new rs.RangeInclusive(rs.min(lo, hi), rs.max(lo, hi), rs.u8Step)) as rs.Iter<[rs.u8, rs.Ptr]>, rs.vecIntoIter(rs.vecFrom(items.items.slice())), rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))), undefined); + for (const _41 of rs.byteSliceView(data)) { + Holder.step$u16_slice_Iter_u8(held, _41, code, out); + } + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$164lw4w(held.last, 4294967295, code)).reverse()), undefined, true); +} + +/** + * std's iterators held in fields of the crate's own generic struct, of numbers, which JS + * copies, and of strings, which it shares. + */ +export function heldFields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + if (rs.u8Rem(kind, 2) === 0) { + held$u16_iters_held_fields_closure0(data, (b2: rs.u8): rs.u16 => { + return rs.u16Mul(b2 as rs.u16, 300); + }, (v: rs.u16): rs.u32 => { + return v as rs.u32; + }, out); + } else { + held$String_iters_held_fields_closure2(data, (b: rs.u8): string => { + return rs.stringExtend("", rs.iterMap(new rs.Range(0, rs.u8Rem(b, 5)), (_2: rs.u8): string => { + return "ab"; + })); + }, (s: string): rs.u32 => { + return rs.u32Add(rs.u32Mul(rs.stringLen(s) as rs.u32, 1000), rs.iterSum(rs.iterMap(rs.strBytes(s), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; + }), rs.u32Add, 0)); + }, out); + } +} + //# sourceMappingURL=iters.ts.map diff --git a/ts/fixtures/lang/iters/expected/lib.ts b/ts/fixtures/lang/iters/expected/lib.ts index 5a582c245..dc4d2aa3f 100644 --- a/ts/fixtures/lang/iters/expected/lib.ts +++ b/ts/fixtures/lang/iters/expected/lib.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. import * as rs from "./rs.ts"; -import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, optionItems, own, values, returned, zips, zipsBack, rangeFroms, rangeMethods, compares, lent, byValue } from "./iters.ts"; +import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, optionItems, own, values, returned, zips, zipsBack, rangeFroms, rangeMethods, compares, lent, byValue, heldFields } from "./iters.ts"; import type * as Ticks from "./iters.Ticks.ts"; export function drop$iters_Ticks(_1: Ticks.Ticks): void { @@ -41,7 +41,7 @@ export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.By optionItems(data8, out8); }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::lent", (_218: rs.u8, data9: rs.ByteSlice, out9: rs.ByteVec): undefined => { lent(data9, out9); - }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::by_value", byValue as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::by_value", byValue as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::held_fields", heldFields as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/iters/src/iters.rs b/ts/fixtures/lang/iters/src/iters.rs index 78086f9e8..265b64bc2 100644 --- a/ts/fixtures/lang/iters/src/iters.rs +++ b/ts/fixtures/lang/iters/src/iters.rs @@ -2146,3 +2146,69 @@ impl IntoIterator for Bag { Phase::of(self.0).chain(Phase::of(self.1)) } } + +/// std's iterators held in the crate's own fields, over a parameter's items, as rangemap's +/// iterators hold a B-tree's. +struct Holder<'a, T, I: Iterator> { + slice: std::slice::Iter<'a, T>, + tree: std::collections::btree_map::Range<'a, u8, T>, + owned: std::vec::IntoIter, + peeked: std::iter::Peekable, + last: Option, +} + +impl<'a, T: Clone, I: Iterator> Holder<'a, T, I> { + /// One step of each by `op`, writing what it yields by `code`, and the item it last took. + fn step(&mut self, op: u8, code: fn(&T) -> u32, out: &mut Vec) { + let item = match op % 6 { + 0 => self.slice.next().cloned(), + 1 => self.slice.next_back().cloned(), + 2 => self.tree.next().map(|(_, v)| v.clone()), + 3 => self.tree.next_back().map(|(_, v)| v.clone()), + 4 => self.owned.next(), + _ => { + let peeked = self.peeked.peek().map_or(0xff, |&&b| b); + out.push(peeked); + self.peeked.next_if(|&&b| b % 2 == 0).and_then(|_| self.last.clone()) + } + }; + out.extend(item.as_ref().map_or(u32::MAX, code).to_le_bytes()); + if item.is_some() { + self.last = item; + } + out.push(self.slice.len() as u8); + out.push(self.owned.len() as u8); + } +} + +/// `Holder` over items `make` makes of the input, stepped by its bytes. +fn held(data: &[u8], make: impl Fn(u8) -> T, code: fn(&T) -> u32, out: &mut Vec) { + let items: Vec = data.iter().map(|&b| make(b)).collect(); + let tree: std::collections::BTreeMap = data.iter().map(|&b| (b, make(b))).collect(); + let (lo, hi) = (data.first().copied().unwrap_or(0), data.last().copied().unwrap_or(0)); + let mut held = Holder { + slice: items.iter(), + tree: tree.range(lo.min(hi)..=lo.max(hi)), + owned: items.clone().into_iter(), + peeked: data.iter().peekable(), + last: None, + }; + for &op in data { + held.step(op, code, out); + } + out.extend(held.last.as_ref().map_or(u32::MAX, code).to_le_bytes()); +} + +/// std's iterators held in fields of the crate's own generic struct, of numbers, which JS +/// copies, and of strings, which it shares. +pub fn held_fields(kind: u8, data: &[u8], out: &mut Vec) { + match kind % 2 { + 0 => held(data, |b| u16::from(b) * 300, |v| u32::from(*v), out), + _ => held( + data, + |b| (0..b % 5).map(|_| "ab").collect::(), + |s| s.len() as u32 * 1000 + s.bytes().map(u32::from).sum::(), + out, + ), + } +} diff --git a/ts/fixtures/lang/iters/src/lib.rs b/ts/fixtures/lang/iters/src/lib.rs index c93019b34..7c2a00243 100644 --- a/ts/fixtures/lang/iters/src/lib.rs +++ b/ts/fixtures/lang/iters/src/lib.rs @@ -37,5 +37,6 @@ fn cases() -> Vec<(&'static str, Case)> { ("iters::option_items", |_, data, out| iters::option_items(data, out)), ("iters::lent", |_, data, out| iters::lent(data, out)), ("iters::by_value", iters::by_value), + ("iters::held_fields", iters::held_fields), ] } diff --git a/ts/fixtures/lang/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index 0c7318344..27c5d87df 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ts @@ -2285,7 +2285,7 @@ export function tagged$u8(a: Aimed.Aimed): [rs.Place, rs.u8] { /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$Cell_u8(to: rs.Place>, n: rs.u8, out: rs.ByteVec): void { - const shared: Swapped.Swapped> = { at: new rs.Atomic(rs.NULL) }; + const shared: Swapped.Swapped> = { at: new rs.Atomic(rs.NULL) as rs.Atomic>> }; rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>>, 4) === rs.NULL ? 1 : 0); rs.atomicStore(shared.at as rs.Atomic>>, to, 4); const at: rs.Place> = rs.atomicLoad(shared.at as rs.Atomic>>, 4); @@ -2296,7 +2296,7 @@ export function swappedIn$Cell_u8(to: rs.Place>, n: rs.u8, out: r /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$array2_u16(to: rs.Slice, n: rs.u8, out: rs.ByteVec): void { - const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) as rs.Atomic> }; rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); rs.atomicStore(shared.at as rs.Atomic>, to, 4); const at: rs.Slice = rs.atomicLoad(shared.at as rs.Atomic>, 4); @@ -2307,7 +2307,7 @@ export function swappedIn$array2_u16(to: rs.Slice, n: rs.u8, out: rs.Byt /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$array4_u8(to: rs.ByteSlice, n: rs.u8, out: rs.ByteVec): void { - const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) as rs.Atomic> }; rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic, 4) === rs.NULL ? 1 : 0); rs.atomicStore(shared.at as rs.Atomic, to, 4); const at: rs.ByteSlice = rs.atomicLoad(shared.at as rs.Atomic, 4); @@ -2318,7 +2318,7 @@ export function swappedIn$array4_u8(to: rs.ByteSlice, n: rs.u8, out: rs.ByteVec) /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$pointers_Housed_u8(to: Housed.Housed, n: rs.u8, out: rs.ByteVec): void { - const shared: Swapped.Swapped> = { at: new rs.Atomic(rs.NULL) }; + const shared: Swapped.Swapped> = { at: new rs.Atomic(rs.NULL) as rs.Atomic>> }; rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); rs.atomicStore(shared.at as rs.Atomic>, to, 4); const at: Housed.Housed = rs.atomicLoad(shared.at as rs.Atomic>, 4); @@ -2329,7 +2329,7 @@ export function swappedIn$pointers_Housed_u8(to: Housed.Housed, n: rs.u8, /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$pointers_Leaning(to: rs.Place, n: rs.u8, out: rs.ByteVec): void { - const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) as rs.Atomic> }; rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); rs.atomicStore(shared.at as rs.Atomic>, to, 4); const at: rs.Place = rs.atomicLoad(shared.at as rs.Atomic>, 4); @@ -2340,7 +2340,7 @@ export function swappedIn$pointers_Leaning(to: rs.Place, n: rs. /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$pointers_Paired(to: Paired.Paired, n: rs.u8, out: rs.ByteVec): void { - const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) as rs.Atomic> }; rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic, 4) === rs.NULL ? 1 : 0); rs.atomicStore(shared.at as rs.Atomic, to, 4); const at: Paired.Paired = rs.atomicLoad(shared.at as rs.Atomic, 4); @@ -2351,7 +2351,7 @@ export function swappedIn$pointers_Paired(to: Paired.Paired, n: rs.u8, out: rs.B /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ export function swappedIn$u8(to: rs.Place, n: rs.u8, out: rs.ByteVec): void { - const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) as rs.Atomic> }; rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); rs.atomicStore(shared.at as rs.Atomic>, to, 4); const at: rs.Place = rs.atomicLoad(shared.at as rs.Atomic>, 4); diff --git a/ts/fixtures/lang/shapes/expected/generics.Runs.ts b/ts/fixtures/lang/shapes/expected/generics.Runs.ts index 2a6866332..1ed68d69e 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Runs.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Runs.ts @@ -6,11 +6,11 @@ import { clone$14vwxlf as option_clone$14vwxlf, clone$0e53k5z as option_clone$0e import type * as Run from "./generics.Run.ts"; export function clone$Clone_u16(self: Runs): Runs { - return new Runs(copy$array_u16((self.array as rs.u16[]).slice()), rs.vecFrom((self.list as rs.Vec).items.slice()), self.view as rs.Slice, rs.sliceFrom(rs.sliceToArray(self.boxed as rs.Slice)), rs.cowClone(self.cow as rs.Cow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u16)), option_clone$14vwxlf(self.maybe as rs.Vec | undefined)); + return new Runs(copy$array_u16((self.array as rs.u16[]).slice()), rs.vecFrom((self.list as rs.Vec).items.slice()), self.view as rs.Slice, rs.sliceFrom(rs.sliceToArray(self.boxed as rs.Slice)), rs.cowClone(self.cow as rs.Cow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u16)) as rs.Vec>, option_clone$14vwxlf(self.maybe as rs.Vec | undefined)); } export function clone$Clone_u8(self: Runs): Runs { - return new Runs(copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(self.array as Uint8Array))), rs.byteVecFrom(rs.byteVecView(self.list as rs.ByteVec)), self.view as rs.ByteSlice, rs.byteSliceFrom(rs.byteSliceToArray(self.boxed as rs.ByteSlice)), rs.byteCowClone(self.cow as rs.ByteCow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u8)), option_clone$0e53k5z(self.maybe as rs.ByteVec | undefined)); + return new Runs(copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(self.array as Uint8Array))), rs.byteVecFrom(rs.byteVecView(self.list as rs.ByteVec)), self.view as rs.ByteSlice, rs.byteSliceFrom(rs.byteSliceToArray(self.boxed as rs.ByteSlice)), rs.byteCowClone(self.cow as rs.ByteCow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u8)) as rs.Vec>, option_clone$0e53k5z(self.maybe as rs.ByteVec | undefined)); } export function fmt$fmt_Debug_u16(self: Runs, f: rs.Formatter): rs.Result { diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index e106e8026..5b1dbe873 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -154,7 +154,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { return _2; }), undefined, true); const n: rs.u8 = option_unwrapOrDefault$03apme8(rs.byteSliceFirst(rs.byteVecSlice(data2))); - const runs: Runs.Runs = new Runs.Runs(rs.bytes(3).fill(n), rs.byteVecFrom(rs.byteVecView(data2)), rs.byteVecSlice(data2), rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(data2))), rs.byteVecSlice(data2), new rs.Vec(), then$0y7on52(rs.usizeRem(data2.length, 2) === 0, (): rs.ByteVec => { + const runs: Runs.Runs = new Runs.Runs(rs.bytes(3).fill(n), rs.byteVecFrom(rs.byteVecView(data2)), rs.byteVecSlice(data2), rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(data2))), rs.byteVecSlice(data2), new rs.Vec() as rs.Vec>, then$0y7on52(rs.usizeRem(data2.length, 2) === 0, (): rs.ByteVec => { return new rs.ByteVec(); })); const before: Runs.Runs = Runs.clone$Clone_u8(runs); @@ -200,7 +200,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { const n2: rs.u16 = option_unwrapOrDefault$0w7995p(rs.sliceFirst(rs.sliceFrom(data3.items))); const runs2: Runs.Runs = new Runs.Runs(Array.from({ length: 3 }, (): rs.u16 => { return n2; - }), rs.vecFrom(data3.items.slice()), rs.sliceFrom(data3.items), rs.sliceFrom(rs.vecFrom(data3.items.slice()).items), new rs.Borrowed(rs.sliceFrom(data3.items)), new rs.Vec(), then$01xsbgy(rs.usizeRem(data3.items.length, 2) === 0, (): rs.Vec => { + }), rs.vecFrom(data3.items.slice()), rs.sliceFrom(data3.items), rs.sliceFrom(rs.vecFrom(data3.items.slice()).items), new rs.Borrowed(rs.sliceFrom(data3.items)), new rs.Vec() as rs.Vec>, then$01xsbgy(rs.usizeRem(data3.items.length, 2) === 0, (): rs.Vec => { return new rs.Vec(); })); const before2: Runs.Runs = Runs.clone$Clone_u16(runs2); @@ -256,7 +256,7 @@ export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { } else { _266 = rs.vecFrom([tick(7)]); } - new Runs.Runs(_246, _256, _258, _260, _266, rs.vecFrom([[tick(5), tick(6)]]), option_map$0ggarad(rs.byteSliceFirst(data), (_210: rs.u8): rs.Vec => { + new Runs.Runs(_246, _256, _258, _260, _266, rs.vecFrom([[tick(5), tick(6)]]) as rs.Vec>, option_map$0ggarad(rs.byteSliceFirst(data), (_210: rs.u8): rs.Vec => { return rs.vecFrom([tick(~_210 & 0xff)]); }))[Symbol.dispose](); const _292: rs.usize = rs.usizeRem(data.length, 3); diff --git a/ts/fixtures/lang/shares/expected/shares.Shared.ts b/ts/fixtures/lang/shares/expected/shares.Shared.ts index 0a973f6c3..a38ce7fc8 100644 --- a/ts/fixtures/lang/shares/expected/shares.Shared.ts +++ b/ts/fixtures/lang/shares/expected/shares.Shared.ts @@ -21,15 +21,15 @@ export class Shared { } export function new$shares_Logged(items: rs.Vec): Shared { - return new Shared(new rs.Arc(rs.sliceFrom(items.items))); + return new Shared(new rs.Arc(rs.sliceFrom(items.items)) as rs.Arc>); } export function new$u8(items: rs.ByteVec): Shared { - return new Shared(new rs.Arc(rs.byteVecSlice(items))); + return new Shared(new rs.Arc(rs.byteVecSlice(items)) as rs.Arc>); } export function collected$u16_iter_Map_slice_Iter_u8_shares_generics_closure0(items: rs.Iter): Shared { - return new Shared(new rs.Arc(rs.sliceFrom(rs.iterToVec(items, undefined, 2, true).items))); + return new Shared(new rs.Arc(rs.sliceFrom(rs.iterToVec(items, undefined, 2, true).items)) as rs.Arc>); } export function first$shares_Logged(self: Shared): Logged.Logged | undefined { @@ -78,15 +78,15 @@ export function setLast$u8(self: Shared, item: rs.u8): void { } export function clone$Clone_shares_Logged(self: Shared): Shared { - return new Shared(rs.arcClone(self.items as rs.Arc>)); + return new Shared(rs.arcClone(self.items as rs.Arc>) as rs.Arc>); } export function clone$Clone_u16(self: Shared): Shared { - return new Shared(rs.arcClone(self.items as rs.Arc>)); + return new Shared(rs.arcClone(self.items as rs.Arc>) as rs.Arc>); } export function clone$Clone_u8(self: Shared): Shared { - return new Shared(rs.arcClone(self.items as rs.Arc)); + return new Shared(rs.arcClone(self.items as rs.Arc) as rs.Arc>); } //# sourceMappingURL=shares.Shared.ts.map diff --git a/ts/fixtures/stock/Cargo.toml b/ts/fixtures/stock/Cargo.toml index 53f57845e..7899e199f 100644 --- a/ts/fixtures/stock/Cargo.toml +++ b/ts/fixtures/stock/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "stock-fixture" -description = "Calls into bytes, hashbrown, rand, and tracing, which rust2-ts maps itself, and hashlink" +description = "Calls into bytes, hashbrown, rand, and tracing, which rust2-ts maps itself, hashlink, and rangemap" version = "0.0.0" edition.workspace = true license.workspace = true @@ -17,6 +17,7 @@ getrandom = "0.4.3" hashbrown = "0.17.1" hashlink = "0.12.2" rand = "0.10.3" +rangemap = "1.8.0" tracing = "0.1.44" [lints] diff --git a/ts/fixtures/stock/expected/core/cmp.ts b/ts/fixtures/stock/expected/core/cmp.ts index 5924327ca..dd8cd14e1 100644 --- a/ts/fixtures/stock/expected/core/cmp.ts +++ b/ts/fixtures/stock/expected/core/cmp.ts @@ -2,8 +2,16 @@ import * as rs from "../rs.ts"; +export function min$10dxkeu(v1: rs.u64, v2: rs.u64): rs.u64 { + return rs.u64Min(v1, v2); +} + export function min$00xoube(v1: rs.usize, v2: rs.usize): rs.usize { return rs.min(v1, v2); } +export function max$10jofma(v1: rs.u64, v2: rs.u64): rs.u64 { + return rs.u64Max(v1, v2); +} + //# sourceMappingURL=cmp.ts.map diff --git a/ts/fixtures/stock/expected/core/option.ts b/ts/fixtures/stock/expected/core/option.ts index ed8d563ed..529ef582f 100644 --- a/ts/fixtures/stock/expected/core/option.ts +++ b/ts/fixtures/stock/expected/core/option.ts @@ -2,6 +2,8 @@ import * as rs from "../rs.ts"; import type * as Logged from "../maps.Logged.ts"; +import type * as RangeInclusiveStartWrapper from "../rangemap/range_wrapper.RangeInclusiveStartWrapper.ts"; +import type * as RangeStartWrapper from "../rangemap/range_wrapper.RangeStartWrapper.ts"; export function unwrapOr$1b5hww3(self: rs.u32 | undefined, default_: rs.u32): rs.u32 { if (self === undefined) { @@ -24,6 +26,99 @@ export function unwrapOr$05jq4mv(self: rs.usize | undefined, default_: rs.usize) return self; } +export function map$1szk2qx(self: [rs.Range, undefined] | undefined, f: (a0: [rs.Range, undefined]) => rs.Range): rs.Range | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$1uwf58c(self: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined, f: (a0: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]) => [rs.RangeInclusive, rs.u32]): [rs.RangeInclusive, rs.u32] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$13fvwc4(self: [RangeStartWrapper.RangeStartWrapper, undefined] | undefined, f: (a0: [RangeStartWrapper.RangeStartWrapper, undefined]) => [rs.Range, undefined]): [rs.Range, undefined] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$0xbjbpp(self: [rs.RangeInclusive, undefined] | undefined, f: (a0: [rs.RangeInclusive, undefined]) => rs.RangeInclusive): rs.RangeInclusive | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$0j6jw4e(self: [rs.RangeInclusive, undefined] | undefined, f: (a0: [rs.RangeInclusive, undefined]) => undefined): undefined | rs.None { + if (self === undefined) { + return rs.None; + } + f(self); + return undefined; +} + +export function map$0wqo9kn(self: [rs.Range, rs.u64] | undefined, f: (a0: [rs.Range, rs.u64]) => rs.u64): rs.u64 | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$1yav3xg(self: [rs.Range, undefined] | undefined, f: (a0: [rs.Range, undefined]) => undefined): undefined | rs.None { + if (self === undefined) { + return rs.None; + } + f(self); + return undefined; +} + +export function map$0uvwlsi(self: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined, f: (a0: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]) => [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$05vmvpg(self: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined, f: (a0: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]) => [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$0q44qdt(self: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined, f: (a0: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]) => [rs.RangeInclusive, undefined]): [rs.RangeInclusive, undefined] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$02ffuo4(self: [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined, f: (a0: [RangeStartWrapper.RangeStartWrapper, rs.u64]) => [RangeStartWrapper.RangeStartWrapper, rs.u64]): [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$15xkbmr(self: [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined, f: (a0: [RangeStartWrapper.RangeStartWrapper, rs.u64]) => [rs.Range, rs.u64]): [rs.Range, rs.u64] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + +export function map$105h877(self: [RangeStartWrapper.RangeStartWrapper, undefined] | undefined, f: (a0: [RangeStartWrapper.RangeStartWrapper, undefined]) => [RangeStartWrapper.RangeStartWrapper, undefined]): [RangeStartWrapper.RangeStartWrapper, undefined] | undefined { + if (self === undefined) { + return undefined; + } + return f(self); +} + export function map$0faa8rw(self: [rs.u16, rs.Place] | undefined, f: (a0: [rs.u16, rs.Place]) => rs.Place): rs.Place | undefined { if (self === undefined) { return undefined; @@ -59,6 +154,13 @@ export function mapOr$17oc7db(self: rs.Place | undefined, default_: rs.u return f(self); } +export function mapOr$0ntbuih(self: rs.Range | undefined, default_: rs.Range, _: (a0: rs.Range) => rs.Range): rs.Range { + if (self === undefined) { + return default_; + } + return self.clone(); +} + export function mapOr$0o00yzv(self: [rs.u16, rs.u32] | undefined, default_: rs.usize, f: (a0: [rs.u16, rs.u32]) => rs.usize): rs.usize { if (self === undefined) { return default_; @@ -80,6 +182,27 @@ export function mapOr$0as7mjc(self: rs.u32 | undefined, default_: rs.usize, f: ( return f(self); } +export function mapOr$0mwbrmg(self: rs.u64 | undefined, default_: rs.u8, f: (a0: rs.u64) => rs.u8): rs.u8 { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$1ui9ilq(self: [rs.RangeInclusive, rs.u32] | undefined, default_: [rs.Range, rs.u32], f: (a0: [rs.RangeInclusive, rs.u32]) => [rs.Range, rs.u32]): [rs.Range, rs.u32] { + if (self === undefined) { + return default_; + } + return f(self); +} + +export function mapOr$0x6k90y(self: [rs.Range, rs.u64] | undefined, default_: rs.Range, f: (a0: [rs.Range, rs.u64]) => rs.Range): rs.Range { + if (self === undefined) { + return default_; + } + return f(self); +} + export function mapOr$0bhoutc(self: [rs.u16, rs.Place] | undefined, default_: rs.usize, f: (a0: [rs.u16, rs.Place]) => rs.usize): rs.usize { if (self === undefined) { return default_; @@ -87,6 +210,46 @@ export function mapOr$0bhoutc(self: [rs.u16, rs.Place] | undefined, defa return f(self); } +export function filter$1nfpslh(self: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined, predicate: (a0: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]) => boolean): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined { + if (self !== undefined) { + const x: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] = self; + if (predicate(x)) { + return x; + } + } + return undefined; +} + +export function filter$0w6ybci(self: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined, predicate: (a0: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]) => boolean): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined { + if (self !== undefined) { + const x: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] = self; + if (predicate(x)) { + return x; + } + } + return undefined; +} + +export function filter$00vfvog(self: [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined, predicate: (a0: [RangeStartWrapper.RangeStartWrapper, rs.u64]) => boolean): [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined { + if (self !== undefined) { + const x: [RangeStartWrapper.RangeStartWrapper, rs.u64] = self; + if (predicate(x)) { + return x; + } + } + return undefined; +} + +export function filter$16uxvkg(self: [RangeStartWrapper.RangeStartWrapper, undefined] | undefined, predicate: (a0: [RangeStartWrapper.RangeStartWrapper, undefined]) => boolean): [RangeStartWrapper.RangeStartWrapper, undefined] | undefined { + if (self !== undefined) { + const x: [RangeStartWrapper.RangeStartWrapper, undefined] = self; + if (predicate(x)) { + return x; + } + } + return undefined; +} + export function clone$1i3gmk3(self: rs.ByteSlice | undefined): rs.ByteSlice | undefined { if (self === undefined) { return undefined; diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index 26c0b58f6..373a4245f 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -4,6 +4,7 @@ import * as rs from "./rs.ts"; import { bytesMut, far, reclaims, reads, dyns, late, vecSpares, chunks, writes, edits, chains } from "./buf.ts"; import * as Owner from "./harness.Owner.ts"; import { map as maps_map, table, capacity, linked, linkedIters, nested, ownHasher, ownFromIter, equal, defaultHasher } from "./maps.ts"; +import { ranges } from "./ranges.ts"; /** * Each case's name and what it runs. The first byte picks one modulo their count, so a @@ -38,7 +39,7 @@ export function cases(): rs.Vec<[string, (a0: rs.ByteSlice, a1: rs.ByteVec) => u reclaims(a013.data, a013.start, a013.length, a113); }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::vec_spares", vecSpares as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::chunks", (a014: rs.ByteSlice, a114: rs.ByteVec): undefined => { chunks(a014.data, a014.start, a014.length, a114); - }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["ranges", ranges as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); } /** Run one case. */ diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_map.Gaps.ts b/ts/fixtures/stock/expected/rangemap/inclusive_map.Gaps.ts new file mode 100644 index 000000000..9de9c17cc --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_map.Gaps.ts @@ -0,0 +1,116 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as RangeInclusiveEndWrapper from "../rangemap/range_wrapper.RangeInclusiveEndWrapper.ts"; +import * as RangeInclusiveStartWrapper from "../rangemap/range_wrapper.RangeInclusiveStartWrapper.ts"; +import { addOne$rangemap_StepFns_u64_u64, subOne$rangemap_StepFns_u64_u64 } from "../rangemap/std_ext.ts"; + +/** + * An iterator over all ranges not covered by a `RangeInclusiveMap`. + * + * The iterator element type is `RangeInclusive`. + * + * This `struct` is created by the [`gaps`] method on [`RangeInclusiveMap`]. See its + * documentation for more. + * + * [`gaps`]: RangeInclusiveMap::gaps + */ +export interface Gaps { + candidateNeedsPlusOne: boolean; + candidateStart: rs.Ptr; + queryEnd: rs.Ptr; + btmRangeIter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>; + _phantom: undefined; +} + +export function next$iter_Iterator_u64_u32_u64(self: Gaps): rs.RangeInclusive | rs.Done { + let curCandidateStart2!: rs.u64; + const iter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]> = self.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]>; + while (true) { + const _6: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | rs.Done = iter.next(); + if (_6 === rs.DONE) { + break; + } + const overlap: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] = _6; + if (!rs.u64Lt(self.queryEnd as rs.u64, rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0]))))) { + const old = self.candidateNeedsPlusOne; + self.candidateNeedsPlusOne = true; + const candidateNeedsPlusOne: boolean = old; + const _19: rs.u64 = rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0]))); + const old2 = self.candidateStart as rs.u64; + (self.candidateStart as rs.u64) = _19; + const curCandidateStart: rs.u64 = old2; + if (!candidateNeedsPlusOne) { + curCandidateStart2 = curCandidateStart; + } else { + curCandidateStart2 = addOne$rangemap_StepFns_u64_u64(curCandidateStart); + } + if (rs.u64Lt(curCandidateStart2, rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0]))))) { + return new rs.RangeInclusive(curCandidateStart2, subOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0])))), rs.u64Step); + } + } else { + break; + } + } + const old3 = self.candidateNeedsPlusOne; + self.candidateNeedsPlusOne = true; + const candidateNeedsPlusOne2: boolean = old3; + const old4 = self.candidateStart as rs.u64; + (self.candidateStart as rs.u64) = self.queryEnd as rs.u64; + const curCandidateStart3: rs.u64 = old4; + if (!candidateNeedsPlusOne2) { + if (rs.u64Le(curCandidateStart3, self.queryEnd as rs.u64)) { + return new rs.RangeInclusive(curCandidateStart3, self.queryEnd as rs.u64, rs.u64Step); + } + } else if (rs.u64Lt(curCandidateStart3, self.queryEnd as rs.u64)) { + return new rs.RangeInclusive(addOne$rangemap_StepFns_u64_u64(curCandidateStart3), self.queryEnd as rs.u64, rs.u64Step); + } + return rs.DONE; +} + +export function next$iter_Iterator_u64_unit_u64(self: Gaps): rs.RangeInclusive | rs.Done { + let curCandidateStart2!: rs.u64; + const iter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]> = self.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]>; + while (true) { + const _6: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | rs.Done = iter.next(); + if (_6 === rs.DONE) { + break; + } + const overlap: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] = _6; + if (!rs.u64Lt(self.queryEnd as rs.u64, rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0]))))) { + const old = self.candidateNeedsPlusOne; + self.candidateNeedsPlusOne = true; + const candidateNeedsPlusOne: boolean = old; + const _19: rs.u64 = rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0]))); + const old2 = self.candidateStart as rs.u64; + (self.candidateStart as rs.u64) = _19; + const curCandidateStart: rs.u64 = old2; + if (!candidateNeedsPlusOne) { + curCandidateStart2 = curCandidateStart; + } else { + curCandidateStart2 = addOne$rangemap_StepFns_u64_u64(curCandidateStart); + } + if (rs.u64Lt(curCandidateStart2, rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0]))))) { + return new rs.RangeInclusive(curCandidateStart2, subOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(overlap[0])))), rs.u64Step); + } + } else { + break; + } + } + const old3 = self.candidateNeedsPlusOne; + self.candidateNeedsPlusOne = true; + const candidateNeedsPlusOne2: boolean = old3; + const old4 = self.candidateStart as rs.u64; + (self.candidateStart as rs.u64) = self.queryEnd as rs.u64; + const curCandidateStart3: rs.u64 = old4; + if (!candidateNeedsPlusOne2) { + if (rs.u64Le(curCandidateStart3, self.queryEnd as rs.u64)) { + return new rs.RangeInclusive(curCandidateStart3, self.queryEnd as rs.u64, rs.u64Step); + } + } else if (rs.u64Lt(curCandidateStart3, self.queryEnd as rs.u64)) { + return new rs.RangeInclusive(addOne$rangemap_StepFns_u64_u64(curCandidateStart3), self.queryEnd as rs.u64, rs.u64Step); + } + return rs.DONE; +} + +//# sourceMappingURL=inclusive_map.Gaps.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_map.IntoIter.ts b/ts/fixtures/stock/expected/rangemap/inclusive_map.IntoIter.ts new file mode 100644 index 000000000..142c7b2c4 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_map.IntoIter.ts @@ -0,0 +1,37 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$1uwf58c as option_map$1uwf58c } from "../core/option.ts"; +import type * as RangeInclusiveStartWrapper from "../rangemap/range_wrapper.RangeInclusiveStartWrapper.ts"; + +/** + * An owning iterator over the entries of a `RangeInclusiveMap`, ordered by key range. + * + * The iterator element type is `(RangeInclusive, V)`. + * + * This `struct` is created by the [`into_iter`] method on [`RangeInclusiveMap`] + * (provided by the `IntoIterator` trait). See its documentation for more. + * + * [`into_iter`]: IntoIterator::into_iter + */ +export interface IntoIter { + inner: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, V]>; +} + +export function next$iter_Iterator_u64_u32(self: IntoIter): [rs.RangeInclusive, rs.u32] | rs.Done { + return rs.iterFromOption(option_map$1uwf58c(rs.iterToOption(self.inner.next()), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [rs.RangeInclusive, rs.u32] => { + return [_22[0].endWrapper.range, _22[1]] as [rs.RangeInclusive, rs.u32]; + })); +} + +export function sizeHint$iter_Iterator_u64_u32(self: IntoIter): [rs.usize, rs.usize | undefined] { + return self.inner.sizeHint(); +} + +export function nextBack$iter_DoubleEndedIterator_u64_u32(self: IntoIter): [rs.RangeInclusive, rs.u32] | undefined { + return option_map$1uwf58c(rs.iterToOption(self.inner.nextBack()), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [rs.RangeInclusive, rs.u32] => { + return [_22[0].endWrapper.range, _22[1]] as [rs.RangeInclusive, rs.u32]; + }); +} + +//# sourceMappingURL=inclusive_map.IntoIter.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_map.Iter.ts b/ts/fixtures/stock/expected/rangemap/inclusive_map.Iter.ts new file mode 100644 index 000000000..e6a4b8846 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_map.Iter.ts @@ -0,0 +1,53 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$1uwf58c as option_map$1uwf58c, map$0q44qdt as option_map$0q44qdt } from "../core/option.ts"; +import * as RangeInclusiveStartWrapper from "../rangemap/range_wrapper.RangeInclusiveStartWrapper.ts"; + +/** + * An iterator over the entries of a `RangeInclusiveMap`, ordered by key range. + * + * The iterator element type is `(&'a RangeInclusive, &'a V)`. + * + * This `struct` is created by the [`iter`] method on [`RangeInclusiveMap`]. See its + * documentation for more. + * + * [`iter`]: RangeInclusiveMap::iter + */ +export interface Iter { + inner: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>; +} + +export function next$iter_Iterator_u64_u32(self: Iter): [rs.RangeInclusive, rs.u32] | rs.Done { + return rs.iterFromOption(option_map$1uwf58c(rs.iterToOption((self.inner as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]>).next()), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [rs.RangeInclusive, rs.u32] => { + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_22[0]).range, _22[1]] as [rs.RangeInclusive, rs.u32]; + })); +} + +export function next$iter_Iterator_u64_unit(self: Iter): [rs.RangeInclusive, undefined] | rs.Done { + return rs.iterFromOption(option_map$0q44qdt(rs.iterToOption((self.inner as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]>).next()), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): [rs.RangeInclusive, undefined] => { + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_22[0]).range, undefined] as [rs.RangeInclusive, undefined]; + })); +} + +export function sizeHint$iter_Iterator_u64_u32(self: Iter): [rs.usize, rs.usize | undefined] { + return (self.inner as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]>).sizeHint(); +} + +export function sizeHint$iter_Iterator_u64_unit(self: Iter): [rs.usize, rs.usize | undefined] { + return (self.inner as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]>).sizeHint(); +} + +export function nextBack$iter_DoubleEndedIterator_u64_u32(self: Iter): [rs.RangeInclusive, rs.u32] | undefined { + return option_map$1uwf58c(rs.iterToOption((self.inner as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]>).nextBack()), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [rs.RangeInclusive, rs.u32] => { + return [_22[0].endWrapper.range, _22[1]] as [rs.RangeInclusive, rs.u32]; + }); +} + +export function nextBack$iter_DoubleEndedIterator_u64_unit(self: Iter): [rs.RangeInclusive, undefined] | undefined { + return option_map$0q44qdt(rs.iterToOption((self.inner as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]>).nextBack()), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): [rs.RangeInclusive, undefined] => { + return [_22[0].endWrapper.range, undefined] as [rs.RangeInclusive, undefined]; + }); +} + +//# sourceMappingURL=inclusive_map.Iter.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_map.Overlapping.ts b/ts/fixtures/stock/expected/rangemap/inclusive_map.Overlapping.ts new file mode 100644 index 000000000..061e9cb35 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_map.Overlapping.ts @@ -0,0 +1,78 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as RangeInclusiveEndWrapper from "../rangemap/range_wrapper.RangeInclusiveEndWrapper.ts"; +import * as RangeInclusiveStartWrapper from "../rangemap/range_wrapper.RangeInclusiveStartWrapper.ts"; + +/** + * An iterator over all stored ranges partially or completely + * overlapped by a given range. + * + * The iterator element type is `(&'a RangeInclusive, &'a V)`. + * + * This `struct` is created by the [`overlapping`] method on [`RangeInclusiveMap`]. See its + * documentation for more. + * + * [`overlapping`]: RangeInclusiveMap::overlapping + */ +export class Overlapping { + queryRange: R; + btmRangeIter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>; + + constructor(queryRange: R, btmRangeIter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>) { + this.queryRange = queryRange; + this.btmRangeIter = btmRangeIter; + } +} + +export function next$iter_Iterator_u64_u32_ref_ops_RangeInclusive_u64(self: Overlapping>): [rs.RangeInclusive, rs.u32] | rs.Done { + const _2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | rs.Done = (self.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]>).next(); + if (_2 !== rs.DONE) { + if (!rs.u64Le(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]))), rs.rangeInclusiveEnd(self.queryRange))) { + return rs.DONE; + } + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]).range, _2[1]] as [rs.RangeInclusive, rs.u32]; + } + return rs.DONE; +} + +export function next$iter_Iterator_u64_unit_ops_RangeInclusive_u64(self: Overlapping>): [rs.RangeInclusive, undefined] | rs.Done { + const _2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | rs.Done = (self.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]>).next(); + if (_2 !== rs.DONE) { + if (!rs.u64Le(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]))), rs.rangeInclusiveEnd(self.queryRange))) { + return rs.DONE; + } + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]).range, undefined] as [rs.RangeInclusive, undefined]; + } + return rs.DONE; +} + +export function nextBack$iter_DoubleEndedIterator_u64_u32_ref_ops_RangeInclusive_u64(self: Overlapping>): [rs.RangeInclusive, rs.u32] | undefined { + while (true) { + const _2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined = rs.iterToOption((self.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]>).nextBack()); + if (_2 !== undefined) { + if (rs.u64Le(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]))), rs.rangeInclusiveEnd(self.queryRange))) { + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]).range, _2[1]] as [rs.RangeInclusive, rs.u32]; + } + } else { + break; + } + } + return undefined; +} + +export function nextBack$iter_DoubleEndedIterator_u64_unit_ops_RangeInclusive_u64(self: Overlapping>): [rs.RangeInclusive, undefined] | undefined { + while (true) { + const _2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined = rs.iterToOption((self.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]>).nextBack()); + if (_2 !== undefined) { + if (rs.u64Le(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]))), rs.rangeInclusiveEnd(self.queryRange))) { + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0]).range, undefined] as [rs.RangeInclusive, undefined]; + } + } else { + break; + } + } + return undefined; +} + +//# sourceMappingURL=inclusive_map.Overlapping.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_map.RangeInclusiveMap.ts b/ts/fixtures/stock/expected/rangemap/inclusive_map.RangeInclusiveMap.ts new file mode 100644 index 000000000..aec532c45 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_map.RangeInclusiveMap.ts @@ -0,0 +1,503 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { min$10dxkeu, max$10jofma } from "../core/cmp.ts"; +import { map$1uwf58c as option_map$1uwf58c, map$0j6jw4e as option_map$0j6jw4e, map$0uvwlsi as option_map$0uvwlsi, map$05vmvpg as option_map$05vmvpg, map$0q44qdt as option_map$0q44qdt, filter$1nfpslh, filter$0w6ybci } from "../core/option.ts"; +import type * as inclusive_map_Gaps from "../rangemap/inclusive_map.Gaps.ts"; +import type * as inclusive_map_IntoIter from "../rangemap/inclusive_map.IntoIter.ts"; +import type * as inclusive_map_Iter from "../rangemap/inclusive_map.Iter.ts"; +import * as inclusive_map_Overlapping from "../rangemap/inclusive_map.Overlapping.ts"; +import * as RangeInclusiveEndWrapper from "../rangemap/range_wrapper.RangeInclusiveEndWrapper.ts"; +import * as RangeInclusiveStartWrapper from "../rangemap/range_wrapper.RangeInclusiveStartWrapper.ts"; +import { overlaps$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64, touches$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64_u64, addOne$rangemap_StepFns_u64_u64, subOne$rangemap_StepFns_u64_u64 } from "../rangemap/std_ext.ts"; + +export function clone$Clone_u64_u32_u64(self: RangeInclusiveMap): RangeInclusiveMap { + const _2: rs.BTreeMap, rs.u32> = rs.btreeClone(self.btm, RangeInclusiveStartWrapper.clone$Clone_u64, undefined); + self._phantom; + return new RangeInclusiveMap(_2, undefined); +} + +/** + * A map whose keys are stored as ranges bounded + * inclusively below and above `(start..=end)`. + * + * Contiguous and overlapping ranges that map to the same value + * are coalesced into a single range. + * + * Successor and predecessor functions must be provided for + * the key type `K`, so that we can detect adjacent but non-overlapping + * (closed) ranges. (This is not a problem for half-open ranges, + * because adjacent ranges can be detected using equality of range ends alone.) + * + * You can provide these functions either by implementing the + * [`StepLite`] trait for your key type `K`, or, + * if this is impossible because of Rust's "orphan rules", + * you can provide equivalent free functions using the `StepFnsT` type parameter. + * [`StepLite`] is implemented for all standard integer types, + * but not for any third party crate types. + */ +export class RangeInclusiveMap { + btm: rs.BTreeMap, V>; + _phantom: undefined; + + constructor(btm: rs.BTreeMap, V>, _phantom: undefined) { + this.btm = btm; + this._phantom = _phantom; + } +} + +/** + * Gets an iterator over all pairs of key range and value, + * ordered by key range. + * + * The iterator element type is `(&'a RangeInclusive, &'a V)`. + */ +export function iter$u64_u32_u64(self: RangeInclusiveMap): inclusive_map_Iter.Iter { + return { inner: rs.btreeIter(self.btm) as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]> }; +} + +/** + * Gets an iterator over all pairs of key range and value, + * ordered by key range. + * + * The iterator element type is `(&'a RangeInclusive, &'a V)`. + */ +export function iter$u64_unit_u64(self: RangeInclusiveMap): inclusive_map_Iter.Iter { + return { inner: rs.btreeIter(self.btm) as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]> }; +} + +/** Makes a new empty `RangeInclusiveMap`. */ +export function new$u64_u32_u64(): RangeInclusiveMap { + return newWithStepFns$u64_u32_u64(); +} + +/** + * Makes a new empty `RangeInclusiveMap`, specifying successor and + * predecessor functions defined separately from `K` itself. + * + * This is useful as a workaround for Rust's "orphan rules", + * which prevent you from implementing `StepLite` for `K` if `K` + * is a foreign type. + * + * **NOTE:** This will likely be deprecated and then eventually + * removed once the standard library's [Step](core::iter::Step) + * trait is stabilised, as most crates will then likely implement [Step](core::iter::Step) + * for their types where appropriate. + * + * See [this issue](https://github.com/rust-lang/rust/issues/42168) + * for details about that stabilization process. + */ +export function newWithStepFns$u64_u32_u64(): RangeInclusiveMap { + return new RangeInclusiveMap(rs.btreeNew(RangeInclusiveStartWrapper.cmp$cmp_Ord_u64) as rs.BTreeMap, rs.u32>, undefined); +} + +/** + * Makes a new empty `RangeInclusiveMap`, specifying successor and + * predecessor functions defined separately from `K` itself. + * + * This is useful as a workaround for Rust's "orphan rules", + * which prevent you from implementing `StepLite` for `K` if `K` + * is a foreign type. + * + * **NOTE:** This will likely be deprecated and then eventually + * removed once the standard library's [Step](core::iter::Step) + * trait is stabilised, as most crates will then likely implement [Step](core::iter::Step) + * for their types where appropriate. + * + * See [this issue](https://github.com/rust-lang/rust/issues/42168) + * for details about that stabilization process. + */ +export function newWithStepFns$u64_unit_u64(): RangeInclusiveMap { + return new RangeInclusiveMap(rs.btreeNew(RangeInclusiveStartWrapper.cmp$cmp_Ord_u64) as rs.BTreeMap, undefined>, undefined); +} + +/** + * Returns a reference to the value corresponding to the given key, + * if the key is covered by any range in the map. + */ +export function get$u64_unit_u64(self: RangeInclusiveMap, key: rs.u64): undefined | rs.None { + return option_map$0j6jw4e(getKeyValue$u64_unit_u64(self, key), (_2: [rs.RangeInclusive, undefined]): undefined => { + return _2[1]; + }); +} + +/** + * Returns the range-value pair (as a pair of references) corresponding + * to the given key, if the key is covered by any range in the map. + */ +export function getKeyValue$u64_u32_u64(self: RangeInclusiveMap, key: rs.u64): [rs.RangeInclusive, rs.u32] | undefined { + const _12: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(key, key, rs.u64Step)) } as rs.RangeBound>]; + return option_map$1uwf58c(filter$1nfpslh(rs.iterToOption(rs.btreeRange(self.btm, _12, RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): boolean => { + return rs.rangeInclusiveContains(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0])), key); + }), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [rs.RangeInclusive, rs.u32] => { + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_22[0]).range, _22[1]] as [rs.RangeInclusive, rs.u32]; + }); +} + +/** + * Returns the range-value pair (as a pair of references) corresponding + * to the given key, if the key is covered by any range in the map. + */ +export function getKeyValue$u64_unit_u64(self: RangeInclusiveMap, key: rs.u64): [rs.RangeInclusive, undefined] | undefined { + const _12: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(key, key, rs.u64Step)) } as rs.RangeBound>]; + return option_map$0q44qdt(filter$0w6ybci(rs.iterToOption(rs.btreeRange(self.btm, _12, RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): boolean => { + return rs.rangeInclusiveContains(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0])), key); + }), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): [rs.RangeInclusive, undefined] => { + return [RangeInclusiveStartWrapper.deref$ops_Deref_u64(_22[0]).range, undefined] as [rs.RangeInclusive, undefined]; + }); +} + +/** Returns `true` if any range in the map covers the specified key. */ +export function containsKey$u64_unit_u64(self: RangeInclusiveMap, key: rs.u64): boolean { + return get$u64_unit_u64(self, key) !== rs.None; +} + +/** + * Insert a pair of key range and value into the map. + * + * If the inserted range partially or completely overlaps any + * existing range in the map, then the existing range (or ranges) will be + * partially or completely replaced by the inserted range. + * + * If the inserted range either overlaps or is immediately adjacent + * any existing range _mapping to the same value_, then the ranges + * will be coalesced into a single contiguous range. + * + * # Panics + * + * Panics if range `start > end`. + */ +export function insert$u64_u32_u64(self: RangeInclusiveMap, range: rs.RangeInclusive, value: rs.u32): void { + if (!rs.u64Le(rs.rangeInclusiveStart(range), rs.rangeInclusiveEnd(range))) { + rs.panic("Range start can not be after range end"); + } else { + const newRangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(range); + const newValue: rs.u32 = value; + const candidates: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]> = rs.iterFilter(rs.iterTake(rs.iterRev(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: newRangeStartWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64))), 2), (_2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): boolean => { + return touches$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64_u64(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0])), newRangeStartWrapper.endWrapper.range); + }); + const _27: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | rs.Done = candidates.next(); + if (_27 !== rs.DONE) { + let candidate: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] = _27; + const _31: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | rs.Done = candidates.next(); + if (_31 !== rs.DONE) { + candidate = _31; + } + const _37: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] = [RangeInclusiveStartWrapper.clone$Clone_u64(candidate[0]), candidate[1]]; + adjustTouchingRangesForInsert$u64_u32_u64(self, _37[0], _37[1], newRangeStartWrapper.endWrapper.range, newValue); + } + const secondLastPossibleStart: rs.u64 = rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(newRangeStartWrapper))); + const secondLastPossibleStart2: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(secondLastPossibleStart, secondLastPossibleStart, rs.u64Step)); + while (true) { + const _53: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | rs.Done = rs.btreeRange(self.btm, [{ tag: "Included", _0: newRangeStartWrapper } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).next(); + if (_53 !== rs.DONE) { + const storedStart: rs.u64 = rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_53[0]))); + b4: { + if (rs.u64Gt(storedStart, rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(secondLastPossibleStart2))))) { + const latestPossibleStart: rs.u64 = addOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(secondLastPossibleStart2)))); + b5: { + if (!rs.u64Gt(storedStart, latestPossibleStart)) { + if (rs.u64Eq(storedStart, latestPossibleStart)) { + if (_53[1] !== newValue) { + break b5; + } + } + break b4; + } + } + break; + } + } + adjustTouchingRangesForInsert$u64_u32_u64(self, RangeInclusiveStartWrapper.clone$Clone_u64(_53[0]), _53[1], newRangeStartWrapper.endWrapper.range, newValue); + } else { + break; + } + } + rs.btreeInsert(self.btm, newRangeStartWrapper, newValue); + } +} + +/** + * Insert a pair of key range and value into the map. + * + * If the inserted range partially or completely overlaps any + * existing range in the map, then the existing range (or ranges) will be + * partially or completely replaced by the inserted range. + * + * If the inserted range either overlaps or is immediately adjacent + * any existing range _mapping to the same value_, then the ranges + * will be coalesced into a single contiguous range. + * + * # Panics + * + * Panics if range `start > end`. + */ +export function insert$u64_unit_u64(self: RangeInclusiveMap, range: rs.RangeInclusive, _: undefined): void { + if (!rs.u64Le(rs.rangeInclusiveStart(range), rs.rangeInclusiveEnd(range))) { + rs.panic("Range start can not be after range end"); + } else { + const newRangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(range); + const candidates: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]> = rs.iterFilter(rs.iterTake(rs.iterRev(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: newRangeStartWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64))), 2), (_2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): boolean => { + return touches$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64_u64(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0])), newRangeStartWrapper.endWrapper.range); + }); + const _27: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | rs.Done = candidates.next(); + if (_27 !== rs.DONE) { + let candidate: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] = _27; + const _31: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | rs.Done = candidates.next(); + if (_31 !== rs.DONE) { + candidate = _31; + } + const _38: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.clone$Clone_u64(candidate[0]); + candidate[1]; + adjustTouchingRangesForInsert$u64_unit_u64(self, _38, undefined, newRangeStartWrapper.endWrapper.range, undefined); + } + const secondLastPossibleStart: rs.u64 = rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(newRangeStartWrapper))); + const secondLastPossibleStart2: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(secondLastPossibleStart, secondLastPossibleStart, rs.u64Step)); + while (true) { + const _53: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | rs.Done = rs.btreeRange(self.btm, [{ tag: "Included", _0: newRangeStartWrapper } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).next(); + if (_53 !== rs.DONE) { + const storedStart: rs.u64 = rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_53[0]))); + b4: { + if (rs.u64Gt(storedStart, rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(secondLastPossibleStart2))))) { + const latestPossibleStart: rs.u64 = addOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(secondLastPossibleStart2)))); + b5: { + if (!rs.u64Gt(storedStart, latestPossibleStart)) { + if (rs.u64Eq(storedStart, latestPossibleStart)) { + if (false) { + break b5; + } + } + break b4; + } + } + break; + } + } + const storedRangeStartWrapper2: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.clone$Clone_u64(_53[0]); + _53[1]; + adjustTouchingRangesForInsert$u64_unit_u64(self, storedRangeStartWrapper2, undefined, newRangeStartWrapper.endWrapper.range, undefined); + } else { + break; + } + } + rs.btreeInsert(self.btm, newRangeStartWrapper, undefined, undefined, rs.None); + } +} + +/** + * Removes a range from the map, if all or any of it was present. + * + * If the range to be removed _partially_ overlaps any ranges + * in the map, then those ranges will be contracted to no + * longer cover the removed range. + * + * + * # Panics + * + * Panics if range `start > end`. + */ +export function remove$u64_u32_u64(self: RangeInclusiveMap, range: rs.RangeInclusive): void { + if (!rs.u64Le(rs.rangeInclusiveStart(range), rs.rangeInclusiveEnd(range))) { + rs.panic("Range start can not be after range end"); + } else { + const rangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(range); + const range2: rs.RangeInclusive = RangeInclusiveStartWrapper.deref$ops_Deref_u64(rangeStartWrapper).range; + const _17: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined = option_map$0uvwlsi(filter$1nfpslh(rs.iterToOption(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rangeStartWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): boolean => { + return overlaps$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0])), range2); + }), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] => { + return [RangeInclusiveStartWrapper.clone$Clone_u64(_22[0]), _22[1]] as [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]; + }); + if (_17 !== undefined) { + adjustOverlappingRangesForRemove$u64_u32_u64(self, _17[0], _17[1], range2); + } + while (true) { + const newRangeEndAsStart: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveEnd(range2), rs.rangeInclusiveEnd(range2), rs.u64Step)); + const _44: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rangeStartWrapper } as rs.RangeBound>, { tag: "Included", _0: newRangeEndAsStart } as rs.RangeBound>]; + const _39: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] | undefined = option_map$0uvwlsi(rs.iterToOption(rs.btreeRange(self.btm, _44, RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).next()), (_26: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32] => { + return [RangeInclusiveStartWrapper.clone$Clone_u64(_26[0]), _26[1]] as [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]; + }); + if (_39 !== undefined) { + adjustOverlappingRangesForRemove$u64_u32_u64(self, _39[0], _39[1], range2); + } else { + break; + } + } + } +} + +/** + * Removes a range from the map, if all or any of it was present. + * + * If the range to be removed _partially_ overlaps any ranges + * in the map, then those ranges will be contracted to no + * longer cover the removed range. + * + * + * # Panics + * + * Panics if range `start > end`. + */ +export function remove$u64_unit_u64(self: RangeInclusiveMap, range: rs.RangeInclusive): void { + if (!rs.u64Le(rs.rangeInclusiveStart(range), rs.rangeInclusiveEnd(range))) { + rs.panic("Range start can not be after range end"); + } else { + const rangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(range); + const range2: rs.RangeInclusive = RangeInclusiveStartWrapper.deref$ops_Deref_u64(rangeStartWrapper).range; + const _17: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined = option_map$05vmvpg(filter$0w6ybci(rs.iterToOption(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rangeStartWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): boolean => { + return overlaps$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(_2[0])), range2); + }), (_22: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] => { + const _53: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.clone$Clone_u64(_22[0]); + _22[1]; + return [_53, undefined] as [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]; + }); + if (_17 !== undefined) { + adjustOverlappingRangesForRemove$u64_unit_u64(self, _17[0], undefined, range2); + } + while (true) { + const newRangeEndAsStart: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveEnd(range2), rs.rangeInclusiveEnd(range2), rs.u64Step)); + const _44: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rangeStartWrapper } as rs.RangeBound>, { tag: "Included", _0: newRangeEndAsStart } as rs.RangeBound>]; + const _39: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] | undefined = option_map$05vmvpg(rs.iterToOption(rs.btreeRange(self.btm, _44, RangeInclusiveStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveStartWrapper.partialCmp$cmp_PartialOrd_u64)).next()), (_26: [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]): [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined] => { + const _54: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.clone$Clone_u64(_26[0]); + _26[1]; + return [_54, undefined] as [RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]; + }); + if (_39 !== undefined) { + adjustOverlappingRangesForRemove$u64_unit_u64(self, _39[0], undefined, range2); + } else { + break; + } + } + } +} + +export function adjustTouchingRangesForInsert$u64_u32_u64(self: RangeInclusiveMap, storedRangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, storedValue: rs.u32, newRange: rs.RangeInclusive, newValue: rs.u32): void { + if (!(storedValue === newValue)) { + if (overlaps$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64(newRange, RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper).range)) { + rs.btreeRemove(self.btm, storedRangeStartWrapper); + if (rs.u64Lt(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), rs.rangeInclusiveStart(newRange))) { + const _48: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), subOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(newRange)), rs.u64Step)); + rs.btreeInsert(self.btm, _48, storedValue); + } + if (rs.u64Gt(rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), rs.rangeInclusiveEnd(newRange))) { + const _72: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(addOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveEnd(newRange)), rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), rs.u64Step)); + rs.btreeInsert(self.btm, _72, storedValue); + } + } + } else { + Object.assign(newRange, new rs.RangeInclusive(min$10dxkeu(rs.rangeInclusiveStart(newRange), rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper)))), max$10jofma(rs.rangeInclusiveEnd(newRange), rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper)))), rs.u64Step)); + rs.btreeRemove(self.btm, storedRangeStartWrapper); + } +} + +export function adjustTouchingRangesForInsert$u64_unit_u64(self: RangeInclusiveMap, storedRangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, _: undefined, newRange: rs.RangeInclusive, _newValue: undefined): void { + if (false) { + if (overlaps$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64(newRange, RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper).range)) { + rs.btreeRemove(self.btm, storedRangeStartWrapper, undefined, rs.None); + if (rs.u64Lt(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), rs.rangeInclusiveStart(newRange))) { + const _48: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), subOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(newRange)), rs.u64Step)); + rs.btreeInsert(self.btm, _48, undefined, undefined, rs.None); + } + if (rs.u64Gt(rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), rs.rangeInclusiveEnd(newRange))) { + const _72: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(addOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveEnd(newRange)), rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper))), rs.u64Step)); + rs.btreeInsert(self.btm, _72, undefined, undefined, rs.None); + } + } + } else { + Object.assign(newRange, new rs.RangeInclusive(min$10dxkeu(rs.rangeInclusiveStart(newRange), rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper)))), max$10jofma(rs.rangeInclusiveEnd(newRange), rs.rangeInclusiveEnd(RangeInclusiveEndWrapper.deref$ops_Deref_u64(RangeInclusiveStartWrapper.deref$ops_Deref_u64(storedRangeStartWrapper)))), rs.u64Step)); + rs.btreeRemove(self.btm, storedRangeStartWrapper, undefined, rs.None); + } +} + +export function adjustOverlappingRangesForRemove$u64_u32_u64(self: RangeInclusiveMap, storedRangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, storedValue: rs.u32, rangeToRemove: rs.RangeInclusive): void { + rs.btreeRemove(self.btm, storedRangeStartWrapper); + const storedRange: rs.RangeInclusive = storedRangeStartWrapper.endWrapper.range; + if (rs.u64Lt(rs.rangeInclusiveStart(storedRange), rs.rangeInclusiveStart(rangeToRemove))) { + const _18: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveStart(storedRange), subOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(rangeToRemove)), rs.u64Step)); + rs.btreeInsert(self.btm, _18, storedValue); + } + if (rs.u64Gt(rs.rangeInclusiveEnd(storedRange), rs.rangeInclusiveEnd(rangeToRemove))) { + const _36: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(addOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveEnd(rangeToRemove)), rs.rangeInclusiveEnd(storedRange), rs.u64Step)); + rs.btreeInsert(self.btm, _36, storedValue); + } +} + +export function adjustOverlappingRangesForRemove$u64_unit_u64(self: RangeInclusiveMap, storedRangeStartWrapper: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, _: undefined, rangeToRemove: rs.RangeInclusive): void { + rs.btreeRemove(self.btm, storedRangeStartWrapper, undefined, rs.None); + const storedRange: rs.RangeInclusive = storedRangeStartWrapper.endWrapper.range; + if (rs.u64Lt(rs.rangeInclusiveStart(storedRange), rs.rangeInclusiveStart(rangeToRemove))) { + const _18: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveStart(storedRange), subOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveStart(rangeToRemove)), rs.u64Step)); + rs.btreeInsert(self.btm, _18, undefined, undefined, rs.None); + } + if (rs.u64Gt(rs.rangeInclusiveEnd(storedRange), rs.rangeInclusiveEnd(rangeToRemove))) { + const _36: RangeInclusiveStartWrapper.RangeInclusiveStartWrapper = RangeInclusiveStartWrapper.new$u64(new rs.RangeInclusive(addOne$rangemap_StepFns_u64_u64(rs.rangeInclusiveEnd(rangeToRemove)), rs.rangeInclusiveEnd(storedRange), rs.u64Step)); + rs.btreeInsert(self.btm, _36, undefined, undefined, rs.None); + } +} + +/** + * Gets an iterator over all the maximally-sized ranges + * contained in `outer_range` that are not covered by + * any range stored in the map. + * + * The iterator element type is `RangeInclusive`. + */ +export function gaps$u64_u32_u64(self: RangeInclusiveMap, outerRange: rs.RangeInclusive): inclusive_map_Gaps.Gaps { + const overlapIter: inclusive_map_Overlapping.Overlapping> = overlapping$u64_u32_u64_ref_ops_RangeInclusive_u64(self, outerRange); + return { candidateNeedsPlusOne: false, candidateStart: rs.rangeInclusiveStart(outerRange), queryEnd: rs.rangeInclusiveEnd(outerRange), btmRangeIter: (overlapIter.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]>) as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>, _phantom: undefined }; +} + +/** + * Gets an iterator over all the maximally-sized ranges + * contained in `outer_range` that are not covered by + * any range stored in the map. + * + * The iterator element type is `RangeInclusive`. + */ +export function gaps$u64_unit_u64(self: RangeInclusiveMap, outerRange: rs.RangeInclusive): inclusive_map_Gaps.Gaps { + const overlapIter: inclusive_map_Overlapping.Overlapping> = overlapping$u64_unit_u64_ref_ops_RangeInclusive_u64(self, outerRange); + return { candidateNeedsPlusOne: false, candidateStart: rs.rangeInclusiveStart(outerRange), queryEnd: rs.rangeInclusiveEnd(outerRange), btmRangeIter: (overlapIter.btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]>) as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>, _phantom: undefined }; +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + */ +export function overlapping$u64_u32_u64_ref_ops_RangeInclusive_u64(self: RangeInclusiveMap, range: rs.RangeInclusive): inclusive_map_Overlapping.Overlapping> { + const _15: rs.RangeFrom> = new rs.RangeFrom(RangeInclusiveEndWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveStart(range), rs.rangeInclusiveStart(range), rs.u64Step))); + const btmRangeIter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.u32]> = rs.btreeRange(self.btm, rs.by(_15, RangeInclusiveEndWrapper.cmp$cmp_Ord_u64, RangeInclusiveStartWrapper.borrow$Borrow_rangemap_range_wrapper_RangeInclusiveEndWrapper_u64_u64), RangeInclusiveEndWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveEndWrapper.partialCmp$cmp_PartialOrd_u64)); + return new inclusive_map_Overlapping.Overlapping(range, btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>); +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + */ +export function overlapping$u64_unit_u64_ops_RangeInclusive_u64(self: RangeInclusiveMap, range: rs.RangeInclusive): inclusive_map_Overlapping.Overlapping> { + const _15: rs.RangeFrom> = new rs.RangeFrom(RangeInclusiveEndWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveStart(range), rs.rangeInclusiveStart(range), rs.u64Step))); + const btmRangeIter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]> = rs.btreeRange(self.btm, rs.by(_15, RangeInclusiveEndWrapper.cmp$cmp_Ord_u64, RangeInclusiveStartWrapper.borrow$Borrow_rangemap_range_wrapper_RangeInclusiveEndWrapper_u64_u64), RangeInclusiveEndWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveEndWrapper.partialCmp$cmp_PartialOrd_u64)); + return new inclusive_map_Overlapping.Overlapping(range, btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>); +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + */ +export function overlapping$u64_unit_u64_ref_ops_RangeInclusive_u64(self: RangeInclusiveMap, range: rs.RangeInclusive): inclusive_map_Overlapping.Overlapping> { + const _15: rs.RangeFrom> = new rs.RangeFrom(RangeInclusiveEndWrapper.new$u64(new rs.RangeInclusive(rs.rangeInclusiveStart(range), rs.rangeInclusiveStart(range), rs.u64Step))); + const btmRangeIter: rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, undefined]> = rs.btreeRange(self.btm, rs.by(_15, RangeInclusiveEndWrapper.cmp$cmp_Ord_u64, RangeInclusiveStartWrapper.borrow$Borrow_rangemap_range_wrapper_RangeInclusiveEndWrapper_u64_u64), RangeInclusiveEndWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeInclusiveEndWrapper.partialCmp$cmp_PartialOrd_u64)); + return new inclusive_map_Overlapping.Overlapping(range, btmRangeIter as rs.Iter<[RangeInclusiveStartWrapper.RangeInclusiveStartWrapper, rs.Ptr]>); +} + +/** + * Returns `true` if any range in the map completely or partially + * overlaps the given range. + */ +export function overlaps$u64_u32_u64(self: RangeInclusiveMap, range: rs.RangeInclusive): boolean { + return rs.iterToOption(inclusive_map_Overlapping.next$iter_Iterator_u64_u32_ref_ops_RangeInclusive_u64(overlapping$u64_u32_u64_ref_ops_RangeInclusive_u64(self, range))) !== undefined; +} + +export function intoIter$iter_IntoIterator_u64_u32_u64(self: RangeInclusiveMap): inclusive_map_IntoIter.IntoIter { + return { inner: rs.btreeIter(self.btm) }; +} + +//# sourceMappingURL=inclusive_map.RangeInclusiveMap.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_set.Gaps.ts b/ts/fixtures/stock/expected/rangemap/inclusive_set.Gaps.ts new file mode 100644 index 000000000..8d195d511 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_set.Gaps.ts @@ -0,0 +1,22 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as inclusive_map_Gaps from "../rangemap/inclusive_map.Gaps.ts"; + +/** + * An iterator over all ranges not covered by a `RangeInclusiveSet`. + * + * This `struct` is created by the [`gaps`] method on [`RangeInclusiveSet`]. See its + * documentation for more. + * + * [`gaps`]: RangeInclusiveSet::gaps + */ +export interface Gaps { + inner: inclusive_map_Gaps.Gaps; +} + +export function next$iter_Iterator_u64_u64(self: Gaps): rs.RangeInclusive | rs.Done { + return inclusive_map_Gaps.next$iter_Iterator_u64_unit_u64(self.inner); +} + +//# sourceMappingURL=inclusive_set.Gaps.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_set.Iter.ts b/ts/fixtures/stock/expected/rangemap/inclusive_set.Iter.ts new file mode 100644 index 000000000..d8a1addd1 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_set.Iter.ts @@ -0,0 +1,35 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$0xbjbpp as option_map$0xbjbpp } from "../core/option.ts"; +import * as inclusive_map_Iter from "../rangemap/inclusive_map.Iter.ts"; + +/** + * An iterator over the ranges of a `RangeInclusiveSet`. + * + * This `struct` is created by the [`iter`] method on [`RangeInclusiveSet`]. See its + * documentation for more. + * + * [`iter`]: RangeInclusiveSet::iter + */ +export interface Iter { + inner: inclusive_map_Iter.Iter; +} + +export function next$iter_Iterator_u64(self: Iter): rs.RangeInclusive | rs.Done { + return rs.iterFromOption(option_map$0xbjbpp(rs.iterToOption(inclusive_map_Iter.next$iter_Iterator_u64_unit(self.inner)), (_22: [rs.RangeInclusive, undefined]): rs.RangeInclusive => { + return _22[0]; + })); +} + +export function sizeHint$iter_Iterator_u64(self: Iter): [rs.usize, rs.usize | undefined] { + return inclusive_map_Iter.sizeHint$iter_Iterator_u64_unit(self.inner); +} + +export function nextBack$iter_DoubleEndedIterator_u64(self: Iter): rs.RangeInclusive | undefined { + return option_map$0xbjbpp(inclusive_map_Iter.nextBack$iter_DoubleEndedIterator_u64_unit(self.inner), (_22: [rs.RangeInclusive, undefined]): rs.RangeInclusive => { + return _22[0]; + }); +} + +//# sourceMappingURL=inclusive_set.Iter.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_set.Overlapping.ts b/ts/fixtures/stock/expected/rangemap/inclusive_set.Overlapping.ts new file mode 100644 index 000000000..8952012d7 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_set.Overlapping.ts @@ -0,0 +1,36 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$0xbjbpp as option_map$0xbjbpp } from "../core/option.ts"; +import * as inclusive_map_Overlapping from "../rangemap/inclusive_map.Overlapping.ts"; + +/** + * An iterator over all stored ranges partially or completely + * overlapped by a given range. + * + * This `struct` is created by the [`overlapping`] method on [`RangeInclusiveSet`]. See its + * documentation for more. + * + * [`overlapping`]: RangeInclusiveSet::overlapping + */ +export class Overlapping { + inner: inclusive_map_Overlapping.Overlapping; + + constructor(inner: inclusive_map_Overlapping.Overlapping) { + this.inner = inner; + } +} + +export function next$iter_Iterator_u64_ops_RangeInclusive_u64(self: Overlapping>): rs.RangeInclusive | rs.Done { + return rs.iterFromOption(option_map$0xbjbpp(rs.iterToOption(inclusive_map_Overlapping.next$iter_Iterator_u64_unit_ops_RangeInclusive_u64(self.inner)), (_22: [rs.RangeInclusive, undefined]): rs.RangeInclusive => { + return _22[0]; + })); +} + +export function nextBack$iter_DoubleEndedIterator_u64_ops_RangeInclusive_u64(self: Overlapping>): rs.RangeInclusive | undefined { + return option_map$0xbjbpp(inclusive_map_Overlapping.nextBack$iter_DoubleEndedIterator_u64_unit_ops_RangeInclusive_u64(self.inner), (_22: [rs.RangeInclusive, undefined]): rs.RangeInclusive => { + return _22[0]; + }); +} + +//# sourceMappingURL=inclusive_set.Overlapping.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/inclusive_set.RangeInclusiveSet.ts b/ts/fixtures/stock/expected/rangemap/inclusive_set.RangeInclusiveSet.ts new file mode 100644 index 000000000..4a579f276 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/inclusive_set.RangeInclusiveSet.ts @@ -0,0 +1,114 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as RangeInclusiveMap from "../rangemap/inclusive_map.RangeInclusiveMap.ts"; +import type * as inclusive_set_Gaps from "../rangemap/inclusive_set.Gaps.ts"; +import type * as inclusive_set_Iter from "../rangemap/inclusive_set.Iter.ts"; +import * as inclusive_set_Overlapping from "../rangemap/inclusive_set.Overlapping.ts"; + +/** + * A set whose items are stored as ranges bounded + * inclusively below and above `(start..=end)`. + * + * See [`RangeInclusiveMap`]'s documentation for more details. + * + * [`RangeInclusiveMap`]: crate::RangeInclusiveMap + */ +export class RangeInclusiveSet { + rm: RangeInclusiveMap.RangeInclusiveMap; + + constructor(rm: RangeInclusiveMap.RangeInclusiveMap) { + this.rm = rm; + } +} + +/** Makes a new empty `RangeInclusiveSet`. */ +export function new$u64_u64(): RangeInclusiveSet { + return newWithStepFns$u64_u64(); +} + +/** + * Makes a new empty `RangeInclusiveSet`, specifying successor and + * predecessor functions defined separately from `T` itself. + * + * This is useful as a workaround for Rust's "orphan rules", + * which prevent you from implementing `StepLite` for `T` if `T` + * is a foreign type. + * + * **NOTE:** This will likely be deprecated and then eventually + * removed once the standard library's [Step](core::iter::Step) + * trait is stabilised, as most crates will then likely implement [Step](core::iter::Step) + * for their types where appropriate. + * + * See [this issue](https://github.com/rust-lang/rust/issues/42168) + * for details about that stabilization process. + */ +export function newWithStepFns$u64_u64(): RangeInclusiveSet { + return new RangeInclusiveSet(RangeInclusiveMap.newWithStepFns$u64_unit_u64()); +} + +/** Returns `true` if any range in the set covers the specified value. */ +export function contains$u64_u64(self: RangeInclusiveSet, value: rs.u64): boolean { + return RangeInclusiveMap.containsKey$u64_unit_u64(self.rm, value); +} + +/** + * Gets an ordered iterator over all ranges, + * ordered by range. + */ +export function iter$u64_u64(self: RangeInclusiveSet): inclusive_set_Iter.Iter { + return { inner: RangeInclusiveMap.iter$u64_unit_u64(self.rm) }; +} + +/** + * Insert a range into the set. + * + * If the inserted range either overlaps or is immediately adjacent + * any existing range, then the ranges will be coalesced into + * a single contiguous range. + * + * # Panics + * + * Panics if range `start > end`. + */ +export function insert$u64_u64(self: RangeInclusiveSet, range: rs.RangeInclusive): void { + RangeInclusiveMap.insert$u64_unit_u64(self.rm, range, undefined); +} + +/** + * Removes a range from the set, if all or any of it was present. + * + * If the range to be removed _partially_ overlaps any ranges + * in the set, then those ranges will be contracted to no + * longer cover the removed range. + * + * # Panics + * + * Panics if range `start > end`. + */ +export function remove$u64_u64(self: RangeInclusiveSet, range: rs.RangeInclusive): void { + RangeInclusiveMap.remove$u64_unit_u64(self.rm, range); +} + +/** + * Gets an iterator over all the maximally-sized ranges + * contained in `outer_range` that are not covered by + * any range stored in the set. + * + * The iterator element type is `RangeInclusive`. + */ +export function gaps$u64_u64(self: RangeInclusiveSet, outerRange: rs.RangeInclusive): inclusive_set_Gaps.Gaps { + return { inner: RangeInclusiveMap.gaps$u64_unit_u64(self.rm, outerRange) }; +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + * + * The iterator element type is `RangeInclusive`. + */ +export function overlapping$u64_u64_ops_RangeInclusive_u64(self: RangeInclusiveSet, range: rs.RangeInclusive): inclusive_set_Overlapping.Overlapping> { + return new inclusive_set_Overlapping.Overlapping(RangeInclusiveMap.overlapping$u64_unit_u64_ops_RangeInclusive_u64(self.rm, range)); +} + +//# sourceMappingURL=inclusive_set.RangeInclusiveSet.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/map.Gaps.ts b/ts/fixtures/stock/expected/rangemap/map.Gaps.ts new file mode 100644 index 000000000..447f6b93e --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/map.Gaps.ts @@ -0,0 +1,81 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import type * as RangeEndWrapper from "../rangemap/range_wrapper.RangeEndWrapper.ts"; +import * as RangeStartWrapper from "../rangemap/range_wrapper.RangeStartWrapper.ts"; + +/** + * An iterator over all ranges not covered by a `RangeMap`. + * + * The iterator element type is `Range`. + * + * This `struct` is created by the [`gaps`] method on [`RangeMap`]. See its + * documentation for more. + * + * [`gaps`]: RangeMap::gaps + */ +export interface Gaps { + candidateStart: rs.Ptr; + queryEnd: rs.Ptr; + btmRangeIter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]>; +} + +export function next$iter_Iterator_u64_u64(self: Gaps): rs.Range | rs.Done { + const iter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]> = self.btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]>; + while (true) { + const _6: [RangeStartWrapper.RangeStartWrapper, rs.u64] | rs.Done = iter.next(); + if (_6 === rs.DONE) { + break; + } + const _11: RangeEndWrapper.RangeEndWrapper = RangeStartWrapper.deref$ops_Deref_u64(_6[0]); + if (!rs.u64Le(self.queryEnd as rs.u64, _11.range.start)) { + const old = self.candidateStart as rs.u64; + (self.candidateStart as rs.u64) = _11.range.end; + const originalStart: rs.u64 = old; + if (!rs.u64Lt(originalStart, _11.range.start)) { + (self.candidateStart as rs.u64) = _11.range.end; + } else { + return new rs.Range(originalStart, _11.range.start, rs.u64Step); + } + } else { + break; + } + } + if (!rs.u64Lt(self.candidateStart as rs.u64, self.queryEnd as rs.u64)) { + return rs.DONE; + } + const gap2: rs.Range = new rs.Range(self.candidateStart as rs.u64, self.queryEnd as rs.u64, rs.u64Step); + (self.candidateStart as rs.u64) = self.queryEnd as rs.u64; + return gap2; +} + +export function next$iter_Iterator_u64_unit(self: Gaps): rs.Range | rs.Done { + const iter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]> = self.btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]>; + while (true) { + const _6: [RangeStartWrapper.RangeStartWrapper, undefined] | rs.Done = iter.next(); + if (_6 === rs.DONE) { + break; + } + const _11: RangeEndWrapper.RangeEndWrapper = RangeStartWrapper.deref$ops_Deref_u64(_6[0]); + if (!rs.u64Le(self.queryEnd as rs.u64, _11.range.start)) { + const old = self.candidateStart as rs.u64; + (self.candidateStart as rs.u64) = _11.range.end; + const originalStart: rs.u64 = old; + if (!rs.u64Lt(originalStart, _11.range.start)) { + (self.candidateStart as rs.u64) = _11.range.end; + } else { + return new rs.Range(originalStart, _11.range.start, rs.u64Step); + } + } else { + break; + } + } + if (!rs.u64Lt(self.candidateStart as rs.u64, self.queryEnd as rs.u64)) { + return rs.DONE; + } + const gap2: rs.Range = new rs.Range(self.candidateStart as rs.u64, self.queryEnd as rs.u64, rs.u64Step); + (self.candidateStart as rs.u64) = self.queryEnd as rs.u64; + return gap2; +} + +//# sourceMappingURL=map.Gaps.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/map.IntoIter.ts b/ts/fixtures/stock/expected/rangemap/map.IntoIter.ts new file mode 100644 index 000000000..bd40098b1 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/map.IntoIter.ts @@ -0,0 +1,37 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$13fvwc4 as option_map$13fvwc4 } from "../core/option.ts"; +import type * as RangeStartWrapper from "../rangemap/range_wrapper.RangeStartWrapper.ts"; + +/** + * An owning iterator over the entries of a `RangeMap`, ordered by key range. + * + * The iterator element type is `(Range, V)`. + * + * This `struct` is created by the [`into_iter`] method on [`RangeMap`] + * (provided by the `IntoIterator` trait). See its documentation for more. + * + * [`into_iter`]: IntoIterator::into_iter + */ +export interface IntoIter { + inner: rs.Iter<[RangeStartWrapper.RangeStartWrapper, V]>; +} + +export function next$iter_Iterator_u64_unit(self: IntoIter): [rs.Range, undefined] | rs.Done { + return rs.iterFromOption(option_map$13fvwc4(rs.iterToOption(self.inner.next()), (_22: [RangeStartWrapper.RangeStartWrapper, undefined]): [rs.Range, undefined] => { + return [_22[0].endWrapper.range, undefined] as [rs.Range, undefined]; + })); +} + +export function sizeHint$iter_Iterator_u64_unit(self: IntoIter): [rs.usize, rs.usize | undefined] { + return self.inner.sizeHint(); +} + +export function nextBack$iter_DoubleEndedIterator_u64_unit(self: IntoIter): [rs.Range, undefined] | undefined { + return option_map$13fvwc4(rs.iterToOption(self.inner.nextBack()), (_22: [RangeStartWrapper.RangeStartWrapper, undefined]): [rs.Range, undefined] => { + return [_22[0].endWrapper.range, undefined] as [rs.Range, undefined]; + }); +} + +//# sourceMappingURL=map.IntoIter.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/map.Iter.ts b/ts/fixtures/stock/expected/rangemap/map.Iter.ts new file mode 100644 index 000000000..7b7b6b9da --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/map.Iter.ts @@ -0,0 +1,53 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$13fvwc4 as option_map$13fvwc4, map$15xkbmr as option_map$15xkbmr } from "../core/option.ts"; +import type * as RangeStartWrapper from "../rangemap/range_wrapper.RangeStartWrapper.ts"; + +/** + * An iterator over the entries of a `RangeMap`, ordered by key range. + * + * The iterator element type is `(&'a Range, &'a V)`. + * + * This `struct` is created by the [`iter`] method on [`RangeMap`]. See its + * documentation for more. + * + * [`iter`]: RangeMap::iter + */ +export interface Iter { + inner: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]>; +} + +export function next$iter_Iterator_u64_u64(self: Iter): [rs.Range, rs.u64] | rs.Done { + return rs.iterFromOption(option_map$15xkbmr(rs.iterToOption((self.inner as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]>).next()), (_22: [RangeStartWrapper.RangeStartWrapper, rs.u64]): [rs.Range, rs.u64] => { + return [_22[0].endWrapper.range, _22[1]] as [rs.Range, rs.u64]; + })); +} + +export function next$iter_Iterator_u64_unit(self: Iter): [rs.Range, undefined] | rs.Done { + return rs.iterFromOption(option_map$13fvwc4(rs.iterToOption((self.inner as rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]>).next()), (_22: [RangeStartWrapper.RangeStartWrapper, undefined]): [rs.Range, undefined] => { + return [_22[0].endWrapper.range, undefined] as [rs.Range, undefined]; + })); +} + +export function sizeHint$iter_Iterator_u64_u64(self: Iter): [rs.usize, rs.usize | undefined] { + return (self.inner as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]>).sizeHint(); +} + +export function sizeHint$iter_Iterator_u64_unit(self: Iter): [rs.usize, rs.usize | undefined] { + return (self.inner as rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]>).sizeHint(); +} + +export function nextBack$iter_DoubleEndedIterator_u64_u64(self: Iter): [rs.Range, rs.u64] | undefined { + return option_map$15xkbmr(rs.iterToOption((self.inner as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]>).nextBack()), (_22: [RangeStartWrapper.RangeStartWrapper, rs.u64]): [rs.Range, rs.u64] => { + return [_22[0].endWrapper.range, _22[1]] as [rs.Range, rs.u64]; + }); +} + +export function nextBack$iter_DoubleEndedIterator_u64_unit(self: Iter): [rs.Range, undefined] | undefined { + return option_map$13fvwc4(rs.iterToOption((self.inner as rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]>).nextBack()), (_22: [RangeStartWrapper.RangeStartWrapper, undefined]): [rs.Range, undefined] => { + return [_22[0].endWrapper.range, undefined] as [rs.Range, undefined]; + }); +} + +//# sourceMappingURL=map.Iter.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/map.Overlapping.ts b/ts/fixtures/stock/expected/rangemap/map.Overlapping.ts new file mode 100644 index 000000000..05a4f609a --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/map.Overlapping.ts @@ -0,0 +1,78 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as RangeEndWrapper from "../rangemap/range_wrapper.RangeEndWrapper.ts"; +import * as RangeStartWrapper from "../rangemap/range_wrapper.RangeStartWrapper.ts"; + +/** + * An iterator over all stored ranges partially or completely + * overlapped by a given range. + * + * The iterator element type is `(&'a Range, &'a V)`. + * + * This `struct` is created by the [`overlapping`] method on [`RangeMap`]. See its + * documentation for more. + * + * [`overlapping`]: RangeMap::overlapping + */ +export class Overlapping { + queryRange: R; + btmRangeIter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]>; + + constructor(queryRange: R, btmRangeIter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]>) { + this.queryRange = queryRange; + this.btmRangeIter = btmRangeIter; + } +} + +export function next$iter_Iterator_u64_u64_ops_Range_u64(self: Overlapping>): [rs.Range, rs.u64] | rs.Done { + const _2: [RangeStartWrapper.RangeStartWrapper, rs.u64] | rs.Done = (self.btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]>).next(); + if (_2 !== rs.DONE) { + if (!rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(_2[0])).start, self.queryRange.end)) { + return rs.DONE; + } + return [RangeStartWrapper.deref$ops_Deref_u64(_2[0]).range, _2[1]] as [rs.Range, rs.u64]; + } + return rs.DONE; +} + +export function next$iter_Iterator_u64_unit_ref_ops_Range_u64(self: Overlapping>): [rs.Range, undefined] | rs.Done { + const _2: [RangeStartWrapper.RangeStartWrapper, undefined] | rs.Done = (self.btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]>).next(); + if (_2 !== rs.DONE) { + if (!rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(_2[0])).start, self.queryRange.end)) { + return rs.DONE; + } + return [RangeStartWrapper.deref$ops_Deref_u64(_2[0]).range, undefined] as [rs.Range, undefined]; + } + return rs.DONE; +} + +export function nextBack$iter_DoubleEndedIterator_u64_u64_ops_Range_u64(self: Overlapping>): [rs.Range, rs.u64] | undefined { + while (true) { + const _2: [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined = rs.iterToOption((self.btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]>).nextBack()); + if (_2 !== undefined) { + if (rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(_2[0])).start, self.queryRange.end)) { + return [RangeStartWrapper.deref$ops_Deref_u64(_2[0]).range, _2[1]] as [rs.Range, rs.u64]; + } + } else { + break; + } + } + return undefined; +} + +export function nextBack$iter_DoubleEndedIterator_u64_unit_ref_ops_Range_u64(self: Overlapping>): [rs.Range, undefined] | undefined { + while (true) { + const _2: [RangeStartWrapper.RangeStartWrapper, undefined] | undefined = rs.iterToOption((self.btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]>).nextBack()); + if (_2 !== undefined) { + if (rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(_2[0])).start, self.queryRange.end)) { + return [RangeStartWrapper.deref$ops_Deref_u64(_2[0]).range, undefined] as [rs.Range, undefined]; + } + } else { + break; + } + } + return undefined; +} + +//# sourceMappingURL=map.Overlapping.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/map.RangeMap.ts b/ts/fixtures/stock/expected/rangemap/map.RangeMap.ts new file mode 100644 index 000000000..a6b74292c --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/map.RangeMap.ts @@ -0,0 +1,479 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { min$10dxkeu, max$10jofma } from "../core/cmp.ts"; +import { map$13fvwc4 as option_map$13fvwc4, map$0wqo9kn as option_map$0wqo9kn, map$1yav3xg as option_map$1yav3xg, map$02ffuo4 as option_map$02ffuo4, map$15xkbmr as option_map$15xkbmr, map$105h877 as option_map$105h877, filter$00vfvog, filter$16uxvkg } from "../core/option.ts"; +import type * as map_Gaps from "../rangemap/map.Gaps.ts"; +import type * as map_IntoIter from "../rangemap/map.IntoIter.ts"; +import type * as map_Iter from "../rangemap/map.Iter.ts"; +import * as map_Overlapping from "../rangemap/map.Overlapping.ts"; +import * as RangeEndWrapper from "../rangemap/range_wrapper.RangeEndWrapper.ts"; +import * as RangeStartWrapper from "../rangemap/range_wrapper.RangeStartWrapper.ts"; +import { overlaps$rangemap_std_ext_RangeExt_u64_ops_Range_u64, touches$rangemap_std_ext_RangeExt_u64_ops_Range_u64 } from "../rangemap/std_ext.ts"; + +export function clone$Clone_u64_unit(self: RangeMap): RangeMap { + return new RangeMap(rs.btreeClone(self.btm, RangeStartWrapper.clone$Clone_u64, undefined)); +} + +/** + * A map whose keys are stored as (half-open) ranges bounded + * inclusively below and exclusively above `(start..end)`. + * + * Contiguous and overlapping ranges that map to the same value + * are coalesced into a single range. + */ +export class RangeMap { + btm: rs.BTreeMap, V>; + + constructor(btm: rs.BTreeMap, V>) { + this.btm = btm; + } +} + +/** Makes a new empty `RangeMap`. */ +export function new$u64_u64(): RangeMap { + return new RangeMap(rs.btreeNew(RangeStartWrapper.cmp$cmp_Ord_u64) as rs.BTreeMap, rs.u64>); +} + +/** Makes a new empty `RangeMap`. */ +export function new$u64_unit(): RangeMap { + return new RangeMap(rs.btreeNew(RangeStartWrapper.cmp$cmp_Ord_u64) as rs.BTreeMap, undefined>); +} + +/** + * Gets an iterator over all pairs of key range and value, + * ordered by key range. + * + * The iterator element type is `(&'a Range, &'a V)`. + */ +export function iter$u64_u64(self: RangeMap): map_Iter.Iter { + return { inner: rs.btreeIter(self.btm) as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]> }; +} + +/** + * Gets an iterator over all pairs of key range and value, + * ordered by key range. + * + * The iterator element type is `(&'a Range, &'a V)`. + */ +export function iter$u64_unit(self: RangeMap): map_Iter.Iter { + return { inner: rs.btreeIter(self.btm) as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]> }; +} + +/** Returns the number of elements in the map. */ +export function len$u64_u64(self: RangeMap): rs.usize { + return rs.btreeLen(self.btm); +} + +/** Returns the number of elements in the map. */ +export function len$u64_unit(self: RangeMap): rs.usize { + return rs.btreeLen(self.btm); +} + +/** Returns true if the map contains no elements. */ +export function isEmpty$u64_unit(self: RangeMap): boolean { + return rs.btreeLen(self.btm) === 0; +} + +/** + * Returns a reference to the value corresponding to the given key, + * if the key is covered by any range in the map. + */ +export function get$u64_u64(self: RangeMap, key: rs.u64): rs.u64 | undefined { + return option_map$0wqo9kn(getKeyValue$u64_u64(self, key), (_2: [rs.Range, rs.u64]): rs.u64 => { + return _2[1]; + }); +} + +/** + * Returns a reference to the value corresponding to the given key, + * if the key is covered by any range in the map. + */ +export function get$u64_unit(self: RangeMap, key: rs.u64): undefined | rs.None { + return option_map$1yav3xg(getKeyValue$u64_unit(self, key), (_2: [rs.Range, undefined]): undefined => { + return _2[1]; + }); +} + +/** + * Returns the range-value pair (as a pair of references) corresponding + * to the given key, if the key is covered by any range in the map. + */ +export function getKeyValue$u64_u64(self: RangeMap, key: rs.u64): [rs.Range, rs.u64] | undefined { + const _12: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: RangeStartWrapper.new$u64(new rs.Range(key, key, rs.u64Step)) } as rs.RangeBound>]; + return option_map$15xkbmr(filter$00vfvog(rs.iterToOption(rs.btreeRange(self.btm, _12, RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeStartWrapper.RangeStartWrapper, rs.u64]): boolean => { + return rs.rangeContains(_2[0].endWrapper.range, key); + }), (_22: [RangeStartWrapper.RangeStartWrapper, rs.u64]): [rs.Range, rs.u64] => { + return [_22[0].endWrapper.range, _22[1]] as [rs.Range, rs.u64]; + }); +} + +/** + * Returns the range-value pair (as a pair of references) corresponding + * to the given key, if the key is covered by any range in the map. + */ +export function getKeyValue$u64_unit(self: RangeMap, key: rs.u64): [rs.Range, undefined] | undefined { + const _12: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: RangeStartWrapper.new$u64(new rs.Range(key, key, rs.u64Step)) } as rs.RangeBound>]; + return option_map$13fvwc4(filter$16uxvkg(rs.iterToOption(rs.btreeRange(self.btm, _12, RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeStartWrapper.RangeStartWrapper, undefined]): boolean => { + return rs.rangeContains(_2[0].endWrapper.range, key); + }), (_22: [RangeStartWrapper.RangeStartWrapper, undefined]): [rs.Range, undefined] => { + return [_22[0].endWrapper.range, undefined] as [rs.Range, undefined]; + }); +} + +/** Returns `true` if any range in the map covers the specified key. */ +export function containsKey$u64_unit(self: RangeMap, key: rs.u64): boolean { + return get$u64_unit(self, key) !== rs.None; +} + +/** + * Gets an iterator over all the maximally-sized ranges + * contained in `outer_range` that are not covered by + * any range stored in the map. + * + * If the start and end of the outer range are the same + * and it does not overlap any stored range, then a single + * empty gap will be returned. + * + * The iterator element type is `Range`. + */ +export function gaps$u64_u64(self: RangeMap, outerRange: rs.Range): map_Gaps.Gaps { + const _6: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]> = overlapping$u64_u64_ref_ops_Range_u64(self, outerRange).btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]>; + return { candidateStart: outerRange.start, queryEnd: outerRange.end, btmRangeIter: _6 as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]> }; +} + +/** + * Gets an iterator over all the maximally-sized ranges + * contained in `outer_range` that are not covered by + * any range stored in the map. + * + * If the start and end of the outer range are the same + * and it does not overlap any stored range, then a single + * empty gap will be returned. + * + * The iterator element type is `Range`. + */ +export function gaps$u64_unit(self: RangeMap, outerRange: rs.Range): map_Gaps.Gaps { + const _6: rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]> = overlapping$u64_unit_ref_ops_Range_u64(self, outerRange).btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]>; + return { candidateStart: outerRange.start, queryEnd: outerRange.end, btmRangeIter: _6 as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]> }; +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + */ +export function overlapping$u64_u64_ops_Range_u64(self: RangeMap, range: rs.Range): map_Overlapping.Overlapping> { + const _15: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: RangeEndWrapper.new$u64(new rs.Range(range.start, range.start, rs.u64Step)) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; + const btmRangeIter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]> = rs.btreeRange(self.btm, rs.by(_15, RangeEndWrapper.cmp$cmp_Ord_u64, RangeStartWrapper.borrow$Borrow_rangemap_range_wrapper_RangeEndWrapper_u64_u64), RangeEndWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeEndWrapper.partialCmp$cmp_PartialOrd_u64)); + return new map_Overlapping.Overlapping(range, btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]>); +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + */ +export function overlapping$u64_u64_ref_ops_Range_u64(self: RangeMap, range: rs.Range): map_Overlapping.Overlapping> { + const _15: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: RangeEndWrapper.new$u64(new rs.Range(range.start, range.start, rs.u64Step)) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; + const btmRangeIter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]> = rs.btreeRange(self.btm, rs.by(_15, RangeEndWrapper.cmp$cmp_Ord_u64, RangeStartWrapper.borrow$Borrow_rangemap_range_wrapper_RangeEndWrapper_u64_u64), RangeEndWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeEndWrapper.partialCmp$cmp_PartialOrd_u64)); + return new map_Overlapping.Overlapping(range, btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]>); +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + */ +export function overlapping$u64_unit_ref_ops_Range_u64(self: RangeMap, range: rs.Range): map_Overlapping.Overlapping> { + const _15: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: RangeEndWrapper.new$u64(new rs.Range(range.start, range.start, rs.u64Step)) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; + const btmRangeIter: rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]> = rs.btreeRange(self.btm, rs.by(_15, RangeEndWrapper.cmp$cmp_Ord_u64, RangeStartWrapper.borrow$Borrow_rangemap_range_wrapper_RangeEndWrapper_u64_u64), RangeEndWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeEndWrapper.partialCmp$cmp_PartialOrd_u64)); + return new map_Overlapping.Overlapping(range, btmRangeIter as rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.Ptr]>); +} + +/** + * Returns the first range-value pair in this map, if one exists. The range in this pair is the + * minimum range in the map. + */ +export function firstRangeValue$u64_unit(self: RangeMap): [rs.Range, undefined] | undefined { + return option_map$13fvwc4(rs.btreeFirst(self.btm), (_22: [RangeStartWrapper.RangeStartWrapper, undefined]): [rs.Range, undefined] => { + return [_22[0].endWrapper.range, undefined] as [rs.Range, undefined]; + }); +} + +/** + * Returns the last range-value pair in this map, if one exists. The range in this pair is the + * maximum range in the map. + */ +export function lastRangeValue$u64_u64(self: RangeMap): [rs.Range, rs.u64] | undefined { + return option_map$15xkbmr(rs.btreeFirst(self.btm, true), (_22: [RangeStartWrapper.RangeStartWrapper, rs.u64]): [rs.Range, rs.u64] => { + return [_22[0].endWrapper.range, _22[1]] as [rs.Range, rs.u64]; + }); +} + +/** + * Insert a pair of key range and value into the map. + * + * If the inserted range partially or completely overlaps any + * existing range in the map, then the existing range (or ranges) will be + * partially or completely replaced by the inserted range. + * + * If the inserted range either overlaps or is immediately adjacent + * any existing range _mapping to the same value_, then the ranges + * will be coalesced into a single contiguous range. + * + * # Panics + * + * Panics if range `start >= end`. + */ +export function insert$u64_u64(self: RangeMap, range: rs.Range, value: rs.u64): void { + if (!rs.u64Lt(range.start, range.end)) { + rs.panic("assertion failed: range.start < range.end"); + } else { + const newStartWrapper: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(range); + const newValue: rs.u64 = value; + const candidates: rs.Iter<[RangeStartWrapper.RangeStartWrapper, rs.u64]> = rs.iterFilter(rs.iterTake(rs.iterRev(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: newStartWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64))), 2), (_2: [RangeStartWrapper.RangeStartWrapper, rs.u64]): boolean => { + return touches$rangemap_std_ext_RangeExt_u64_ops_Range_u64(_2[0].endWrapper.range, newStartWrapper.endWrapper.range); + }); + const _22: [RangeStartWrapper.RangeStartWrapper, rs.u64] | rs.Done = candidates.next(); + if (_22 !== rs.DONE) { + let candidate: [RangeStartWrapper.RangeStartWrapper, rs.u64] = _22; + const _26: [RangeStartWrapper.RangeStartWrapper, rs.u64] | rs.Done = candidates.next(); + if (_26 !== rs.DONE) { + candidate = _26; + } + const _32: [RangeStartWrapper.RangeStartWrapper, rs.u64] = [RangeStartWrapper.clone$Clone_u64(candidate[0]), candidate[1]]; + adjustTouchingRangesForInsert$u64_u64(self, _32[0], _32[1], newStartWrapper.endWrapper.range, newValue); + } + while (true) { + const newRangeEndAsStart: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(newStartWrapper.endWrapper.range.end, newStartWrapper.endWrapper.range.end, rs.u64Step)); + const _48: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Included", _0: newStartWrapper } as rs.RangeBound>, { tag: "Included", _0: newRangeEndAsStart } as rs.RangeBound>]; + const _44: [RangeStartWrapper.RangeStartWrapper, rs.u64] | rs.Done = rs.btreeRange(self.btm, _48, RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).next(); + if (_44 !== rs.DONE) { + if (rs.u64Eq(_44[0].endWrapper.range.start, newStartWrapper.endWrapper.range.end)) { + if (rs.u64Ne(_44[1], newValue)) { + break; + } + } + adjustTouchingRangesForInsert$u64_u64(self, RangeStartWrapper.clone$Clone_u64(_44[0]), _44[1], newStartWrapper.endWrapper.range, newValue); + } else { + break; + } + } + rs.btreeInsert(self.btm, newStartWrapper, newValue); + } +} + +/** + * Insert a pair of key range and value into the map. + * + * If the inserted range partially or completely overlaps any + * existing range in the map, then the existing range (or ranges) will be + * partially or completely replaced by the inserted range. + * + * If the inserted range either overlaps or is immediately adjacent + * any existing range _mapping to the same value_, then the ranges + * will be coalesced into a single contiguous range. + * + * # Panics + * + * Panics if range `start >= end`. + */ +export function insert$u64_unit(self: RangeMap, range: rs.Range, _: undefined): void { + if (!rs.u64Lt(range.start, range.end)) { + rs.panic("assertion failed: range.start < range.end"); + } else { + const newStartWrapper: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(range); + const candidates: rs.Iter<[RangeStartWrapper.RangeStartWrapper, undefined]> = rs.iterFilter(rs.iterTake(rs.iterRev(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: newStartWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64))), 2), (_2: [RangeStartWrapper.RangeStartWrapper, undefined]): boolean => { + return touches$rangemap_std_ext_RangeExt_u64_ops_Range_u64(_2[0].endWrapper.range, newStartWrapper.endWrapper.range); + }); + const _22: [RangeStartWrapper.RangeStartWrapper, undefined] | rs.Done = candidates.next(); + if (_22 !== rs.DONE) { + let candidate: [RangeStartWrapper.RangeStartWrapper, undefined] = _22; + const _26: [RangeStartWrapper.RangeStartWrapper, undefined] | rs.Done = candidates.next(); + if (_26 !== rs.DONE) { + candidate = _26; + } + const _33: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.clone$Clone_u64(candidate[0]); + candidate[1]; + adjustTouchingRangesForInsert$u64_unit(self, _33, undefined, newStartWrapper.endWrapper.range, undefined); + } + while (true) { + const newRangeEndAsStart: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(newStartWrapper.endWrapper.range.end, newStartWrapper.endWrapper.range.end, rs.u64Step)); + const _48: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Included", _0: newStartWrapper } as rs.RangeBound>, { tag: "Included", _0: newRangeEndAsStart } as rs.RangeBound>]; + const _44: [RangeStartWrapper.RangeStartWrapper, undefined] | rs.Done = rs.btreeRange(self.btm, _48, RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).next(); + if (_44 !== rs.DONE) { + if (rs.u64Eq(_44[0].endWrapper.range.start, newStartWrapper.endWrapper.range.end)) { + if (false) { + break; + } + } + const storedStartWrapper2: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.clone$Clone_u64(_44[0]); + _44[1]; + adjustTouchingRangesForInsert$u64_unit(self, storedStartWrapper2, undefined, newStartWrapper.endWrapper.range, undefined); + } else { + break; + } + } + rs.btreeInsert(self.btm, newStartWrapper, undefined, undefined, rs.None); + } +} + +/** + * Removes a range from the map, if all or any of it was present. + * + * If the range to be removed _partially_ overlaps any ranges + * in the map, then those ranges will be contracted to no + * longer cover the removed range. + * + * + * # Panics + * + * Panics if range `start >= end`. + */ +export function remove$u64_u64(self: RangeMap, range: rs.Range): void { + if (!rs.u64Lt(range.start, range.end)) { + rs.panic("assertion failed: range.start < range.end"); + } else { + const startWrapper: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(range); + const range2: rs.Range = startWrapper.endWrapper.range; + const _10: [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined = option_map$02ffuo4(filter$00vfvog(rs.iterToOption(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: startWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeStartWrapper.RangeStartWrapper, rs.u64]): boolean => { + return overlaps$rangemap_std_ext_RangeExt_u64_ops_Range_u64(_2[0].endWrapper.range, range2); + }), (_22: [RangeStartWrapper.RangeStartWrapper, rs.u64]): [RangeStartWrapper.RangeStartWrapper, rs.u64] => { + return [RangeStartWrapper.clone$Clone_u64(_22[0]), _22[1]] as [RangeStartWrapper.RangeStartWrapper, rs.u64]; + }); + if (_10 !== undefined) { + adjustOverlappingRangesForRemove$u64_u64(self, _10[0], _10[1], range2); + } + while (true) { + const newRangeEndAsStart: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(range2.end, range2.end, rs.u64Step)); + const _37: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: startWrapper } as rs.RangeBound>, { tag: "Excluded", _0: newRangeEndAsStart } as rs.RangeBound>]; + const _32: [RangeStartWrapper.RangeStartWrapper, rs.u64] | undefined = option_map$02ffuo4(rs.iterToOption(rs.btreeRange(self.btm, _37, RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).next()), (_23: [RangeStartWrapper.RangeStartWrapper, rs.u64]): [RangeStartWrapper.RangeStartWrapper, rs.u64] => { + return [RangeStartWrapper.clone$Clone_u64(_23[0]), _23[1]] as [RangeStartWrapper.RangeStartWrapper, rs.u64]; + }); + if (_32 !== undefined) { + adjustOverlappingRangesForRemove$u64_u64(self, _32[0], _32[1], range2); + } else { + break; + } + } + } +} + +/** + * Removes a range from the map, if all or any of it was present. + * + * If the range to be removed _partially_ overlaps any ranges + * in the map, then those ranges will be contracted to no + * longer cover the removed range. + * + * + * # Panics + * + * Panics if range `start >= end`. + */ +export function remove$u64_unit(self: RangeMap, range: rs.Range): void { + if (!rs.u64Lt(range.start, range.end)) { + rs.panic("assertion failed: range.start < range.end"); + } else { + const startWrapper: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(range); + const range2: rs.Range = startWrapper.endWrapper.range; + const _10: [RangeStartWrapper.RangeStartWrapper, undefined] | undefined = option_map$105h877(filter$16uxvkg(rs.iterToOption(rs.btreeRange(self.btm, [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: startWrapper } as rs.RangeBound>] as [rs.RangeBound>, rs.RangeBound>], RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).nextBack()), (_2: [RangeStartWrapper.RangeStartWrapper, undefined]): boolean => { + return overlaps$rangemap_std_ext_RangeExt_u64_ops_Range_u64(_2[0].endWrapper.range, range2); + }), (_22: [RangeStartWrapper.RangeStartWrapper, undefined]): [RangeStartWrapper.RangeStartWrapper, undefined] => { + const _5: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.clone$Clone_u64(_22[0]); + _22[1]; + return [_5, undefined] as [RangeStartWrapper.RangeStartWrapper, undefined]; + }); + if (_10 !== undefined) { + adjustOverlappingRangesForRemove$u64_unit(self, _10[0], undefined, range2); + } + while (true) { + const newRangeEndAsStart: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(range2.end, range2.end, rs.u64Step)); + const _37: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: startWrapper } as rs.RangeBound>, { tag: "Excluded", _0: newRangeEndAsStart } as rs.RangeBound>]; + const _32: [RangeStartWrapper.RangeStartWrapper, undefined] | undefined = option_map$105h877(rs.iterToOption(rs.btreeRange(self.btm, _37, RangeStartWrapper.eq$cmp_PartialEq_u64, rs.cmpGt(RangeStartWrapper.partialCmp$cmp_PartialOrd_u64)).next()), (_23: [RangeStartWrapper.RangeStartWrapper, undefined]): [RangeStartWrapper.RangeStartWrapper, undefined] => { + const _52: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.clone$Clone_u64(_23[0]); + _23[1]; + return [_52, undefined] as [RangeStartWrapper.RangeStartWrapper, undefined]; + }); + if (_32 !== undefined) { + adjustOverlappingRangesForRemove$u64_unit(self, _32[0], undefined, range2); + } else { + break; + } + } + } +} + +export function adjustTouchingRangesForInsert$u64_u64(self: RangeMap, storedStartWrapper: RangeStartWrapper.RangeStartWrapper, storedValue: rs.u64, newRange: rs.Range, newValue: rs.u64): void { + if (!rs.u64Eq(storedValue, newValue)) { + if (overlaps$rangemap_std_ext_RangeExt_u64_ops_Range_u64(newRange, RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper).range)) { + rs.btreeRemove(self.btm, storedStartWrapper); + if (rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper)).start, newRange.start)) { + const _41: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(storedStartWrapper.endWrapper.range.start, newRange.start, rs.u64Step)); + rs.btreeInsert(self.btm, _41, storedValue); + } + if (rs.u64Gt(storedStartWrapper.endWrapper.range.end, newRange.end)) { + const _53: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(newRange.end, storedStartWrapper.endWrapper.range.end, rs.u64Step)); + rs.btreeInsert(self.btm, _53, storedValue); + } + } + } else { + const _12: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper)); + newRange.start = min$10dxkeu(newRange.start, _12.start); + const _19: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper)); + newRange.end = max$10jofma(newRange.end, _19.end); + rs.btreeRemove(self.btm, storedStartWrapper); + } +} + +export function adjustTouchingRangesForInsert$u64_unit(self: RangeMap, storedStartWrapper: RangeStartWrapper.RangeStartWrapper, _: undefined, newRange: rs.Range, _newValue: undefined): void { + if (false) { + if (overlaps$rangemap_std_ext_RangeExt_u64_ops_Range_u64(newRange, RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper).range)) { + rs.btreeRemove(self.btm, storedStartWrapper, undefined, rs.None); + if (rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper)).start, newRange.start)) { + const _41: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(storedStartWrapper.endWrapper.range.start, newRange.start, rs.u64Step)); + rs.btreeInsert(self.btm, _41, undefined, undefined, rs.None); + } + if (rs.u64Gt(storedStartWrapper.endWrapper.range.end, newRange.end)) { + const _53: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(newRange.end, storedStartWrapper.endWrapper.range.end, rs.u64Step)); + rs.btreeInsert(self.btm, _53, undefined, undefined, rs.None); + } + } + } else { + const _12: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper)); + newRange.start = min$10dxkeu(newRange.start, _12.start); + const _19: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(RangeStartWrapper.deref$ops_Deref_u64(storedStartWrapper)); + newRange.end = max$10jofma(newRange.end, _19.end); + rs.btreeRemove(self.btm, storedStartWrapper, undefined, rs.None); + } +} + +export function adjustOverlappingRangesForRemove$u64_u64(self: RangeMap, stored: RangeStartWrapper.RangeStartWrapper, storedValue: rs.u64, rangeToRemove: rs.Range): void { + rs.btreeRemove(self.btm, stored); + const storedRange: RangeEndWrapper.RangeEndWrapper = stored.endWrapper; + if (rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(storedRange).start, rangeToRemove.start)) { + const _16: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(storedRange.range.start, rangeToRemove.start, rs.u64Step)); + rs.btreeInsert(self.btm, _16, storedValue); + } + if (rs.u64Gt(storedRange.range.end, rangeToRemove.end)) { + const _28: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(rangeToRemove.end, storedRange.range.end, rs.u64Step)); + rs.btreeInsert(self.btm, _28, storedValue); + } +} + +export function adjustOverlappingRangesForRemove$u64_unit(self: RangeMap, stored: RangeStartWrapper.RangeStartWrapper, _: undefined, rangeToRemove: rs.Range): void { + rs.btreeRemove(self.btm, stored, undefined, rs.None); + const storedRange: RangeEndWrapper.RangeEndWrapper = stored.endWrapper; + if (rs.u64Lt(RangeEndWrapper.deref$ops_Deref_u64(storedRange).start, rangeToRemove.start)) { + const _16: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(storedRange.range.start, rangeToRemove.start, rs.u64Step)); + rs.btreeInsert(self.btm, _16, undefined, undefined, rs.None); + } + if (rs.u64Gt(storedRange.range.end, rangeToRemove.end)) { + const _28: RangeStartWrapper.RangeStartWrapper = RangeStartWrapper.new$u64(new rs.Range(rangeToRemove.end, storedRange.range.end, rs.u64Step)); + rs.btreeInsert(self.btm, _28, undefined, undefined, rs.None); + } +} + +export function intoIter$iter_IntoIterator_u64_unit(self: RangeMap): map_IntoIter.IntoIter { + return { inner: rs.btreeIter(self.btm) }; +} + +//# sourceMappingURL=map.RangeMap.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/operations.Intersection.ts b/ts/fixtures/stock/expected/rangemap/operations.Intersection.ts new file mode 100644 index 000000000..c4840fd46 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/operations.Intersection.ts @@ -0,0 +1,40 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { orderEnd$rangemap_operations_RangeOrder_ops_Range_u64, intersect$rangemap_operations_RangeIntersect_ops_Range_u64 } from "../rangemap/operations.ts"; +import * as set_Iter from "../rangemap/set.Iter.ts"; + +export interface Intersection { + left: rs.Peekable>; + right: rs.Peekable>; +} + +export function new$ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64(left: set_Iter.Iter, right: set_Iter.Iter): Intersection, set_Iter.Iter, set_Iter.Iter> { + return { left: rs.iterPeekable(rs.iterFrom(left, set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) })) as rs.Peekable>>, right: rs.iterPeekable(rs.iterFrom(right, set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) })) as rs.Peekable>> }; +} + +export function next$iter_Iterator_ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64(self: Intersection, set_Iter.Iter, set_Iter.Iter>): rs.Range | rs.Done { + while (true) { + const _4: [rs.Range | undefined, rs.Range | undefined] = [rs.peekablePeek(self.left as rs.Peekable>), rs.peekablePeek(self.right as rs.Peekable>)]; + if (_4[0] !== undefined) { + if (_4[1] !== undefined) { + const intersection: rs.Range | undefined = intersect$rangemap_operations_RangeIntersect_ops_Range_u64(_4[0], _4[1]); + if (!(orderEnd$rangemap_operations_RangeOrder_ops_Range_u64(_4[0], _4[1]) < 0)) { + (self.right as rs.Peekable>).next(); + } else { + (self.left as rs.Peekable>).next(); + } + if (intersection !== undefined) { + return intersection; + } + } else { + break; + } + } else { + break; + } + } + return rs.DONE; +} + +//# sourceMappingURL=operations.Intersection.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/operations.Union.ts b/ts/fixtures/stock/expected/rangemap/operations.Union.ts new file mode 100644 index 000000000..14b73c636 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/operations.Union.ts @@ -0,0 +1,55 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { orderStart$rangemap_operations_RangeOrder_ops_Range_u64, merge$rangemap_operations_RangeMerge_ops_Range_u64 } from "../rangemap/operations.ts"; +import * as set_Iter from "../rangemap/set.Iter.ts"; + +export interface Union { + left: rs.Peekable>; + right: rs.Peekable>; +} + +export function new$ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64(left: set_Iter.Iter, right: set_Iter.Iter): Union, set_Iter.Iter, set_Iter.Iter> { + return { left: rs.iterPeekable(rs.iterFrom(left, set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) })) as rs.Peekable>>, right: rs.iterPeekable(rs.iterFrom(right, set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) })) as rs.Peekable>> }; +} + +export function next$iter_Iterator_ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64(self: Union, set_Iter.Iter, set_Iter.Iter>): rs.Range | rs.Done { + let _4!: rs.Range; + let _20!: rs.Range; + const _5: [rs.Range | undefined, rs.Range | undefined] = [rs.peekablePeek(self.left as rs.Peekable>), rs.peekablePeek(self.right as rs.Peekable>)]; + if (_5[0] === undefined) { + if (_5[1] === undefined) { + return rs.DONE; + } + _4 = rs.optionUnwrap(rs.iterToOption((self.right as rs.Peekable>).next())); + } else if (_5[1] === undefined) { + _4 = rs.optionUnwrap(rs.iterToOption((self.left as rs.Peekable>).next())); + } else { + if (!(orderStart$rangemap_operations_RangeOrder_ops_Range_u64(_5[0], _5[1]) < 0)) { + _20 = rs.optionUnwrap(rs.iterToOption((self.right as rs.Peekable>).next())); + } else { + _20 = rs.optionUnwrap(rs.iterToOption((self.left as rs.Peekable>).next())); + } + _4 = _20; + } + const range: rs.Range = _4.clone(); + const join: (a0: rs.Peekable>) => boolean = (iter: rs.Peekable>): boolean => { + const _33: rs.Range | undefined = rs.peekablePeek(iter); + if (_33 !== undefined) { + if (merge$rangemap_operations_RangeMerge_ops_Range_u64(range, _33)) { + rs.optionUnwrap(rs.iterToOption(iter.next())); + return true; + } + } + return false; + }; + while (true) { + if (!join(self.left as rs.Peekable>)) { + if (!join(self.right as rs.Peekable>)) { + return range; + } + } + } +} + +//# sourceMappingURL=operations.Union.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/operations.ts b/ts/fixtures/stock/expected/rangemap/operations.ts new file mode 100644 index 000000000..868f4eeee --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/operations.ts @@ -0,0 +1,32 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; + +export function orderStart$rangemap_operations_RangeOrder_ops_Range_u64(self: rs.Range, other: rs.Range): rs.Ordering { + return rs.cmp(self.start, other.start); +} + +export function orderEnd$rangemap_operations_RangeOrder_ops_Range_u64(self: rs.Range, other: rs.Range): rs.Ordering { + return rs.cmp(self.end, other.end); +} + +export function merge$rangemap_operations_RangeMerge_ops_Range_u64(self: rs.Range, other: rs.Range): boolean { + if (!rs.rangeContains(self, other.start)) { + return false; + } + if (rs.u64Gt(other.end, self.end)) { + self.end = other.end; + } + return true; +} + +export function intersect$rangemap_operations_RangeIntersect_ops_Range_u64(self: rs.Range, other: rs.Range): rs.Range | undefined { + const start: rs.u64 = rs.u64Max(self.start, other.start); + const end: rs.u64 = rs.u64Min(self.end, other.end); + if (!rs.u64Ge(start, end)) { + return new rs.Range(start, end, rs.u64Step); + } + return undefined; +} + +//# sourceMappingURL=operations.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeEndWrapper.ts b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeEndWrapper.ts new file mode 100644 index 000000000..17d764ef8 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeEndWrapper.ts @@ -0,0 +1,43 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; + +export function clone$Clone_u64(self: RangeEndWrapper): RangeEndWrapper { + return new RangeEndWrapper(self.range.clone()); +} + +export class RangeEndWrapper { + range: rs.Range; + + constructor(range: rs.Range) { + this.range = range; + } +} + +export function new$u64(range: rs.Range): RangeEndWrapper { + return new RangeEndWrapper(range); +} + +export function eq$cmp_PartialEq_u64(self: RangeEndWrapper, other: RangeEndWrapper): boolean { + const _4: rs.Range = deref$ops_Deref_u64(self); + const _6: rs.Range = deref$ops_Deref_u64(other); + return rs.u64Eq(_4.end, _6.end); +} + +export function cmp$cmp_Ord_u64(self: RangeEndWrapper, other: RangeEndWrapper): rs.Ordering { + const _4: rs.Range = deref$ops_Deref_u64(self); + const _6: rs.Range = deref$ops_Deref_u64(other); + return rs.cmp(_4.end, _6.end); +} + +export function partialCmp$cmp_PartialOrd_u64(self: RangeEndWrapper, other: RangeEndWrapper): rs.Ordering | undefined { + const _4: rs.Range = deref$ops_Deref_u64(self); + const _6: rs.Range = deref$ops_Deref_u64(other); + return rs.cmp(_4.end, _6.end); +} + +export function deref$ops_Deref_u64(self: RangeEndWrapper): rs.Range { + return self.range; +} + +//# sourceMappingURL=range_wrapper.RangeEndWrapper.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeInclusiveEndWrapper.ts b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeInclusiveEndWrapper.ts new file mode 100644 index 000000000..d00f3c3d9 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeInclusiveEndWrapper.ts @@ -0,0 +1,37 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; + +export function clone$Clone_u64(self: RangeInclusiveEndWrapper): RangeInclusiveEndWrapper { + return new RangeInclusiveEndWrapper(self.range.clone()); +} + +export class RangeInclusiveEndWrapper { + range: rs.RangeInclusive; + + constructor(range: rs.RangeInclusive) { + this.range = range; + } +} + +export function new$u64(range: rs.RangeInclusive): RangeInclusiveEndWrapper { + return new RangeInclusiveEndWrapper(range); +} + +export function eq$cmp_PartialEq_u64(self: RangeInclusiveEndWrapper, other: RangeInclusiveEndWrapper): boolean { + return rs.u64Eq(rs.rangeInclusiveEnd(deref$ops_Deref_u64(self)), rs.rangeInclusiveEnd(deref$ops_Deref_u64(other))); +} + +export function cmp$cmp_Ord_u64(self: RangeInclusiveEndWrapper, other: RangeInclusiveEndWrapper): rs.Ordering { + return rs.cmp(rs.rangeInclusiveEnd(deref$ops_Deref_u64(self)), rs.rangeInclusiveEnd(deref$ops_Deref_u64(other))); +} + +export function partialCmp$cmp_PartialOrd_u64(self: RangeInclusiveEndWrapper, other: RangeInclusiveEndWrapper): rs.Ordering | undefined { + return rs.cmp(rs.rangeInclusiveEnd(deref$ops_Deref_u64(self)), rs.rangeInclusiveEnd(deref$ops_Deref_u64(other))); +} + +export function deref$ops_Deref_u64(self: RangeInclusiveEndWrapper): rs.RangeInclusive { + return self.range; +} + +//# sourceMappingURL=range_wrapper.RangeInclusiveEndWrapper.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeInclusiveStartWrapper.ts b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeInclusiveStartWrapper.ts new file mode 100644 index 000000000..3c06173e4 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeInclusiveStartWrapper.ts @@ -0,0 +1,42 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as RangeInclusiveEndWrapper from "../rangemap/range_wrapper.RangeInclusiveEndWrapper.ts"; + +export function clone$Clone_u64(self: RangeInclusiveStartWrapper): RangeInclusiveStartWrapper { + return new RangeInclusiveStartWrapper(RangeInclusiveEndWrapper.clone$Clone_u64(self.endWrapper)); +} + +export class RangeInclusiveStartWrapper { + endWrapper: RangeInclusiveEndWrapper.RangeInclusiveEndWrapper; + + constructor(endWrapper: RangeInclusiveEndWrapper.RangeInclusiveEndWrapper) { + this.endWrapper = endWrapper; + } +} + +export function new$u64(range: rs.RangeInclusive): RangeInclusiveStartWrapper { + return new RangeInclusiveStartWrapper(RangeInclusiveEndWrapper.new$u64(range)); +} + +export function eq$cmp_PartialEq_u64(self: RangeInclusiveStartWrapper, other: RangeInclusiveStartWrapper): boolean { + return rs.u64Eq(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(self))), rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(other)))); +} + +export function cmp$cmp_Ord_u64(self: RangeInclusiveStartWrapper, other: RangeInclusiveStartWrapper): rs.Ordering { + return rs.cmp(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(self))), rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(other)))); +} + +export function partialCmp$cmp_PartialOrd_u64(self: RangeInclusiveStartWrapper, other: RangeInclusiveStartWrapper): rs.Ordering | undefined { + return rs.cmp(rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(self))), rs.rangeInclusiveStart(RangeInclusiveEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(other)))); +} + +export function borrow$Borrow_rangemap_range_wrapper_RangeInclusiveEndWrapper_u64_u64(self: RangeInclusiveStartWrapper): RangeInclusiveEndWrapper.RangeInclusiveEndWrapper { + return self.endWrapper; +} + +export function deref$ops_Deref_u64(self: RangeInclusiveStartWrapper): RangeInclusiveEndWrapper.RangeInclusiveEndWrapper { + return self.endWrapper; +} + +//# sourceMappingURL=range_wrapper.RangeInclusiveStartWrapper.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeStartWrapper.ts b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeStartWrapper.ts new file mode 100644 index 000000000..a473b6e6c --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/range_wrapper.RangeStartWrapper.ts @@ -0,0 +1,48 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as RangeEndWrapper from "../rangemap/range_wrapper.RangeEndWrapper.ts"; + +export function clone$Clone_u64(self: RangeStartWrapper): RangeStartWrapper { + return new RangeStartWrapper(RangeEndWrapper.clone$Clone_u64(self.endWrapper)); +} + +export class RangeStartWrapper { + endWrapper: RangeEndWrapper.RangeEndWrapper; + + constructor(endWrapper: RangeEndWrapper.RangeEndWrapper) { + this.endWrapper = endWrapper; + } +} + +export function new$u64(range: rs.Range): RangeStartWrapper { + return new RangeStartWrapper(RangeEndWrapper.new$u64(range)); +} + +export function eq$cmp_PartialEq_u64(self: RangeStartWrapper, other: RangeStartWrapper): boolean { + const _4: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(self)); + const _7: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(other)); + return rs.u64Eq(_4.start, _7.start); +} + +export function cmp$cmp_Ord_u64(self: RangeStartWrapper, other: RangeStartWrapper): rs.Ordering { + const _4: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(self)); + const _7: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(other)); + return rs.cmp(_4.start, _7.start); +} + +export function partialCmp$cmp_PartialOrd_u64(self: RangeStartWrapper, other: RangeStartWrapper): rs.Ordering | undefined { + const _4: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(self)); + const _7: rs.Range = RangeEndWrapper.deref$ops_Deref_u64(deref$ops_Deref_u64(other)); + return rs.cmp(_4.start, _7.start); +} + +export function borrow$Borrow_rangemap_range_wrapper_RangeEndWrapper_u64_u64(self: RangeStartWrapper): RangeEndWrapper.RangeEndWrapper { + return self.endWrapper; +} + +export function deref$ops_Deref_u64(self: RangeStartWrapper): RangeEndWrapper.RangeEndWrapper { + return self.endWrapper; +} + +//# sourceMappingURL=range_wrapper.RangeStartWrapper.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/set.Gaps.ts b/ts/fixtures/stock/expected/rangemap/set.Gaps.ts new file mode 100644 index 000000000..473a50476 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/set.Gaps.ts @@ -0,0 +1,22 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import * as map_Gaps from "../rangemap/map.Gaps.ts"; + +/** + * An iterator over all ranges not covered by a `RangeSet`. + * + * This `struct` is created by the [`gaps`] method on [`RangeSet`]. See its + * documentation for more. + * + * [`gaps`]: RangeSet::gaps + */ +export interface Gaps { + inner: map_Gaps.Gaps; +} + +export function next$iter_Iterator_u64(self: Gaps): rs.Range | rs.Done { + return map_Gaps.next$iter_Iterator_u64_unit(self.inner); +} + +//# sourceMappingURL=set.Gaps.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/set.IntoIter.ts b/ts/fixtures/stock/expected/rangemap/set.IntoIter.ts new file mode 100644 index 000000000..fccd36d95 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/set.IntoIter.ts @@ -0,0 +1,39 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$1szk2qx as option_map$1szk2qx } from "../core/option.ts"; +import * as map_IntoIter from "../rangemap/map.IntoIter.ts"; + +/** + * An owning iterator over the ranges of a `RangeSet`. + * + * This `struct` is created by the [`into_iter`] method on [`RangeSet`] + * (provided by the `IntoIterator` trait). See its documentation for more. + * + * [`into_iter`]: IntoIterator::into_iter + */ +export class IntoIter { + inner: map_IntoIter.IntoIter; + + constructor(inner: map_IntoIter.IntoIter) { + this.inner = inner; + } +} + +export function next$iter_Iterator_u64(self: IntoIter): rs.Range | rs.Done { + return rs.iterFromOption(option_map$1szk2qx(rs.iterToOption(map_IntoIter.next$iter_Iterator_u64_unit(self.inner)), (_22: [rs.Range, undefined]): rs.Range => { + return _22[0]; + })); +} + +export function sizeHint$iter_Iterator_u64(self: IntoIter): [rs.usize, rs.usize | undefined] { + return map_IntoIter.sizeHint$iter_Iterator_u64_unit(self.inner); +} + +export function nextBack$iter_DoubleEndedIterator_u64(self: IntoIter): rs.Range | undefined { + return option_map$1szk2qx(map_IntoIter.nextBack$iter_DoubleEndedIterator_u64_unit(self.inner), (_22: [rs.Range, undefined]): rs.Range => { + return _22[0]; + }); +} + +//# sourceMappingURL=set.IntoIter.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/set.Iter.ts b/ts/fixtures/stock/expected/rangemap/set.Iter.ts new file mode 100644 index 000000000..0d8bdc40e --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/set.Iter.ts @@ -0,0 +1,35 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$1szk2qx as option_map$1szk2qx } from "../core/option.ts"; +import * as map_Iter from "../rangemap/map.Iter.ts"; + +/** + * An iterator over the ranges of a `RangeSet`. + * + * This `struct` is created by the [`iter`] method on [`RangeSet`]. See its + * documentation for more. + * + * [`iter`]: RangeSet::iter + */ +export interface Iter { + inner: map_Iter.Iter; +} + +export function next$iter_Iterator_u64(self: Iter): rs.Range | rs.Done { + return rs.iterFromOption(option_map$1szk2qx(rs.iterToOption(map_Iter.next$iter_Iterator_u64_unit(self.inner)), (_22: [rs.Range, undefined]): rs.Range => { + return _22[0]; + })); +} + +export function sizeHint$iter_Iterator_u64(self: Iter): [rs.usize, rs.usize | undefined] { + return map_Iter.sizeHint$iter_Iterator_u64_unit(self.inner); +} + +export function nextBack$iter_DoubleEndedIterator_u64(self: Iter): rs.Range | undefined { + return option_map$1szk2qx(map_Iter.nextBack$iter_DoubleEndedIterator_u64_unit(self.inner), (_22: [rs.Range, undefined]): rs.Range => { + return _22[0]; + }); +} + +//# sourceMappingURL=set.Iter.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/set.Overlapping.ts b/ts/fixtures/stock/expected/rangemap/set.Overlapping.ts new file mode 100644 index 000000000..61b97e523 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/set.Overlapping.ts @@ -0,0 +1,36 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$1szk2qx as option_map$1szk2qx } from "../core/option.ts"; +import * as map_Overlapping from "../rangemap/map.Overlapping.ts"; + +/** + * An iterator over all stored ranges partially or completely + * overlapped by a given range. + * + * This `struct` is created by the [`overlapping`] method on [`RangeSet`]. See its + * documentation for more. + * + * [`overlapping`]: RangeSet::overlapping + */ +export class Overlapping { + inner: map_Overlapping.Overlapping; + + constructor(inner: map_Overlapping.Overlapping) { + this.inner = inner; + } +} + +export function next$iter_Iterator_u64_ref_ops_Range_u64(self: Overlapping>): rs.Range | rs.Done { + return rs.iterFromOption(option_map$1szk2qx(rs.iterToOption(map_Overlapping.next$iter_Iterator_u64_unit_ref_ops_Range_u64(self.inner)), (_22: [rs.Range, undefined]): rs.Range => { + return _22[0]; + })); +} + +export function nextBack$iter_DoubleEndedIterator_u64_ref_ops_Range_u64(self: Overlapping>): rs.Range | undefined { + return option_map$1szk2qx(map_Overlapping.nextBack$iter_DoubleEndedIterator_u64_unit_ref_ops_Range_u64(self.inner), (_22: [rs.Range, undefined]): rs.Range => { + return _22[0]; + }); +} + +//# sourceMappingURL=set.Overlapping.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/set.RangeSet.ts b/ts/fixtures/stock/expected/rangemap/set.RangeSet.ts new file mode 100644 index 000000000..e01f7b310 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/set.RangeSet.ts @@ -0,0 +1,173 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { map$1szk2qx as option_map$1szk2qx } from "../core/option.ts"; +import * as RangeMap from "../rangemap/map.RangeMap.ts"; +import * as operations_Intersection from "../rangemap/operations.Intersection.ts"; +import * as operations_Union from "../rangemap/operations.Union.ts"; +import type * as set_Gaps from "../rangemap/set.Gaps.ts"; +import * as set_IntoIter from "../rangemap/set.IntoIter.ts"; +import type * as set_Iter from "../rangemap/set.Iter.ts"; +import * as set_Overlapping from "../rangemap/set.Overlapping.ts"; + +export function clone$Clone_u64(self: RangeSet): RangeSet { + return new RangeSet(RangeMap.clone$Clone_u64_unit(self.rm)); +} + +/** + * A set whose items are stored as (half-open) ranges bounded + * inclusively below and exclusively above `(start..end)`. + * + * See [`RangeMap`]'s documentation for more details. + * + * [`RangeMap`]: crate::RangeMap + */ +export class RangeSet { + rm: RangeMap.RangeMap; + + constructor(rm: RangeMap.RangeMap) { + this.rm = rm; + } +} + +/** Makes a new empty `RangeSet`. */ +export function new$u64(): RangeSet { + return new RangeSet(RangeMap.new$u64_unit()); +} + +/** Returns a reference to the range covering the given key, if any. */ +export function get$u64(self: RangeSet, value: rs.u64): rs.Range | undefined { + return option_map$1szk2qx(RangeMap.getKeyValue$u64_unit(self.rm, value), (_2: [rs.Range, undefined]): rs.Range => { + return _2[0]; + }); +} + +/** Returns `true` if any range in the set covers the specified value. */ +export function contains$u64(self: RangeSet, value: rs.u64): boolean { + return RangeMap.containsKey$u64_unit(self.rm, value); +} + +/** + * Gets an ordered iterator over all ranges, + * ordered by range. + */ +export function iter$u64(self: RangeSet): set_Iter.Iter { + return { inner: RangeMap.iter$u64_unit(self.rm) }; +} + +/** Returns the number of elements in the set. */ +export function len$u64(self: RangeSet): rs.usize { + return RangeMap.len$u64_unit(self.rm); +} + +/** Returns true if the set contains no elements. */ +export function isEmpty$u64(self: RangeSet): boolean { + return RangeMap.isEmpty$u64_unit(self.rm); +} + +/** Return an iterator over the intersection of two range sets. */ +export function intersection$u64(self: RangeSet, other: RangeSet): operations_Intersection.Intersection, set_Iter.Iter, set_Iter.Iter> { + return operations_Intersection.new$ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64(iter$u64(self), iter$u64(other)); +} + +/** Return an iterator over the union of two range sets. */ +export function union$u64(self: RangeSet, other: RangeSet): operations_Union.Union, set_Iter.Iter, set_Iter.Iter> { + return operations_Union.new$ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64(iter$u64(self), iter$u64(other)); +} + +/** + * Insert a range into the set. + * + * If the inserted range either overlaps or is immediately adjacent + * any existing range, then the ranges will be coalesced into + * a single contiguous range. + * + * # Panics + * + * Panics if range `start >= end`. + */ +export function insert$u64(self: RangeSet, range: rs.Range): void { + RangeMap.insert$u64_unit(self.rm, range, undefined); +} + +/** + * Removes a range from the set, if all or any of it was present. + * + * If the range to be removed _partially_ overlaps any ranges + * in the set, then those ranges will be contracted to no + * longer cover the removed range. + * + * # Panics + * + * Panics if range `start >= end`. + */ +export function remove$u64(self: RangeSet, range: rs.Range): void { + RangeMap.remove$u64_unit(self.rm, range); +} + +/** + * Gets an iterator over all the maximally-sized ranges + * contained in `outer_range` that are not covered by + * any range stored in the set. + * + * If the start and end of the outer range are the same + * and it does not overlap any stored range, then a single + * empty gap will be returned. + * + * The iterator element type is `Range`. + */ +export function gaps$u64(self: RangeSet, outerRange: rs.Range): set_Gaps.Gaps { + return { inner: RangeMap.gaps$u64_unit(self.rm, outerRange) }; +} + +/** + * Gets an iterator over all the stored ranges that are + * either partially or completely overlapped by the given range. + * + * The iterator element type is `&Range`. + */ +export function overlapping$u64_ref_ops_Range_u64(self: RangeSet, range: rs.Range): set_Overlapping.Overlapping> { + return new set_Overlapping.Overlapping(RangeMap.overlapping$u64_unit_ref_ops_Range_u64(self.rm, range)); +} + +/** + * Returns `true` if any range in the set completely or partially + * overlaps the given range. + */ +export function overlaps$u64(self: RangeSet, range: rs.Range): boolean { + return rs.iterToOption(set_Overlapping.next$iter_Iterator_u64_ref_ops_Range_u64(overlapping$u64_ref_ops_Range_u64(self, range))) !== undefined; +} + +/** + * Returns the first range in the set, if one exists. The range is the minimum range in this + * set. + */ +export function first$u64(self: RangeSet): rs.Range | undefined { + return option_map$1szk2qx(RangeMap.firstRangeValue$u64_unit(self.rm), (_22: [rs.Range, undefined]): rs.Range => { + return _22[0]; + }); +} + +export function intoIter$iter_IntoIterator_u64(self: RangeSet): set_IntoIter.IntoIter { + return new set_IntoIter.IntoIter(RangeMap.intoIter$iter_IntoIterator_u64_unit(self.rm)); +} + +export function fromIter$iter_FromIterator_ops_Range_u64_u64_array2_ops_Range_u64(iter: rs.Range[]): RangeSet { + const rangeSet: RangeSet = new$u64(); + extend$iter_Extend_ops_Range_u64_u64_array2_ops_Range_u64(rangeSet, iter); + return rangeSet; +} + +export function extend$iter_Extend_ops_Range_u64_u64_array2_ops_Range_u64(self: RangeSet, iter: rs.Range[]): void { + rs.iterForEach(rs.iterSlice(iter), (range: rs.Range): undefined => { + insert$u64(self, range); + }); +} + +export function extend$iter_Extend_ops_Range_u64_u64_iter_Filter_iter_Cloned_rangemap_set_Iter_u64_ranges_ranges_closure13(self: RangeSet, iter: rs.Iter>): void { + rs.iterForEach(iter, (range: rs.Range): undefined => { + insert$u64(self, range); + }); +} + +//# sourceMappingURL=set.RangeSet.ts.map diff --git a/ts/fixtures/stock/expected/rangemap/std_ext.ts b/ts/fixtures/stock/expected/rangemap/std_ext.ts new file mode 100644 index 000000000..c085d32e6 --- /dev/null +++ b/ts/fixtures/stock/expected/rangemap/std_ext.ts @@ -0,0 +1,78 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "../rs.ts"; +import { min$10dxkeu, max$10jofma } from "../core/cmp.ts"; + +export function overlaps$rangemap_std_ext_RangeExt_u64_ops_Range_u64(self: rs.Range, other: rs.Range): boolean { + return rs.u64Lt(max$10jofma(self.start, other.start), min$10dxkeu(self.end, other.end)); +} + +export function touches$rangemap_std_ext_RangeExt_u64_ops_Range_u64(self: rs.Range, other: rs.Range): boolean { + return rs.u64Le(max$10jofma(self.start, other.start), min$10dxkeu(self.end, other.end)); +} + +export function overlaps$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64(self: rs.RangeInclusive, other: rs.RangeInclusive): boolean { + return rs.u64Le(max$10jofma(rs.rangeInclusiveStart(self), rs.rangeInclusiveStart(other)), min$10dxkeu(rs.rangeInclusiveEnd(self), rs.rangeInclusiveEnd(other))); +} + +export function touches$rangemap_std_ext_RangeInclusiveExt_u64_ops_RangeInclusive_u64_u64(self: rs.RangeInclusive, other: rs.RangeInclusive): boolean { + let minRangeEndExtended!: rs.u64; + const maxStart: rs.u64 = max$10jofma(rs.rangeInclusiveStart(self), rs.rangeInclusiveStart(other)); + const minRangeEnd: rs.u64 = min$10dxkeu(rs.rangeInclusiveEnd(self), rs.rangeInclusiveEnd(other)); + if (!rs.u64Lt(minRangeEnd, maxStart)) { + minRangeEndExtended = minRangeEnd; + } else { + minRangeEndExtended = addOne$rangemap_StepFns_u64_u64(minRangeEnd); + } + return rs.u64Le(maxStart, minRangeEndExtended); +} + +/** + * Returns the _successor_ of `self`. + * + * If this would overflow the range of values supported by `Self`, + * this function is allowed to panic, wrap, or saturate. + * The suggested behavior is to panic when debug assertions are enabled, + * and to wrap or saturate otherwise. + */ +export function addOne$rangemap_StepLite_u64(self: rs.u64): rs.u64 { + return rs.u64Add(self, 1); +} + +/** + * Returns the _predecessor_ of `self`. + * + * If this would overflow the range of values supported by `Self`, + * this function is allowed to panic, wrap, or saturate. + * The suggested behavior is to panic when debug assertions are enabled, + * and to wrap or saturate otherwise. + */ +export function subOne$rangemap_StepLite_u64(self: rs.u64): rs.u64 { + return rs.u64Sub(self, 1); +} + +/** + * Returns the _successor_ of value `start`. + * + * If this would overflow the range of values supported by `Self`, + * this function is allowed to panic, wrap, or saturate. + * The suggested behavior is to panic when debug assertions are enabled, + * and to wrap or saturate otherwise. + */ +export function addOne$rangemap_StepFns_u64_u64(start: rs.u64): rs.u64 { + return addOne$rangemap_StepLite_u64(start); +} + +/** + * Returns the _predecessor_ of value `start`. + * + * If this would overflow the range of values supported by `Self`, + * this function is allowed to panic, wrap, or saturate. + * The suggested behavior is to panic when debug assertions are enabled, + * and to wrap or saturate otherwise. + */ +export function subOne$rangemap_StepFns_u64_u64(start: rs.u64): rs.u64 { + return subOne$rangemap_StepLite_u64(start); +} + +//# sourceMappingURL=std_ext.ts.map diff --git a/ts/fixtures/stock/expected/ranges.ts b/ts/fixtures/stock/expected/ranges.ts new file mode 100644 index 000000000..7df9c1c67 --- /dev/null +++ b/ts/fixtures/stock/expected/ranges.ts @@ -0,0 +1,499 @@ +// Generated by rust2-ts. Do not edit. + +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$0ntbuih as option_mapOr$0ntbuih, mapOr$0mwbrmg as option_mapOr$0mwbrmg, mapOr$1ui9ilq as option_mapOr$1ui9ilq, mapOr$0x6k90y as option_mapOr$0x6k90y } from "./core/option.ts"; +import * as inclusive_map_Gaps from "./rangemap/inclusive_map.Gaps.ts"; +import * as inclusive_map_IntoIter from "./rangemap/inclusive_map.IntoIter.ts"; +import * as inclusive_map_Iter from "./rangemap/inclusive_map.Iter.ts"; +import * as inclusive_map_Overlapping from "./rangemap/inclusive_map.Overlapping.ts"; +import * as RangeInclusiveMap from "./rangemap/inclusive_map.RangeInclusiveMap.ts"; +import * as inclusive_set_Gaps from "./rangemap/inclusive_set.Gaps.ts"; +import * as inclusive_set_Iter from "./rangemap/inclusive_set.Iter.ts"; +import * as inclusive_set_Overlapping from "./rangemap/inclusive_set.Overlapping.ts"; +import * as RangeInclusiveSet from "./rangemap/inclusive_set.RangeInclusiveSet.ts"; +import * as map_Gaps from "./rangemap/map.Gaps.ts"; +import * as map_Iter from "./rangemap/map.Iter.ts"; +import * as map_Overlapping from "./rangemap/map.Overlapping.ts"; +import * as RangeMap from "./rangemap/map.RangeMap.ts"; +import * as operations_Intersection from "./rangemap/operations.Intersection.ts"; +import * as operations_Union from "./rangemap/operations.Union.ts"; +import * as set_Gaps from "./rangemap/set.Gaps.ts"; +import * as set_IntoIter from "./rangemap/set.IntoIter.ts"; +import * as set_Iter from "./rangemap/set.Iter.ts"; +import * as set_Overlapping from "./rangemap/set.Overlapping.ts"; +import * as RangeSet from "./rangemap/set.RangeSet.ts"; + +/** A range's bounds, as eight bytes. */ +export function put(out: rs.ByteVec, start: rs.u64, end: rs.u64): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u64Low(start)).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u64Low(end)).reverse())); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_iter_Rev_rangemap_set_IntoIter_u64_ranges_ranges_closure11(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_inclusive_map_Gaps_u64_u32_u64_ranges_ranges_closure9(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_inclusive_map_Iter_u64_u32_ranges_ranges_closure20(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_inclusive_map_Overlapping_u64_u32_ranges_ranges_closure5(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_inclusive_set_Gaps_u64_u64_ranges_ranges_closure8(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_inclusive_set_Iter_u64_ranges_ranges_closure19(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_inclusive_set_Overlapping_u64_ops_RangeInclusive_u64_ranges_ranges_closure4(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_map_Gaps_u64_u64_ranges_ranges_closure7(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_map_Iter_u64_u64_ranges_ranges_closure18(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_map_Overlapping_u64_u64_ops_Range_u64_ranges_ranges_closure3(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_operations_Intersection_ops_Range_u64_rangemap_set_Iter_u64_ranges_ranges_closure16(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_operations_Union_ops_Range_u64_rangemap_set_Iter_u64_ranges_ranges_closure15(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_set_Gaps_u64_ranges_ranges_closure6(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_set_Iter_u64_ranges_ranges_closure14(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_set_Iter_u64_ranges_ranges_closure17(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_rangemap_set_Overlapping_u64_ranges_ranges_closure2(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** Each range of `ranges`, then a marker. */ +export function putAll$iter_Map_vec_IntoIter_tuple2_ops_RangeInclusive_u64_u32_ranges_ranges_closure12(out: rs.ByteVec, ranges: rs.Iter<[rs.u64, rs.u64, rs.u64]>): void { + const iter: rs.Iter<[rs.u64, rs.u64, rs.u64]> = ranges; + while (true) { + const _5: [rs.u64, rs.u64, rs.u64] | rs.Done = iter.next(); + if (_5 === rs.DONE) { + break; + } + const start: rs.u64 = _5[0]; + const end: rs.u64 = _5[1]; + const value: rs.u64 = _5[2]; + put(out, start, end); + rs.byteVecPush(out, rs.u64Low(value) & 0xff); + } + rs.byteVecPush(out, 255); +} + +/** + * A `RangeSet` and a `RangeMap` of `u64`, and their inclusive twins, through each triple + * of bytes: a step, then a range's bounds, which may be empty or backwards. Each step + * writes what it reads, then each collection's ranges. + */ +export function ranges(data: rs.ByteSlice, out: rs.ByteVec): void { + const set: RangeSet.RangeSet = RangeSet.new$u64(); + const map: RangeMap.RangeMap = RangeMap.new$u64_u64(); + const inclusive: RangeInclusiveSet.RangeInclusiveSet = RangeInclusiveSet.new$u64_u64(); + const values: RangeInclusiveMap.RangeInclusiveMap = RangeInclusiveMap.new$u64_u32_u64(); + const iter: rs.Iter = rs.byteSliceChunks(data, 3); + while (true) { + const _10: rs.ByteSlice | rs.Done = iter.next(); + if (_10 === rs.DONE) { + break; + } + rs.idx(_10, 0); + const op: rs.u8 = _10.data[_10.start]; + const _20: [rs.u64, rs.u64] = [option_unwrapOr$1fr498u(rs.byteSliceGet(_10, 1), 0) as rs.u64, option_unwrapOr$1fr498u(rs.byteSliceGet(_10, 2), 0) as rs.u64]; + const a: rs.u64 = _20[0]; + const b: rs.u64 = _20[1]; + const range: rs.Range = new rs.Range(a, b, rs.u64Step); + const valid: boolean = rs.u64Lt(a, b); + b2: { + const _32: rs.u8 = rs.u8Rem(op, 8); + if (_32 === 0) { + if (valid) { + const _36: rs.Range = range.clone(); + RangeSet.insert$u64(set, _36); + RangeMap.insert$u64_u64(map, range, op as rs.u64); + const _43: rs.RangeInclusive = new rs.RangeInclusive(a, rs.u64Sub(b, 1), rs.u64Step); + RangeInclusiveSet.insert$u64_u64(inclusive, _43); + const _48: rs.RangeInclusive = new rs.RangeInclusive(a, rs.u64Sub(b, 1), rs.u64Step); + RangeInclusiveMap.insert$u64_u32_u64(values, _48, op as rs.u32); + break b2; + } + } else if (_32 === 1) { + if (valid) { + const _54: rs.Range = range.clone(); + RangeSet.remove$u64(set, _54); + RangeMap.remove$u64_u64(map, range); + const _60: rs.RangeInclusive = new rs.RangeInclusive(a, rs.u64Sub(b, 1), rs.u64Step); + RangeInclusiveSet.remove$u64_u64(inclusive, _60); + const _65: rs.RangeInclusive = new rs.RangeInclusive(a, rs.u64Sub(b, 1), rs.u64Step); + RangeInclusiveMap.remove$u64_u32_u64(values, _65); + break b2; + } + } else { + if (_32 === 2) { + rs.byteVecPush(out, RangeSet.contains$u64(set, a) ? 1 : 0); + rs.byteVecPush(out, option_mapOr$0mwbrmg(RangeMap.get$u64_u64(map, a), 254, (_215: rs.u64): rs.u8 => { + return rs.u64Low(_215) & 0xff; + })); + rs.byteVecPush(out, RangeInclusiveSet.contains$u64_u64(inclusive, b) ? 1 : 0); + const _85: [rs.Range, rs.u32] = option_mapOr$1ui9ilq(RangeInclusiveMap.getKeyValue$u64_u32_u64(values, b), [new rs.Range(0, 0, rs.u64Step), 254] as [rs.Range, rs.u32], (_218: [rs.RangeInclusive, rs.u32]): [rs.Range, rs.u32] => { + return [new rs.Range(rs.rangeInclusiveStart(_218[0]), rs.rangeInclusiveEnd(_218[0]), rs.u64Step), _218[1]] as [rs.Range, rs.u32]; + }); + const r: rs.Range = _85[0]; + const v: rs.u32 = _85[1]; + put(out, r.start, r.end); + rs.byteVecPush(out, v & 0xff); + const got: rs.Range = option_mapOr$0ntbuih(RangeSet.get$u64(set, b), new rs.Range(0, 0, rs.u64Step), (a03: rs.Range): rs.Range => { + return a03.clone(); + }); + put(out, got.start, got.end); + break b2; + } + if (_32 === 3) { + putAll$iter_Map_rangemap_set_Overlapping_u64_ranges_ranges_closure2(out, rs.iterMap(rs.iterFrom(RangeSet.overlapping$u64_ref_ops_Range_u64(set, range), set_Overlapping.next$iter_Iterator_u64_ref_ops_Range_u64, undefined, { back: (it: set_Overlapping.Overlapping>) => rs.iterFromOption(set_Overlapping.nextBack$iter_DoubleEndedIterator_u64_ref_ops_Range_u64(it)) }), (r12: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r12.start, r12.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + const _113: rs.Range = range.clone(); + putAll$iter_Map_rangemap_map_Overlapping_u64_u64_ops_Range_u64_ranges_ranges_closure3(out, rs.iterMap(rs.iterFrom(RangeMap.overlapping$u64_u64_ops_Range_u64(map, _113), map_Overlapping.next$iter_Iterator_u64_u64_ops_Range_u64, undefined, { back: (it: map_Overlapping.Overlapping>) => rs.iterFromOption(map_Overlapping.nextBack$iter_DoubleEndedIterator_u64_u64_ops_Range_u64(it)) }), (_210: [rs.Range, rs.u64]): [rs.u64, rs.u64, rs.u64] => { + return [_210[0].start, _210[0].end, _210[1]] as [rs.u64, rs.u64, rs.u64]; + })); + const _119: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + putAll$iter_Map_rangemap_inclusive_set_Overlapping_u64_ops_RangeInclusive_u64_ranges_ranges_closure4(out, rs.iterMap(rs.iterFrom(RangeInclusiveSet.overlapping$u64_u64_ops_RangeInclusive_u64(inclusive, _119), inclusive_set_Overlapping.next$iter_Iterator_u64_ops_RangeInclusive_u64, undefined, { back: (it: inclusive_set_Overlapping.Overlapping>) => rs.iterFromOption(inclusive_set_Overlapping.nextBack$iter_DoubleEndedIterator_u64_ops_RangeInclusive_u64(it)) }), (r13: rs.RangeInclusive): [rs.u64, rs.u64, rs.u64] => { + return [rs.rangeInclusiveStart(r13), rs.rangeInclusiveEnd(r13), 0] as [rs.u64, rs.u64, rs.u64]; + })); + const _125: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + putAll$iter_Map_rangemap_inclusive_map_Overlapping_u64_u32_ranges_ranges_closure5(out, rs.iterMap(rs.iterFrom(RangeInclusiveMap.overlapping$u64_u32_u64_ref_ops_RangeInclusive_u64(values, _125), inclusive_map_Overlapping.next$iter_Iterator_u64_u32_ref_ops_RangeInclusive_u64, undefined, { back: (it: inclusive_map_Overlapping.Overlapping>) => rs.iterFromOption(inclusive_map_Overlapping.nextBack$iter_DoubleEndedIterator_u64_u32_ref_ops_RangeInclusive_u64(it)) }), (_214: [rs.RangeInclusive, rs.u32]): [rs.u64, rs.u64, rs.u64] => { + return [rs.rangeInclusiveStart(_214[0]), rs.rangeInclusiveEnd(_214[0]), _214[1] as rs.u64] as [rs.u64, rs.u64, rs.u64]; + })); + rs.byteVecPush(out, RangeSet.overlaps$u64(set, range) ? 1 : 0); + const _136: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + rs.byteVecPush(out, RangeInclusiveMap.overlaps$u64_u32_u64(values, _136) ? 1 : 0); + break b2; + } + if (_32 === 4) { + putAll$iter_Map_rangemap_set_Gaps_u64_ranges_ranges_closure6(out, rs.iterMap(rs.iterFrom(RangeSet.gaps$u64(set, range), set_Gaps.next$iter_Iterator_u64), (r8: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r8.start, r8.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_rangemap_map_Gaps_u64_u64_ranges_ranges_closure7(out, rs.iterMap(rs.iterFrom(RangeMap.gaps$u64_u64(map, range), map_Gaps.next$iter_Iterator_u64_u64), (r9: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r9.start, r9.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + const outer: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + putAll$iter_Map_rangemap_inclusive_set_Gaps_u64_u64_ranges_ranges_closure8(out, rs.iterMap(rs.iterFrom(RangeInclusiveSet.gaps$u64_u64(inclusive, outer), inclusive_set_Gaps.next$iter_Iterator_u64_u64), (r10: rs.RangeInclusive): [rs.u64, rs.u64, rs.u64] => { + return [rs.rangeInclusiveStart(r10), rs.rangeInclusiveEnd(r10), 0] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_rangemap_inclusive_map_Gaps_u64_u32_u64_ranges_ranges_closure9(out, rs.iterMap(rs.iterFrom(RangeInclusiveMap.gaps$u64_u32_u64(values, outer), inclusive_map_Gaps.next$iter_Iterator_u64_u32_u64), (r11: rs.RangeInclusive): [rs.u64, rs.u64, rs.u64] => { + return [rs.rangeInclusiveStart(r11), rs.rangeInclusiveEnd(r11), 0] as [rs.u64, rs.u64, rs.u64]; + })); + break b2; + } + if (_32 === 5) { + const first: rs.Range = option_mapOr$0ntbuih(RangeSet.first$u64(set), new rs.Range(0, 0, rs.u64Step), (a02: rs.Range): rs.Range => { + return a02.clone(); + }); + const last: rs.Range = option_mapOr$0x6k90y(RangeMap.lastRangeValue$u64_u64(map), new rs.Range(0, 0, rs.u64Step), (_29: [rs.Range, rs.u64]): rs.Range => { + return _29[0].clone(); + }); + put(out, first.start, first.end); + put(out, last.start, last.end); + rs.byteVecPush(out, RangeSet.isEmpty$u64(set) ? 1 : 0); + rs.byteVecPush(out, RangeSet.len$u64(set) & 0xff); + rs.byteVecPush(out, RangeMap.len$u64_u64(map) & 0xff); + break b2; + } + if (_32 === 6) { + putAll$iter_Map_iter_Rev_rangemap_set_IntoIter_u64_ranges_ranges_closure11(out, rs.iterMap(rs.iterRev(rs.iterFrom(RangeSet.intoIter$iter_IntoIterator_u64(RangeSet.clone$Clone_u64(set)), set_IntoIter.next$iter_Iterator_u64, undefined, { hint: set_IntoIter.sizeHint$iter_Iterator_u64, back: (it: set_IntoIter.IntoIter) => rs.iterFromOption(set_IntoIter.nextBack$iter_DoubleEndedIterator_u64(it)) })), (r6: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r6.start, r6.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_vec_IntoIter_tuple2_ops_RangeInclusive_u64_u32_ranges_ranges_closure12(out, rs.iterMap(rs.vecIntoIter(rs.iterToVec(rs.iterFrom(RangeInclusiveMap.intoIter$iter_IntoIterator_u64_u32_u64(RangeInclusiveMap.clone$Clone_u64_u32_u64(values)), inclusive_map_IntoIter.next$iter_Iterator_u64_u32, undefined, { hint: inclusive_map_IntoIter.sizeHint$iter_Iterator_u64_u32, back: (it: inclusive_map_IntoIter.IntoIter) => rs.iterFromOption(inclusive_map_IntoIter.nextBack$iter_DoubleEndedIterator_u64_u32(it)) }), "next", 32)), (_2: [rs.RangeInclusive, rs.u32]): [rs.u64, rs.u64, rs.u64] => { + const r7: rs.RangeInclusive = _2[0]; + const v2: rs.u32 = _2[1]; + return [rs.rangeInclusiveStart(r7), rs.rangeInclusiveEnd(r7), v2 as rs.u64] as [rs.u64, rs.u64, rs.u64]; + })); + rs.byteVecPush(out, copyEq(set, map) ? 1 : 0); + break b2; + } + if (_32 === 7) { + if (valid) { + const more: RangeSet.RangeSet = RangeSet.fromIter$iter_FromIterator_ops_Range_u64_u64_array2_ops_Range_u64([range.clone(), new rs.Range(b, rs.u64Add(b, 3), rs.u64Step)]); + const _211: rs.Iter> = rs.iterFilter(rs.iterMap(rs.iterFrom(RangeSet.iter$u64(set), set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) }), (a0: rs.Range): rs.Range => { + return a0.clone(); + }), (r2: rs.Range): boolean => { + return rs.u64Rem(r2.start, 2) === 0; + }); + RangeSet.extend$iter_Extend_ops_Range_u64_u64_iter_Filter_iter_Cloned_rangemap_set_Iter_u64_ranges_ranges_closure13(more, _211); + putAll$iter_Map_rangemap_set_Iter_u64_ranges_ranges_closure14(out, rs.iterMap(rs.iterFrom(RangeSet.iter$u64(more), set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) }), (r3: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r3.start, r3.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_rangemap_operations_Union_ops_Range_u64_rangemap_set_Iter_u64_ranges_ranges_closure15(out, rs.iterMap(rs.iterFrom(RangeSet.union$u64(set, more), operations_Union.next$iter_Iterator_ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64), (r4: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r4.start, r4.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_rangemap_operations_Intersection_ops_Range_u64_rangemap_set_Iter_u64_ranges_ranges_closure16(out, rs.iterMap(rs.iterFrom(RangeSet.intersection$u64(set, more), operations_Intersection.next$iter_Iterator_ops_Range_u64_rangemap_set_Iter_u64_rangemap_set_Iter_u64), (r5: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r5.start, r5.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + break b2; + } + } + } + rs.byteVecPush(out, 253); + } + putAll$iter_Map_rangemap_set_Iter_u64_ranges_ranges_closure17(out, rs.iterMap(rs.iterFrom(RangeSet.iter$u64(set), set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) }), (r14: rs.Range): [rs.u64, rs.u64, rs.u64] => { + return [r14.start, r14.end, 0] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_rangemap_map_Iter_u64_u64_ranges_ranges_closure18(out, rs.iterMap(rs.iterFrom(RangeMap.iter$u64_u64(map), map_Iter.next$iter_Iterator_u64_u64, undefined, { hint: map_Iter.sizeHint$iter_Iterator_u64_u64, back: (it: map_Iter.Iter) => rs.iterFromOption(map_Iter.nextBack$iter_DoubleEndedIterator_u64_u64(it)) }), (_219: [rs.Range, rs.u64]): [rs.u64, rs.u64, rs.u64] => { + return [_219[0].start, _219[0].end, _219[1]] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_rangemap_inclusive_set_Iter_u64_ranges_ranges_closure19(out, rs.iterMap(rs.iterFrom(RangeInclusiveSet.iter$u64_u64(inclusive), inclusive_set_Iter.next$iter_Iterator_u64, undefined, { hint: inclusive_set_Iter.sizeHint$iter_Iterator_u64, back: (it: inclusive_set_Iter.Iter) => rs.iterFromOption(inclusive_set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) }), (r15: rs.RangeInclusive): [rs.u64, rs.u64, rs.u64] => { + return [rs.rangeInclusiveStart(r15), rs.rangeInclusiveEnd(r15), 0] as [rs.u64, rs.u64, rs.u64]; + })); + putAll$iter_Map_rangemap_inclusive_map_Iter_u64_u32_ranges_ranges_closure20(out, rs.iterMap(rs.iterFrom(RangeInclusiveMap.iter$u64_u32_u64(values), inclusive_map_Iter.next$iter_Iterator_u64_u32, undefined, { hint: inclusive_map_Iter.sizeHint$iter_Iterator_u64_u32, back: (it: inclusive_map_Iter.Iter) => rs.iterFromOption(inclusive_map_Iter.nextBack$iter_DoubleEndedIterator_u64_u32(it)) }), (_222: [rs.RangeInclusive, rs.u32]): [rs.u64, rs.u64, rs.u64] => { + return [rs.rangeInclusiveStart(_222[0]), rs.rangeInclusiveEnd(_222[0]), _222[1] as rs.u64] as [rs.u64, rs.u64, rs.u64]; + })); + } +} + +/** Whether the set holds just the ranges the map does. */ +export function copyEq(set: RangeSet.RangeSet, map: RangeMap.RangeMap): boolean { + const _3: set_Iter.Iter = RangeSet.iter$u64(set); + const _4: rs.Iter> = rs.iterMap(rs.iterFrom(RangeMap.iter$u64_u64(map), map_Iter.next$iter_Iterator_u64_u64, undefined, { hint: map_Iter.sizeHint$iter_Iterator_u64_u64, back: (it: map_Iter.Iter) => rs.iterFromOption(map_Iter.nextBack$iter_DoubleEndedIterator_u64_u64(it)) }), (_2: [rs.Range, rs.u64]): rs.Range => { + return _2[0]; + }); + return rs.iterEq(rs.iterFrom(_3, set_Iter.next$iter_Iterator_u64, undefined, { hint: set_Iter.sizeHint$iter_Iterator_u64, back: (it: set_Iter.Iter) => rs.iterFromOption(set_Iter.nextBack$iter_DoubleEndedIterator_u64(it)) }), _4, rs.rangeEq(rs.u64Eq)); +} + +//# sourceMappingURL=ranges.ts.map diff --git a/ts/fixtures/stock/src/harness.rs b/ts/fixtures/stock/src/harness.rs index 4cbf079b3..ec6baae8c 100644 --- a/ts/fixtures/stock/src/harness.rs +++ b/ts/fixtures/stock/src/harness.rs @@ -36,6 +36,7 @@ fn cases() -> Vec<(&'static str, Case)> { ("buf::reclaims", crate::buf::reclaims), ("buf::vec_spares", crate::buf::vec_spares), ("buf::chunks", crate::buf::chunks), + ("ranges", crate::ranges::ranges), ] } diff --git a/ts/fixtures/stock/src/lib.rs b/ts/fixtures/stock/src/lib.rs index 021ce541f..bd8e048a4 100644 --- a/ts/fixtures/stock/src/lib.rs +++ b/ts/fixtures/stock/src/lib.rs @@ -1,12 +1,13 @@ //! Calls into `bytes`, `hashbrown`, `rand`, and `tracing`, which translation maps itself, -//! and into `hashlink`, which translates over `hashbrown`, so this config binds and leaves -//! out nothing. +//! into `hashlink`, which translates over `hashbrown`, and into `rangemap`, which translates +//! over std's B-tree, so this config binds and leaves out nothing. //! //! `harness::run` is the entry point both sides of the differential test run. mod buf; pub mod harness; mod maps; +mod ranges; #[cfg(target_arch = "wasm32")] #[path = "../../wasm.rs"] mod wasm; diff --git a/ts/fixtures/stock/src/ranges.rs b/ts/fixtures/stock/src/ranges.rs new file mode 100644 index 000000000..c5249ca25 --- /dev/null +++ b/ts/fixtures/stock/src/ranges.rs @@ -0,0 +1,123 @@ +//! `rangemap`'s maps and sets, which translate from their source over std's B-tree, keyed +//! by a wrapper of a range's start that its B-tree searches by a wrapper of its end. + +use std::ops::Range; + +use rangemap::{RangeInclusiveMap, RangeInclusiveSet, RangeMap, RangeSet}; + +/// A range's bounds, as eight bytes. +fn put(out: &mut Vec, start: u64, end: u64) { + out.extend_from_slice(&(start as u32).to_le_bytes()); + out.extend_from_slice(&(end as u32).to_le_bytes()); +} + +/// Each range of `ranges`, then a marker. +fn put_all<'a>(out: &mut Vec, ranges: impl Iterator) { + for (start, end, value) in ranges { + put(out, start, end); + out.push(value as u8); + } + out.push(0xff); +} + +/// A `RangeSet` and a `RangeMap` of `u64`, and their inclusive twins, through each triple +/// of bytes: a step, then a range's bounds, which may be empty or backwards. Each step +/// writes what it reads, then each collection's ranges. +pub fn ranges(data: &[u8], out: &mut Vec) { + let mut set: RangeSet = RangeSet::new(); + let mut map: RangeMap = RangeMap::new(); + let mut inclusive: RangeInclusiveSet = RangeInclusiveSet::new(); + let mut values: RangeInclusiveMap = RangeInclusiveMap::new(); + for step in data.chunks(3) { + let op = step[0]; + let (a, b) = ( + u64::from(step.get(1).copied().unwrap_or(0)), + u64::from(step.get(2).copied().unwrap_or(0)), + ); + let range: Range = a..b; + let valid = a < b; + match op % 8 { + 0 if valid => { + set.insert(range.clone()); + map.insert(range, u64::from(op)); + inclusive.insert(a..=b - 1); + values.insert(a..=b - 1, u32::from(op)); + } + 1 if valid => { + set.remove(range.clone()); + map.remove(range); + inclusive.remove(a..=b - 1); + values.remove(a..=b - 1); + } + 2 => { + out.push(set.contains(&a) as u8); + out.push(map.get(&a).map_or(0xfe, |&v| v as u8)); + out.push(inclusive.contains(&b) as u8); + let (r, v) = values + .get_key_value(&b) + .map_or((0..0, 0xfe), |(r, v)| (*r.start()..*r.end(), *v)); + put(out, r.start, r.end); + out.push(v as u8); + let got = set.get(&b).map_or(0..0, Range::clone); + put(out, got.start, got.end); + } + 3 => { + put_all(out, set.overlapping(&range).map(|r| (r.start, r.end, 0))); + put_all(out, map.overlapping(range.clone()).map(|(r, v)| (r.start, r.end, *v))); + put_all(out, inclusive.overlapping(a..=b).map(|r| (*r.start(), *r.end(), 0))); + put_all( + out, + values + .overlapping(&(a..=b)) + .map(|(r, v)| (*r.start(), *r.end(), u64::from(*v))), + ); + out.push(set.overlaps(&range) as u8); + out.push(values.overlaps(&(a..=b)) as u8); + } + 4 => { + put_all(out, set.gaps(&range).map(|r| (r.start, r.end, 0))); + put_all(out, map.gaps(&range).map(|r| (r.start, r.end, 0))); + let outer = a..=b; + put_all(out, inclusive.gaps(&outer).map(|r| (*r.start(), *r.end(), 0))); + put_all(out, values.gaps(&outer).map(|r| (*r.start(), *r.end(), 0))); + } + 5 => { + let first = set.first().map_or(0..0, Range::clone); + let last = map.last_range_value().map_or(0..0, |(r, _)| r.clone()); + put(out, first.start, first.end); + put(out, last.start, last.end); + out.push(set.is_empty() as u8); + out.push(set.len() as u8); + out.push(map.len() as u8); + } + 6 => { + let copy = set.clone(); + put_all(out, copy.into_iter().rev().map(|r| (r.start, r.end, 0))); + let pairs: Vec<_> = values.clone().into_iter().collect(); + put_all( + out, + pairs.into_iter().map(|(r, v)| (*r.start(), *r.end(), u64::from(v))), + ); + out.push((copy_eq(&set, &map)) as u8); + } + 7 if valid => { + let mut more = RangeSet::from_iter([range.clone(), b..b + 3]); + more.extend(set.iter().cloned().filter(|r| r.start % 2 == 0)); + put_all(out, more.iter().map(|r| (r.start, r.end, 0))); + put_all(out, set.union(&more).map(|r| (r.start, r.end, 0))); + put_all(out, set.intersection(&more).map(|r| (r.start, r.end, 0))); + } + // An empty range to insert or remove, which rangemap panics on. + _ => out.push(0xfd), + } + put_all(out, set.iter().map(|r| (r.start, r.end, 0))); + put_all(out, map.iter().map(|(r, v)| (r.start, r.end, *v))); + put_all(out, inclusive.iter().map(|r| (*r.start(), *r.end(), 0))); + put_all(out, values.iter().map(|(r, v)| (*r.start(), *r.end(), u64::from(*v)))); + } +} + +/// Whether the set holds just the ranges the map does. +fn copy_eq(set: &RangeSet, map: &RangeMap) -> bool { + set.iter().eq(map.iter().map(|(r, _)| r)) +} diff --git a/ts/runtime/rs/collections.ts b/ts/runtime/rs/collections.ts index 93b77cf1d..f8bed2d47 100644 --- a/ts/runtime/rs/collections.ts +++ b/ts/runtime/rs/collections.ts @@ -1491,11 +1491,34 @@ export function btreeNew(cmp: (a: NoInfer, b: NoInfer) => Ordering): */ let idx = 0; +/** + * A key of another type `Q`, which a B-tree's keys borrow as, that it is searched by as + * std's search by a `Borrow` form is: by `Q`'s `Ord::cmp` of it against each key's `borrow`. + */ +export class By { + readonly q: unknown; + /** `Q`'s `Ord::cmp`. */ + readonly cmp: (a: unknown, b: unknown) => Ordering; + /** `Q`'s `Ord::cmp` of a `Q` against a key's `borrow`. */ + readonly c: (q: unknown, k: K) => Ordering; + + constructor(q: unknown, cmp: (a: unknown, b: unknown) => Ordering, c: (q: unknown, k: K) => Ordering) { + this.q = q; + this.cmp = cmp; + this.c = c; + } +} + +/** `q`, a key or a range of keys of type `Q`, by `Q`'s `cmp` against each key `K`'s `borrow`. */ +export function by(q: NoInfer>, cmp: (a: Q, b: Q) => Ordering, borrow: (k: K) => Q): By { + return new By(q, cmp as (a: unknown, b: unknown) => Ordering, (q, k) => cmp(q as Q, borrow(k))); +} + /** * std's `find_key_index`: the index of the first of `n`'s keys from `from` on that `key` is * not greater than, by `key.cmp(k)`, if equal, or else the bitwise not of the edge before it. */ -function find(cmp: (a: K, b: K) => Ordering, n: Node, key: K, from = 0): number { +function find(cmp: (a: Q, b: K) => Ordering, n: Node, key: Q, from = 0): number { const keys = n.k; const len = keys.length; for (let i = from; i < len; i++) { @@ -1511,7 +1534,16 @@ function find(cmp: (a: K, b: K) => Ordering, n: Node, key: K, from = * the leaf it would go in, with `idx` the bitwise not of the edge it goes at. */ function seek(m: BTreeMap, key: K): Node { - const cmp = m.c; + return seekBy(m, m.c, key); +} + +/** `seek` by `key`, or by what a `By` holds, as std's lookups search by a `Borrow` form. */ +function lookup(m: BTreeMap, key: K | By): Node { + return key instanceof By ? seekBy(m, key.c, key.q) : seekBy(m, m.c, key); +} + +/** `seek` by `cmp`, of `key` against each key. */ +function seekBy(m: BTreeMap, cmp: (a: Q, b: K) => Ordering, key: Q): Node { let n = m.t; for (;;) { const i = find(cmp, n, key); @@ -1559,30 +1591,30 @@ export function btreeLen(m: BTreeMap): number { } /** `BTreeMap::get`: the value there, or else `none`, the `None` of an `Option` of a value that can be `undefined`. */ -export function btreeGet(m: BTreeMap, key: K): V | undefined; -export function btreeGet(m: BTreeMap, key: K, none: None): V | None; -export function btreeGet(m: BTreeMap, key: K, none?: None): V | None | undefined { - const n = seek(m, key); +export function btreeGet(m: BTreeMap, key: K | By): V | undefined; +export function btreeGet(m: BTreeMap, key: K | By, none: None): V | None; +export function btreeGet(m: BTreeMap, key: K | By, none?: None): V | None | undefined { + const n = lookup(m, key); return idx < 0 ? none : n.v[idx]; } /** `BTreeMap::get_mut` of a value JS copies: its place, if the map holds `key`. */ -export function btreeGetMut(m: BTreeMap, key: K): Place | undefined { - const n = seek(m, key); +export function btreeGetMut(m: BTreeMap, key: K | By): Place | undefined { + const n = lookup(m, key); return idx < 0 ? undefined : new AtIndex(n.v, idx); } /** `BTreeMap::get_key_value`: the equal key the map holds, and its value. */ -export function btreeGetKeyValue(m: BTreeMap, key: K): [K, V] | undefined { - const n = seek(m, key); +export function btreeGetKeyValue(m: BTreeMap, key: K | By): [K, V] | undefined { + const n = lookup(m, key); return idx < 0 ? undefined : [n.k[idx], n.v[idx]]; } /** `BTreeSet::get`, and `BTreeSet::take` if `take`: the equal key the set holds, or else `none`. */ -export function btreeKey(m: BTreeMap, key: K, take?: boolean): K | undefined; -export function btreeKey(m: BTreeMap, key: K, take: boolean, none: None): K | None; -export function btreeKey(m: BTreeMap, key: K, take = false, none?: None): K | None | undefined { - const n = seek(m, key); +export function btreeKey(m: BTreeMap, key: K | By, take?: boolean): K | undefined; +export function btreeKey(m: BTreeMap, key: K | By, take: boolean, none: None): K | None; +export function btreeKey(m: BTreeMap, key: K | By, take = false, none?: None): K | None | undefined { + const n = lookup(m, key); const i = idx; if (i < 0) return none; const held = n.k[i]; @@ -1605,14 +1637,14 @@ export function btreeReplace(m: BTreeSet, key: K, none?: None): K | None | return old; } -export function btreeContains(m: BTreeMap, key: K): boolean { - seek(m, key); +export function btreeContains(m: BTreeMap, key: K | By): boolean { + lookup(m, key); return idx >= 0; } /** `BTreeMap::index`: `map[&key]`. */ -export function btreeIndex(m: BTreeMap, key: K, at?: Location): V { - const n = seek(m, key); +export function btreeIndex(m: BTreeMap, key: K | By, at?: Location): V { + const n = lookup(m, key); if (idx < 0) panic("no entry found for key", at, true); return n.v[idx]; } @@ -1908,8 +1940,8 @@ function append(a: T[], b: T[], from: number): void { } /** `BTreeMap::remove_entry`. */ -export function btreeRemoveEntry(m: BTreeMap, key: K): [K, V] | undefined { - const n = seek(m, key); +export function btreeRemoveEntry(m: BTreeMap, key: K | By): [K, V] | undefined { + const n = lookup(m, key); const i = idx; if (i < 0) return undefined; const entry: [K, V] = [n.k[i], n.v[i]]; @@ -1918,10 +1950,10 @@ export function btreeRemoveEntry(m: BTreeMap, key: K): [K, V] | unde } /** `BTreeMap::remove`: the value there, whose key drops, or else `none`. */ -export function btreeRemove(m: BTreeMap, key: K, k?: (key: K) => void): V | undefined; -export function btreeRemove(m: BTreeMap, key: K, k: ((key: K) => void) | undefined, none: None): V | None; -export function btreeRemove(m: BTreeMap, key: K, k?: (key: K) => void, none?: None): V | None | undefined { - const n = seek(m, key); +export function btreeRemove(m: BTreeMap, key: K | By, k?: (key: K) => void): V | undefined; +export function btreeRemove(m: BTreeMap, key: K | By, k: ((key: K) => void) | undefined, none: None): V | None; +export function btreeRemove(m: BTreeMap, key: K | By, k?: (key: K) => void, none?: None): V | None | undefined { + const n = lookup(m, key); const i = idx; if (i < 0) return none; const held = n.k[i]; @@ -1932,8 +1964,8 @@ export function btreeRemove(m: BTreeMap, key: K, k?: (key: K) => voi } /** `BTreeSet::remove`: whether `key` was there. The key it held drops. */ -export function btreeDelete(m: BTreeSet, key: K, k?: (key: K) => void): boolean { - const n = seek(m, key); +export function btreeDelete(m: BTreeSet, key: K | By, k?: (key: K) => void): boolean { + const n = lookup(m, key); const i = idx; if (i < 0) return false; const held = n.k[i]; @@ -2065,16 +2097,17 @@ export function btreeClear(m: BTreeMap, k?: (key: K) => void, v?: (v * the path to it into a column of empty nodes, whose borders then even out. Like std's, * the new tree has a root unless `m` was empty. */ -export function btreeSplitOff(m: BTreeMap, key: K): BTreeMap { +export function btreeSplitOff(m: BTreeMap, key: K | By): BTreeMap { const out = btreeNew(m.c); if (m.n === 0) return out; + const [cmp, q] = key instanceof By ? [key.c, key.q] : [m.c as (a: unknown, b: K) => Ordering, key]; out.t = pillar(m.h); out.h = m.h; out.r = true; let left = m.t; let right = out.t; for (;;) { - const i = find(m.c, left, key); + const i = find(cmp, left, q); const cut = i < 0 ? ~i : i; right.k = left.k.splice(cut); right.v = left.v.splice(cut); @@ -2346,21 +2379,28 @@ function bounds(r: Bounds): BoundPair { } /** - * `BTreeMap::range` and `range_mut`: the entries within `r`. A key of the crate's own gives - * its `PartialEq::eq` and `PartialOrd::gt`, which std checks the ends by. + * `BTreeMap::range` and `range_mut`: the entries within `r`, or within the range of another + * type a `By` holds. A key of the crate's own gives its `PartialEq::eq` and + * `PartialOrd::gt`, which std checks the ends by. */ -export function btreeRange(m: BTreeMap, r: NoInfer>>, eq?: Test, gt?: Test): Iter<[K, V]> { - return range(m, r as Bounds, ENTRIES, "BTreeMap", eq, gt); +export function btreeRange(m: BTreeMap, r: NoInfer>>, eq?: Test, gt?: Test): Iter<[K, V]>; +export function btreeRange(m: BTreeMap, r: By, eq?: Test, gt?: Test): Iter<[K, V]>; +export function btreeRange(m: BTreeMap, r: Bounds | By, eq?: Test, gt?: Test): Iter<[K, V]> { + return range(m, r, ENTRIES, "BTreeMap", eq, gt); } /** `range_mut` of values JS copies: each key within `r` and the place of its value. */ -export function btreeRangeMut(m: BTreeMap, r: NoInfer>>, eq?: Test, gt?: Test): Iter<[K, Place]> { - return range(m, r as Bounds, PLACES, "BTreeMap", eq, gt); +export function btreeRangeMut(m: BTreeMap, r: NoInfer>>, eq?: Test, gt?: Test): Iter<[K, Place]>; +export function btreeRangeMut(m: BTreeMap, r: By, eq?: Test, gt?: Test): Iter<[K, Place]>; +export function btreeRangeMut(m: BTreeMap, r: Bounds | By, eq?: Test, gt?: Test): Iter<[K, Place]> { + return range(m, r, PLACES, "BTreeMap", eq, gt); } /** `BTreeSet::range`: the keys within `r`. */ -export function btreeRangeKeys(m: BTreeMap, r: NoInfer>>, eq?: Test, gt?: Test): Iter { - return range(m, r as Bounds, KEYS, "BTreeSet", eq, gt); +export function btreeRangeKeys(m: BTreeMap, r: NoInfer>>, eq?: Test, gt?: Test): Iter; +export function btreeRangeKeys(m: BTreeMap, r: By, eq?: Test, gt?: Test): Iter; +export function btreeRangeKeys(m: BTreeMap, r: Bounds | By, eq?: Test, gt?: Test): Iter { + return range(m, r, KEYS, "BTreeSet", eq, gt); } /** @@ -2370,26 +2410,30 @@ export function btreeRangeKeys(m: BTreeMap, r: NoInfer type Key = K | (K extends (infer E)[] ? Slice : never); /** - * The items of `m` within `r`, checked as std checks it: by `eq` and `gt`, or by `m`'s - * order. Its ends are found as std's `find_leaf_edges_spanning_range` finds them: down one - * path while both lie below the same edge, then each down its own. + * The items of `m` within `r`, checked as std checks it: by `eq` and `gt`, or by the order + * of its keys, `m`'s or a `By`'s. Its ends are found as std's + * `find_leaf_edges_spanning_range` finds them: down one path while both lie below the same + * edge, then each down its own. */ -function range(m: BTreeMap, r: Bounds, pick: Pick, name: string, eq?: Test, gt?: Test): Iter { +function range(m: BTreeMap, r: Bounds | By, pick: Pick, name: string, eq?: Test, gt?: Test): Iter { if (!m.r) return new BTreeIter(pick, m.t, 0, m.t, 0); - const [start, stop] = bounds(r); + const by = r instanceof By ? r : undefined; + const order = (by?.cmp ?? m.c) as (a: unknown, b: unknown) => Ordering; + const cmp = (by?.c ?? m.c) as (a: unknown, b: K) => Ordering; + const [start, stop] = bounds((by === undefined ? r : by.q) as Bounds); if (start.tag !== "Unbounded" && stop.tag !== "Unbounded") { const s = start._0; const e = stop._0; - if (start.tag === "Excluded" && stop.tag === "Excluded" && (eq === undefined ? m.c(s, e) === 0 : eq(s, e))) { + if (start.tag === "Excluded" && stop.tag === "Excluded" && (eq === undefined ? order(s, e) === 0 : eq(s, e))) { panic(`range start and end are equal and excluded in ${name}`, `btree_range_equal_${name}`); } - if (gt === undefined ? m.c(s, e) > 0 : gt(s, e)) panic(`range start is greater than range end in ${name}`, `btree_range_order_${name}`); + if (gt === undefined ? order(s, e) > 0 : gt(s, e)) panic(`range start is greater than range end in ${name}`, `btree_range_order_${name}`); } const lo = side(start); const hi = side(stop); for (let n = m.t; ; ) { - const fi = lower(m.c, n, lo); - const bi = upper(m.c, n, hi, fi); + const fi = lower(cmp, n, lo); + const bi = upper(cmp, n, hi, fi); if (fi < bi) { let fl = n; let bl = n; @@ -2397,9 +2441,9 @@ function range(m: BTreeMap, r: Bounds, pick: Pick, name: strin let b = bi; while (fl.e !== undefined) { fl = fl.e[f]; - f = lower(m.c, fl, lo); + f = lower(cmp, fl, lo); bl = (bl.e as Node[])[b]; - b = upper(m.c, bl, hi, 0); + b = upper(cmp, bl, hi, 0); } return new BTreeIter(pick, fl, f, bl, b); } @@ -2426,10 +2470,10 @@ function side(b: RangeBound): Side { } /** std's `find_lower_bound_index`: the edge of `n` a range from `s` starts at, narrowing `s` for the child below it. */ -function lower(cmp: (a: K, b: K) => Ordering, n: Node, s: Side): number { +function lower(cmp: (a: Q, b: K) => Ordering, n: Node, s: Side): number { if (s.tag === ALL_INCLUDED) return 0; if (s.tag === ALL_EXCLUDED) return n.k.length; - const i = find(cmp, n, s.key as K); + const i = find(cmp, n, s.key as Q); if (i < 0) return ~i; if (s.tag === INCLUDED) { s.tag = ALL_EXCLUDED; @@ -2440,10 +2484,10 @@ function lower(cmp: (a: K, b: K) => Ordering, n: Node, s: Side): } /** std's `find_upper_bound_index`: the edge of `n` from `from` on that a range to `s` ends at, narrowing `s` likewise. */ -function upper(cmp: (a: K, b: K) => Ordering, n: Node, s: Side, from: number): number { +function upper(cmp: (a: Q, b: K) => Ordering, n: Node, s: Side, from: number): number { if (s.tag === ALL_INCLUDED) return n.k.length; if (s.tag === ALL_EXCLUDED) return from; - const i = find(cmp, n, s.key as K, from); + const i = find(cmp, n, s.key as Q, from); if (i < 0) return ~i; if (s.tag === INCLUDED) { s.tag = ALL_EXCLUDED; diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index 86ff10302..b70094fdb 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -250,11 +250,14 @@ pub fn call<'tcx>( // or a range's bounds, stands in as it is, as JS reads it as an owned `Cow`. An `Arc`'s // are its value's, so the value it is looked up by stands in as an `Arc` of it, which // the collection only compares. + // A B-tree searches by what the crate's own `Borrow` lends of each key, which + // `btree` gives it. + let lent = matches!(std, Std::BTreeMap | Std::BTreeSet) && own_borrow(b, key, by); let key = peel(b, key); let cow = cow_of(b, key).is_some_and(|borrowed| same_key(b, borrowed, by)); let arc = arc_of(b, key).is_some_and(|inner| same_key(b, inner, by)); match args.get_mut(1) { - _ if cow => {} + _ if cow || lent => {} Some(key) if arc && !matches!(name, "range" | "range_mut") => { let value = std::mem::replace(key, Expr::undefined()); *key = Expr::New(Box::new(Expr::Rs("Arc".into())), vec![value]); @@ -414,6 +417,17 @@ fn lookup_ty<'tcx>(b: &Body<'_, '_, 'tcx>, std: Std, call: &Call<'tcx>, owner: & } } +/// Whether `>::borrow` is the crate's own, so a search by a `by` orders +/// what it lends of each key, as std's does. +fn own_borrow<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { + let tcx = b.t.tcx; + let f = trait_fn(tcx, "Borrow", "borrow"); + Instance::try_resolve(tcx, b.t.typing_env_pub(), f, tcx.mk_args(&[key.into(), by.into()])) + .ok() + .flatten() + .is_some_and(|instance| b.t.own(instance.def_id())) +} + /// Whether a key of type `by` is a JS value that hashes, compares, and orders as one of /// type `key` does: the same type through references and boxes, or a string either way. fn same_key<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { @@ -1492,6 +1506,22 @@ fn btree<'tcx>( values.push(test_fn(b, target, "gt", span)); } } + // A key, or a range of keys, of a type each key lends by the crate's own `Borrow`, which + // is searched by that type's `Ord` against what each key lends. + if let Some(by) = b.t.std_of(coll).and_then(|std| lookup_ty(b, std, call, owner, name)) + && own_borrow(b, key, by) + && let Some(at) = values.get_mut(1) + { + let tcx = b.t.tcx; + let at = std::mem::replace(at, Expr::undefined()); + let cmp = cmp_fn(b, by, false, span); + let borrow = b.fn_value( + trait_fn(tcx, "Borrow", "borrow"), + tcx.mk_args(&[key.into(), by.into()]), + span, + ); + values[1] = Expr::rs("by", vec![at, cmp, borrow]); + } // It holds the range, reads its end at each key it reads, and checks each key against // the end by `<=` or `<`, which a key of the crate's own does by its `PartialOrd`. if name == "extract_if" { diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 15d260fc4..c1b8d21c5 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -38,12 +38,14 @@ pub fn is_next(tcx: ty::TyCtxt<'_>, def_id: DefId) -> bool { impl<'tcx> Translator<'_, 'tcx> { /// `Iterator::Item` of `ty`, if `ty` is an iterator. A type over parameters, which a - /// generic type's fields and a census have, may leave it a projection. + /// generic type's fields and a census have, may leave it a projection; a field's + /// normalizes by its type's bounds. pub fn iter_item(&self, ty: Ty<'tcx>) -> Option> { let tcx = self.tcx; let (_, item) = trait_items(tcx)?; let projection = Ty::new_projection(tcx, ty::IsRigid::No, item, [ty]); - tcx.try_normalize_erasing_regions(self.typing_env_pub(), ty::Unnormalized::new_wip(projection)) + let env = self.defining.unwrap_or(self.typing_env_pub()); + tcx.try_normalize_erasing_regions(env, ty::Unnormalized::new_wip(projection)) .ok() } diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index e110030e1..92ad829a0 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -197,8 +197,8 @@ pub struct Translator<'a, 'tcx> { adts: rustc_data_structures::fx::FxHashMap, /// The fields of generic types whose definition types a form only an instance decides, /// such as an `rs.Ptr` or an `rs.VecOf`, which an instance's read casts to what it - /// holds, with that type where a function type in it takes one, which an instance's - /// value is cast to. + /// holds, with that type where a function type or a type argument in it takes one, + /// which an instance's value is cast to. instanced_fields: rustc_data_structures::fx::FxHashMap>, /// Source files by name, as indexes into `program.sources`. sources: rustc_data_structures::fx::FxHashMap>, @@ -206,6 +206,9 @@ pub struct Translator<'a, 'tcx> { /// Where trait bounds come from: none outside a census, which lowers some functions /// over their own type parameters. env: TypingEnv<'tcx>, + /// Where the bounds of a generic type's parameters come from while its fields lower, by + /// which an iterator's item type over them normalizes. + defining: Option>, /// Whether this is a census, which lowers some functions over their type parameters and /// writes nothing. census: bool, @@ -499,6 +502,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { sources: Default::default(), failed: false, env: TypingEnv::fully_monomorphized(), + defining: None, census, refusals: Some(Vec::new()), capacity_reads: Vec::new(), @@ -1918,8 +1922,11 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { // A projection it names, such as `::Hasher` of a known `S`, is the // type it normalizes to. let identity = ty::GenericArgs::identity_for_item(tcx, adt); - let ty = copy::field_ty(tcx, TypingEnv::post_analysis(tcx, adt), field.did, identity); + let env = TypingEnv::post_analysis(tcx, adt); + let ty = copy::field_ty(tcx, env, field.did, identity); + let outer = self.defining.replace(env); let ty = self.ty(ty, span); + self.defining = outer; if ty.any(&instanced) { self.instanced_fields .insert(field.did, ty.takes(&instanced).then(|| ty.clone())); @@ -1928,8 +1935,9 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// `value`, for `field` of an instance of `adt` with `args`, cast to the field's type in - /// the definition at those arguments where a function type in it takes a form only an - /// instance decides: a function taking what the instance holds takes no other form. + /// the definition at those arguments where a function type or a type argument in it + /// takes a form only an instance decides: a function taking what the instance holds, or + /// a generic type over it, takes no other form. pub fn field_value( &mut self, value: ts::Expr, diff --git a/ts/src/ts.rs b/ts/src/ts.rs index 6a7ee0397..41dfed5ed 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -694,11 +694,13 @@ impl Type { self.any(&|t| matches!(t, Type::Param(name) if name == param)) } - /// Whether a function type in it takes a parameter holding a type `f` picks. + /// Whether a type `f` picks is where TypeScript takes no other: in a function type's + /// parameter, or in a type argument of a generic type. pub fn takes(&self, f: &impl Fn(&Type) -> bool) -> bool { match self { Type::Func(params, ret) => params.iter().any(|t| t.any(f)) || ret.takes(f), Type::Param(_) | Type::Builtin(_) | Type::StrLit(_) => false, + Type::Rs(_, tys) | Type::Sym(_, tys) if !f(self) => tys.iter().any(|t| t.any(f)), Type::Rs(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { tys.iter().any(|t| t.takes(f)) }