std.iter

tier: alloc · since: std-0.6 stability: experimental

迭代器适配器链(§3.8.2/§4.8 UFCS;T16 收口 + 续波 R-P3b 面) 形态:Seq[T, S] trait(get 基惰性适配器)+ UFCS 自由函数入口(数组接收者)。 get(i) = 纯位置读取(无内部状态推进),链任意深度组合;终结器(sum/collect/ count/any/all/fold/reduce/foreach/min/max/last/position)索引驱动逐元素拉取, 零中间集合。数组另有快路径直终结入口。 续波(2026-10-03,R-P3b 承诺面收口):适配器补 skip/take_while/rev/enumerate/ zip/chain;终结子补 fold/reduce/foreach/min/max/last/position;Pair[F,G] 载 enumerate/zip 元组位;ListSeq[T] 接入 List(前奏 class 直 impl trait 派发不挂, 探针实证——包装 struct 同 RawSeq 形,from_list 入口)。 v0 语义注记:next 基适配器在 var-self 写回语义落库前不可组合(interp 逐调用 拷贝接收者,p12 实证);自定义 Iterator 经 for-重放 get(03k 语义)接入同一面。 zip/chain 为同型 S 面(other 与 self 同适配器型):数组入口双侧同包 RawSeq 故 xs.zip(ys)/xs.chain(ys) 直用;异型两侧(如 map 后 zip 裸数组)登记后续。 rev/chain 的 get 为无状态重扫(O(n) 每次,总量 O(n·m)):正确性优先,缓存化 待有状态接收语义(var-self 写回)落库后评估。 min/max 与 std/math 的二元 min/max 同名不同签:use 显式导入制下同导两名才 E5030;方法调用形(xs.max())不走自由函数命名空间,无冲突。 发射面:trait 方法调用与 for-over-Iterator 发射在册(T25 v2 域),本面按 03k 先例以双 interp 口径入主套件。

trait

trait Seq

fn get(var self, i: I64) -> T?
fn map(var self, f: fn(T) -> T) -> MapSeq[T, S]
fn filter(var self, p: fn(T) -> Bool) -> FilterSeq[T, S]
fn take(var self, k: I64) -> TakeSeq[T, S]
fn skip(var self, n: I64) -> SkipSeq[T, S]
fn take_while(var self, p: fn(T) -> Bool) -> TakeWhileSeq[T, S]
fn rev(var self) -> RevSeq[T, S]
fn enumerate(var self) -> EnumSeq[T, S]
fn zip(var self, other: S) -> ZipSeq[T, S]
fn chain(var self, other: S) -> ChainSeq[T, S]
fn sum(var self) -> I64
fn count(var self) -> I64
fn collect(var self) -> List[T]
fn any(var self, p: fn(T) -> Bool) -> Bool
fn all(var self, p: fn(T) -> Bool) -> Bool
fn fold(var self, init: I64, f: fn(I64, T) -> I64) -> I64
fn reduce(var self, f: fn(T, T) -> T) -> T?
fn foreach(var self, f: fn(T)) -> I64
fn min(var self) -> T?
fn max(var self) -> T?
fn last(var self) -> T?
fn position(var self, p: fn(T) -> Bool) -> I64?

impl

impl Seq[T, RawSeq[S, T]] for RawSeq[S, T]
    fn get(var self, i: I64) -> T?

impl Seq[T, ListSeq[T]] for ListSeq[T]
    fn get(var self, i: I64) -> T?

impl Seq[T, MapSeq[T, S]] for MapSeq[T, S]
    fn get(var self, i: I64) -> T?

impl Seq[T, FilterSeq[T, S]] for FilterSeq[T, S]
    fn get(var self, i: I64) -> T?

impl Seq[T, TakeSeq[T, S]] for TakeSeq[T, S]
    fn get(var self, i: I64) -> T?

impl Seq[T, SkipSeq[T, S]] for SkipSeq[T, S]
    fn get(var self, i: I64) -> T?

impl Seq[T, TakeWhileSeq[T, S]] for TakeWhileSeq[T, S]
    fn get(var self, i: I64) -> T?

impl Seq[T, RevSeq[T, S]] for RevSeq[T, S]
    fn get(var self, i: I64) -> T?

impl Seq[T, EnumSeq[T, S]] for EnumSeq[T, S]
    fn get(var self, i: I64) -> Pair[I64, T]?

impl Seq[T, ZipSeq[T, S]] for ZipSeq[T, S]
    fn get(var self, i: I64) -> Pair[T, T]?

impl Seq[T, ChainSeq[T, S]] for ChainSeq[T, S]
    fn get(var self, i: I64) -> T?

pub fn

Signature	Returns	Description
map(xs: [I32], f: fn(I32) -> I32)	MapSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.map(f)(UFCS 接收者填首参;包 RawSeq 成 MapSeq)
filter(xs: [I32], p: fn(I32) -> Bool)	FilterSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.filter(p)
take(xs: [I32], k: I64)	TakeSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.take(k) 截前 k 个
skip(xs: [I32], n: I64)	SkipSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.skip(n) 跳前 n 个
take_while(xs: [I32], p: fn(I32) -> Bool)	TakeWhileSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.take_while(p) 取前缀直遇首败
rev(xs: [I32])	RevSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.rev() 反转视图(无状态重扫)
enumerate(xs: [I32])	EnumSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.enumerate() → Pair[I64, T] 序列
zip(xs: [I32], ys: [I32])	ZipSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.zip(ys) 同型拉链(短者截断)
chain(xs: [I32], ys: [I32])	ChainSeq[I32, RawSeq[[I32], I32]]	数组入口:xs.chain(ys) 同型串接
from_list(xs: List[I32])	ListSeq[I32]	List 入口:iter.from_list(xs)(前奏 class 直 impl 派发不挂,包装 struct 接入)
sum(xs: [I32])	I64	数组直终结快路径:I64 累加(零包装索引循环)
count(xs: [I32])	I64	数组直终结:len 直返
collect(xs: [I32])	List[I32]	数组直终结:转 List[I32]
any(xs: [I32], p: fn(I32) -> Bool)	Bool	数组直终结:短路存在判定
all(xs: [I32], p: fn(I32) -> Bool)	Bool	数组直终结:短路全称判定
fold(xs: [I32], init: I64, f: fn(I64, I32) -> I64)	I64	数组直终结:I64 折叠(init 起,逐元素左折叠)
reduce(xs: [I32], f: fn(I32, I32) -> I32)	I32?	数组直终结:同型归并;空数组 None
foreach(xs: [I32], f: fn(I32))	I64	数组直终结:逐元素执行 f,返回处理数
min(xs: [I32])	I32?	数组直终结:最小值;空数组 None
max(xs: [I32])	I32?	数组直终结:最大值;空数组 None
last(xs: [I32])	I32?	数组直终结:末元素;空数组 None
position(xs: [I32], p: fn(I32) -> Bool)	I64?	数组直终结:首个满足 p 的下标;无则 None
parallel_map(xs: List[I32], f: fn(I32) -> I32)	List[I32]	前奏 parallel.map 薄包装(§7.7 归位;前奏直用 parallel 过渡兼容)
parallel_reduce(xs: List[I32], init: I32, f: fn(I32, I32) -> I32)	I32	前奏 parallel.reduce 薄包装(init 起 I32 归并;过渡兼容同上)