Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion quest/m3/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -26,5 +26,5 @@ generic std gap is planned here even when moq never calls it.
- [Binding gaps](/quest/m3/ts-bind-gaps.md) - bound types as keys, unit returns checked, renamed dependencies
- [Drop order in std's folds and iterators](/quest/m3/ts-drop-order.md) - the values that drop still refused in std's folds, zips, flattens, and collects drop as std's do
- [Slice windows and chunks, Vec drain, and the order of byte arrays](/quest/m3/ts-slice-gaps.md) - `windows`, `chunks`, `Vec::drain`, and byte arrays' order translate
- [Return a std iterator's next from a generic function](/quest/m3/ts-next-return.md) - `it.next()` returned from a generic function is an `Option`, as `tsc` expects
- [Iterator consumers over items whose None is rt.None](/quest/m3/ts-option-items.md) - `nth`, `last`, and `find` of an iterator of `Option` keep `None` apart from `Some(None)`
- [Port the workflow guard to kixelated/quest](/quest/m3/quest-workflow-guard.md) - quest's environment guard parses YAML as this repository's does
15 changes: 0 additions & 15 deletions quest/m3/ts-next-return.md

This file was deleted.

17 changes: 17 additions & 0 deletions quest/m3/ts-option-items.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
# [S] Iterator consumers over items whose None is rt.None

## Goal

`nth`, `last`, `find`, `max`, `min`, and std's other iterator consumers that return an
`Option` of the item translate over an iterator whose item's `None` is `rt.None`, such as
`Option<u8>`, keeping `None` apart from `Some(None)`, proven by a differential test against
native Rust.

## Plan

Found while fixing a returned `next` on 2026-10-30: `it.nth(n)` and `it.last()` of an
iterator of `Option<u8>` are refused at their span, as `src/lower/library.rs`'s
`takes_none` lists only `next`, `next_back`, and `nth_back` among iterator methods.
Each runtime consumer needs the item's `None` passed in, as `rt.iterToOption` takes it.

Public API: the translator's output.
7 changes: 7 additions & 0 deletions ts/fixtures/lang/expected/core/option.ts
Original file line number Diff line number Diff line change
Expand Up @@ -564,6 +564,13 @@ export function mapOr$Option_Vec_u8_u8_library_closure5(self: rt.ByteVec | undef
return f(self);
}

export function mapOr$Option_char_u32_from(self: rt.char | undefined, default_: rt.u32, _: (a0: rt.char) => rt.u32): rt.u32 {
if (self === undefined) {
return default_;
}
return self as rt.u32;
}

export function mapOr$Option_u16_u16_edits_closure21(self: rt.u16 | undefined, default_: rt.u16, f: (a0: rt.u16) => rt.u16): rt.u16 {
if (self === undefined) {
return default_;
Expand Down
7 changes: 7 additions & 0 deletions ts/fixtures/lang/expected/core/result.ts
Original file line number Diff line number Diff line change
Expand Up @@ -207,6 +207,13 @@ export function unwrapOr$Result_isize_isize(self: rt.Result<rt.isize, rt.isize>,
return default_;
}

export function unwrapOr$Result_str_Utf8Error(self: rt.Result<string, rt.Utf8Error>, default_: string): string {
if (self.ok) {
return self.value;
}
return default_;
}

export function unwrapOr$Result_u16_TryFromIntError(self: rt.Result<rt.u16, rt.TryFromIntError>, default_: rt.u16): rt.u16 {
if (self.ok) {
return self.value;
Expand Down
4 changes: 3 additions & 1 deletion ts/fixtures/lang/expected/harness.ts
Original file line number Diff line number Diff line change
Expand Up @@ -22,7 +22,7 @@ import { ints, strings, derived, written, counts, rounding, panics, wrapped } fr
import { methods } from "./generics.ts";
import { holds } from "./holds.ts";
import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert } from "./ints.ts";
import { adaptors, consumers, skips, ranked, ranges, options, own, values } from "./iters.ts";
import { adaptors, consumers, skips, ranked, ranges, options, own, values, returned } from "./iters.ts";
import { keys, overrides } from "./keys.ts";
import { locals } from "./locals.ts";
import { locks, relock, rwlocks } from "./locks.ts";
Expand Down Expand Up @@ -153,6 +153,8 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec)
copies(data53, out54);
}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["statics::cells", (_2154: rt.u8, data54: rt.ByteSlice, out55: rt.ByteVec): void => {
statics_cells(data54, out55);
}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void], ["iters::returned", (_2155: rt.u8, data55: rt.ByteSlice, out56: rt.ByteVec): void => {
returned(data55, out56);
}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => void]]).map(copy$str_forabfnu8au8bmutstdvecVecu8);
}

Expand Down
159 changes: 158 additions & 1 deletion ts/fixtures/lang/expected/iters.ts
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,8 @@
import * as rt from "./rt.ts";
import { copy$Bumped, copy$Option_u8_Reverse_Option_u8, copy$Option_usize_u8, copy$u8_u8 } from "./lib.ts";
import { thenSome$bool_u16, thenSome$bool_u8 } from "./core/bool.ts";
import { unwrapOr$Option_NonZero_u64, unwrapOr$Option_i64, unwrapOr$Option_u8, unwrapOr$Option_usize_u8, map$Option_u8_u8_elements_closure8, mapOr$Option_Tilt_u8_ranked_closure11_closure0, mapOr$Option_Vec_u16_u8_consumers_closure23, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOr$Option_u8_usize_iters_closure1, mapOr$Option_u8s_u8_skips_closure44, mapOr$Option_usize_u8_consumers_closure8, mapOr$Option_usize_u8_u8_heaps_closure0, filter$Option_u8_combinators_closure0 } from "./core/option.ts";
import { unwrapOr$Option_NonZero_u64, unwrapOr$Option_i64, unwrapOr$Option_u8, unwrapOr$Option_usize_u8, map$Option_u8_u8_elements_closure8, mapOr$Option_Tilt_u8_ranked_closure11_closure0, mapOr$Option_Vec_u16_u8_consumers_closure23, mapOr$Option_char_u32_from, mapOr$Option_u8_u8_btree_maps_closure5, mapOr$Option_u8_u8_u8_btree_maps_closure0, mapOr$Option_u8_usize_iters_closure1, mapOr$Option_u8s_u8_skips_closure44, mapOr$Option_usize_u8_consumers_closure8, mapOr$Option_usize_u8_u8_heaps_closure0, filter$Option_u8_combinators_closure0 } from "./core/option.ts";
import { unwrapOr$Result_str_Utf8Error } from "./core/result.ts";
import * as Bumped from "./iters.Bumped.ts";
import * as Countdown from "./iters.Countdown.ts";
import * as Doubled from "./iters.Doubled.ts";
Expand Down Expand Up @@ -1213,4 +1214,160 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void {
}));
}

/**
* What std's `Option`-returning calls give, returned as is: an `Option`, whose `None`
* stays apart from an item's own.
*/
export function returned(data: rt.ByteSlice, out: rt.ByteVec): void {
const _3: (a0: rt.u8 | undefined, a1: rt.ByteVec) => void = (b: rt.u8 | undefined, out2: rt.ByteVec): void => {
rt.byteVecPush(out2, mapOr$Option_u8_u8_btree_maps_closure5(b, 170, (b2: rt.u8): rt.u8 => {
return b2;
}));
};
const _4: (a0: rt.u8 | undefined | rt.None, a1: rt.ByteVec) => void = (b3: rt.u8 | undefined | rt.None, out3: rt.ByteVec): void => {
if (b3 === rt.None) {
rt.byteVecPush(out3, 187);
} else if (b3 === undefined) {
rt.byteVecPush(out3, 204);
} else {
rt.byteVecPush(out3, b3);
}
};
const n: rt.usize = mapOr$Option_u8_usize_iters_closure1(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => {
return rt.u8Rem(_2, 4) as rt.usize;
});
const part = first$Copied_Iter_u8(rt.iterSlice(rt.byteSliceView(data)));
_3(part, out);
const part2 = back$Copied_Iter_u8(rt.iterSlice(rt.byteSliceView(data)));
_3(part2, out);
const part3 = nth$Copied_Iter_u8(rt.iterSlice(rt.byteSliceView(data)), n);
_3(part3, out);
const part4 = last$Copied_Iter_u8(rt.iterSlice(rt.byteSliceView(data)));
_3(part4, out);
const part5 = first$Map_Iter_u8_returned_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b6: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b6, 3) === 0)) {
return b6;
}
return undefined;
}));
_4(part5, out);
const part6 = back$Map_Iter_u8_returned_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b7: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b7, 3) === 0)) {
return b7;
}
return undefined;
}));
_4(part6, out);
const part7 = first$Gaps({ data, at: n });
_4(part7, out);
const part8 = first$Countdown({ left: n & 0xff, step: 1 });
_3(part8, out);
rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(mapOr$Option_char_u32_from(first$Chars(rt.strChars(unwrapOr$Result_str_Utf8Error(rt.strFromUtf8(data), "é"))), 0, (a0: rt.char): rt.u32 => {
return a0 as rt.u32;
})).reverse()));
const part9 = byMut$Copied_Iter_u8(rt.iterSlice(rt.byteSliceView(data)));
_3(part9, out);
const gaps: Gaps.Gaps = { data, at: 0 };
const part10 = byMut$Gaps(gaps);
_4(part10, out);
const part11 = byMut$Gaps(gaps);
_4(part11, out);
const it: rt.Iter<rt.u8> = rt.iterSlice(rt.byteSliceView(data));
const part12 = borrowed(it);
_3(part12, out);
const part13 = borrowed(it);
_3(part13, out);
const part14 = secondOf(data);
_3(part14, out);
const part15 = fromOne(n & 0xff);
_3(part15, out);
const part16 = peeked$Copied_Iter_u8(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))));
_3(part16, out);
const part17 = at$u8(data, n);
_3(part17, out);
const part18 = at$Option_u8(rt.iterToArray(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b8: rt.u8): rt.u8 | undefined => {
if (!(rt.u8Rem(b8, 3) === 0)) {
return b8;
}
return undefined;
})), n);
_4(part18, out);
}

export function first$Chars(it: rt.Iter<rt.char>): rt.char | undefined {
return rt.iterToOption(it.next());
}

export function first$Copied_Iter_u8(it: rt.Iter<rt.u8>): rt.u8 | undefined {
return rt.iterToOption(it.next());
}

export function first$Countdown(it: Countdown.Countdown): rt.u8 | undefined {
return rt.iterToOption(Countdown.next$Iterator(it));
}

export function first$Gaps(it: Gaps.Gaps): rt.u8 | undefined | rt.None {
return rt.iterToOption(Gaps.next$Iterator(it), rt.None);
}

export function first$Map_Iter_u8_returned_closure0(it: rt.Iter<rt.u8 | undefined>): rt.u8 | undefined | rt.None {
return rt.iterToOption(it.next(), rt.None);
}

export function back$Copied_Iter_u8(it: rt.Iter<rt.u8>): rt.u8 | undefined {
return rt.iterToOption(it.nextBack());
}

export function back$Map_Iter_u8_returned_closure0(it: rt.Iter<rt.u8 | undefined>): rt.u8 | undefined | rt.None {
return rt.iterToOption(it.nextBack(), rt.None);
}

export function nth$Copied_Iter_u8(it: rt.Iter<rt.u8>, n: rt.usize): rt.u8 | undefined {
return rt.iterNth(it, n);
}

export function last$Copied_Iter_u8(it: rt.Iter<rt.u8>): rt.u8 | undefined {
return rt.iterLast(it);
}

/** Through a `&mut` to the iterator. */
export function byMut$Copied_Iter_u8(it: rt.Iter<rt.u8>): rt.u8 | undefined {
return rt.iterToOption(it.next());
}

/** Through a `&mut` to the iterator. */
export function byMut$Gaps(it: Gaps.Gaps): rt.u8 | undefined | rt.None {
return rt.iterToOption(Gaps.next$Iterator(it), rt.None);
}

/** Through a borrow of a std iterator the function is not generic over. */
export function borrowed(it: rt.Iter<rt.u8>): rt.u8 | undefined {
return rt.iterToOption(it.next());
}

/** Of a slice's iterator the function makes. */
export function secondOf(data: rt.ByteSlice): rt.u8 | undefined {
const it: rt.Iter<rt.u8> = rt.iterSlice(rt.byteSliceView(data));
it.next();
return rt.iterToOption(it.next());
}

/** Of a small range the function makes. */
export function fromOne(n: rt.u8): rt.u8 | undefined {
const range: rt.Range<rt.u8> = new rt.Range(1, n);
return range.start < range.end ? range.start++ : undefined;
}

export function peeked$Copied_Iter_u8(it: rt.Peekable<rt.u8>): rt.u8 | undefined {
return rt.peekablePeek(it);
}

export function at$Option_u8(items: Array<rt.u8 | undefined>, i: rt.usize): rt.u8 | undefined | rt.None {
return rt.sliceGet(items, i, rt.None);
}

export function at$u8(items: rt.ByteSlice, i: rt.usize): rt.u8 | undefined {
return rt.byteSliceGet(items, i);
}

//# sourceMappingURL=iters.ts.map
1 change: 1 addition & 0 deletions ts/fixtures/lang/src/harness.rs
Original file line number Diff line number Diff line change
Expand Up @@ -123,6 +123,7 @@ fn cases() -> Vec<(&'static str, Case)> {
("counts::cloned_rcs", |_, data, out| counts::cloned_rcs(data, out)),
("counts::copies", |_, data, out| counts::copies(data, out)),
("statics::cells", |_, data, out| statics::cells(data, out)),
("iters::returned", |_, data, out| iters::returned(data, out)),
]
}

Expand Down
85 changes: 85 additions & 0 deletions ts/fixtures/lang/src/iters.rs
Original file line number Diff line number Diff line change
Expand Up @@ -791,3 +791,88 @@ impl fmt::Debug for Doubled<'_> {
f.debug_list().entries(self.0.iter().map(|&b| b as u16 * 2)).finish()
}
}

/// What std's `Option`-returning calls give, returned as is: an `Option`, whose `None`
/// stays apart from an item's own.
pub fn returned(data: &[u8], out: &mut Vec<u8>) {
let maybe = |b: &u8| if b % 3 == 0 { None } else { Some(*b) };
let push = |b: Option<u8>, out: &mut Vec<u8>| out.push(b.map_or(0xaa, |b| b));
let nested = |b: Option<Option<u8>>, out: &mut Vec<u8>| match b {
None => out.push(0xbb),
Some(None) => out.push(0xcc),
Some(Some(b)) => out.push(b),
};
let n = data.first().map_or(0, |&b| usize::from(b % 4));
push(first(data.iter().copied()), out);
push(back(data.iter().copied()), out);
push(nth(data.iter().copied(), n), out);
push(last(data.iter().copied()), out);
nested(first(data.iter().map(maybe)), out);
nested(back(data.iter().map(maybe)), out);
nested(first(Gaps { data, at: n }), out);
push(first(Countdown { left: n as u8, step: 1 }), out);
let text = std::str::from_utf8(data).unwrap_or("é");
out.extend(first(text.chars()).map_or(0, u32::from).to_le_bytes());
let mut copied = data.iter().copied();
push(by_mut(&mut copied), out);
let mut gaps = Gaps { data, at: 0 };
nested(by_mut(&mut gaps), out);
nested(by_mut(&mut gaps), out);
let mut it = data.iter();
push(borrowed(&mut it).copied(), out);
push(borrowed(&mut it).copied(), out);
push(second_of(data).copied(), out);
push(from_one(n as u8), out);
let mut peekable = data.iter().copied().peekable();
push(peeked(&mut peekable).copied(), out);
push(at(data, n).copied(), out);
let maybes: Vec<Option<u8>> = data.iter().map(maybe).collect();
nested(at(&maybes, n).copied(), out);
}

fn first<I: Iterator>(mut it: I) -> Option<I::Item> {
it.next()
}

fn back<I: DoubleEndedIterator>(mut it: I) -> Option<I::Item> {
it.next_back()
}

fn nth<I: Iterator>(mut it: I, n: usize) -> Option<I::Item> {
it.nth(n)
}

fn last<I: Iterator>(it: I) -> Option<I::Item> {
it.last()
}

/// Through a `&mut` to the iterator.
fn by_mut<I: Iterator>(it: &mut I) -> Option<I::Item> {
it.next()
}

/// Through a borrow of a std iterator the function is not generic over.
fn borrowed<'a>(it: &mut std::slice::Iter<'a, u8>) -> Option<&'a u8> {
it.next()
}

/// Of a slice's iterator the function makes.
fn second_of(data: &[u8]) -> Option<&u8> {
let mut it = data.iter();
it.next();
it.next()
}

/// Of a small range the function makes.
fn from_one(n: u8) -> Option<u8> {
let mut range = 1..n;
range.next()
}

fn peeked<I: Iterator>(it: &mut std::iter::Peekable<I>) -> Option<&I::Item> {
it.peek()
}

fn at<T>(items: &[T], i: usize) -> Option<&T> {
items.get(i)
}
Loading