API

`#slices`

import: #slices

counts: 62 函数, 0 方法, 1 类型, 0 常量, 0 方法集

int/string/f64 切片：contains/index/equal/reverse/clone/sort_func 等。

`contains_int`

XuAPI

pub fn contains_int(xs []int, v int) bool

用途

包含int。

参数

xs []int: 要处理的切片（[]int）
v int: 值（int）

bool — 是否成立

`index_of_int`

XuAPI

pub fn index_of_int(xs []int, v int) int

用途

下标ofint。未找到返回 -1。

参数

xs []int: 要处理的切片（[]int）
v int: 值（int）

int — 下标；未找到为 -1

`last_index_int`

XuAPI

pub fn last_index_int(xs &[]int, v int) int

用途

last下标int。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
v int: 值（int）

int — 下标；未找到为 -1

`last_index_str`

XuAPI

pub fn last_index_str(xs &[]string, v string) int

用途

last下标str。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
v string: 值（string）

int — 下标；未找到为 -1

`sum_int`

XuAPI

pub fn sum_int(xs []int) int

用途

摘要int。

参数

xs []int: 要处理的切片（[]int）

int — 该类型的值

`contains_str`

XuAPI

pub fn contains_str(xs []string, v string) bool

用途

包含str。

参数

xs []string: 要处理的切片（[]string）
v string: 值（string）

bool — 是否成立

`index_of_str`

XuAPI

pub fn index_of_str(xs []string, v string) int

用途

下标ofstr。未找到返回 -1。

参数

xs []string: 要处理的切片（[]string）
v string: 值（string）

int — 下标；未找到为 -1

`equal_ints`

XuAPI

pub fn equal_ints(a &[]int, b &[]int) bool

用途

相等int 切片。

参数

a &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
b &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

bool — 是否成立

`equal_strs`

XuAPI

pub fn equal_strs(a &[]string, b &[]string) bool

用途

相等strs。

参数

a &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
b &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

bool — 是否成立

`reverse_ints`

XuAPI

pub fn reverse_ints(a &mut []int)

用途

逆序int 切片。

参数

a &mut []int: 要处理的切片（独占借用；类型 &mut []int）

`reverse_strs`

XuAPI

pub fn reverse_strs(a &mut []string)

用途

逆序strs。

参数

a &mut []string: 要处理的切片（独占借用；类型 &mut []string）

`clone_ints`

XuAPI

pub fn clone_ints(xs &[]int) []int

用途

拷贝int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

[]int — 切片结果

`clone_strs`

XuAPI

pub fn clone_strs(xs &[]string) []string

用途

拷贝strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

[]string — 切片结果

`compare_ints`

XuAPI

pub fn compare_ints(a &[]int, b &[]int) int

用途

比较int 切片。

参数

a &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
b &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

int — 该类型的值

`compare_strs`

XuAPI

pub fn compare_strs(a &[]string, b &[]string) int

用途

比较strs。

参数

a &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
b &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

int — 该类型的值

`compact_ints`

XuAPI

pub fn compact_ints(xs &[]int) []int

用途

压成一行int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

[]int — 切片结果

`compact_strs`

XuAPI

pub fn compact_strs(xs &[]string) []string

用途

压成一行strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

[]string — 切片结果

`insert_int`

XuAPI

pub fn insert_int(xs &[]int, i int, v int) []int

用途

插入int。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
i int: 下标或整数（int）
v int: 值（int）

[]int — 切片结果

`insert_str`

XuAPI

pub fn insert_str(xs &[]string, i int, v string) []string

用途

插入str。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
i int: 下标或整数（int）
v string: 值（string）

[]string — 切片结果

`delete_ints`

XuAPI

pub fn delete_ints(xs &[]int, i int, j int) []int

用途

删除int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
i int: 下标或整数（int）
j int: 下标（int）

[]int — 切片结果

`delete_strs`

XuAPI

pub fn delete_strs(xs &[]string, i int, j int) []string

用途

删除strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
i int: 下标或整数（int）
j int: 下标（int）

[]string — 切片结果

`min_int`

XuAPI

pub fn min_int(xs &[]int) int

用途

最小int。失败时 throw。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

int — 该类型的值

`max_int`

XuAPI

pub fn max_int(xs &[]int) int

用途

最大int。失败时 throw。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

int — 该类型的值

`contains_f64`

XuAPI

pub fn contains_f64(xs &[]f64, v f64) bool

用途

包含f64。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
v f64: 值（f64）

bool — 是否成立

`index_of_f64`

XuAPI

pub fn index_of_f64(xs &[]f64, v f64) int

用途

下标off64。未找到返回 -1。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
v f64: 值（f64）

int — 下标；未找到为 -1

`equal_f64s`

XuAPI

pub fn equal_f64s(a &[]f64, b &[]f64) bool

用途

相等f64 切片。

参数

a &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
b &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

bool — 是否成立

`clone_f64s`

XuAPI

pub fn clone_f64s(xs &[]f64) []f64

用途

拷贝f64 切片。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

[]f64 — 切片结果

`reverse_f64s`

XuAPI

pub fn reverse_f64s(a &mut []f64)

用途

逆序f64 切片。

参数

a &mut []f64: 要处理的切片（独占借用；类型 &mut []f64）

`min_f64`

XuAPI

pub fn min_f64(xs &[]f64) f64

用途

最小f64。失败时 throw。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

f64 — 该类型的值

`max_f64`

XuAPI

pub fn max_f64(xs &[]f64) f64

用途

最大f64。失败时 throw。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

f64 — 该类型的值

`compare_f64s`

XuAPI

pub fn compare_f64s(a &[]f64, b &[]f64) int

用途

比较f64 切片。

参数

a &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
b &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

int — 该类型的值

`compact_f64s`

XuAPI

pub fn compact_f64s(xs &[]f64) []f64

用途

压成一行f64 切片。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

[]f64 — 切片结果

`insert_f64`

XuAPI

pub fn insert_f64(xs &[]f64, i int, v f64) []f64

用途

插入f64。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
i int: 下标或整数（int）
v f64: 值（f64）

[]f64 — 切片结果

`delete_f64s`

XuAPI

pub fn delete_f64s(xs &[]f64, i int, j int) []f64

用途

删除f64 切片。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
i int: 下标或整数（int）
j int: 下标（int）

[]f64 — 切片结果

`struct SearchResult`

XuAPI

pub struct SearchResult {
    pub index int
    pub found bool
}

用途

公开结构体 `SearchResult`。

参数

index int: 字段（int）
found bool: 字段（bool）

`binary_search_ints`

XuAPI

pub fn binary_search_ints(xs &[]int, v int) SearchResult

用途

在已排序切片中二分查找，返回下标与是否命中。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
v int: 值（int）

SearchResult — 该类型的值

`binary_search_strs`

XuAPI

pub fn binary_search_strs(xs &[]string, v string) SearchResult

用途

在已排序切片中二分查找，返回下标与是否命中。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
v string: 值（string）

SearchResult — 该类型的值

`binary_search_f64s`

XuAPI

pub fn binary_search_f64s(xs &[]f64, v f64) SearchResult

用途

在已排序切片中二分查找，返回下标与是否命中。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
v f64: 值（f64）

SearchResult — 该类型的值

`replace_ints`

XuAPI

pub fn replace_ints(xs &[]int, i int, j int, add &[]int) []int

用途

替换int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
i int: 下标或整数（int）
j int: 下标（int）
add &[]int: add（借用，调用方仍持有；类型 &[]int）

[]int — 切片结果

`replace_strs`

XuAPI

pub fn replace_strs(xs &[]string, i int, j int, add &[]string) []string

用途

替换strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
i int: 下标或整数（int）
j int: 下标（int）
add &[]string: add（借用，调用方仍持有；类型 &[]string）

[]string — 切片结果

`concat_ints`

XuAPI

pub fn concat_ints(a &[]int, b &[]int) []int

用途

concatint 切片。

参数

a &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
b &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

[]int — 切片结果

`repeat_ints`

XuAPI

pub fn repeat_ints(xs &[]int, n int) []int

用途

重复int 切片。失败时 throw。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
n int: 数量、长度或上限（int）

[]int — 切片结果

`repeat_strs`

XuAPI

pub fn repeat_strs(xs &[]string, n int) []string

用途

重复strs。失败时 throw。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
n int: 数量、长度或上限（int）

[]string — 切片结果

`index_func_ints`

XuAPI

pub fn index_func_ints(xs &[]int, f fn(int) bool) int

用途

下标回调int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
f fn(int) bool: 字节回调：参数为字节值 0..255，返回是否命中

int — 下标；未找到为 -1

`contains_func_ints`

XuAPI

pub fn contains_func_ints(xs &[]int, f fn(int) bool) bool

用途

包含回调int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
f fn(int) bool: 字节回调：参数为字节值 0..255，返回是否命中

bool — 是否成立

`index_func_strs`

XuAPI

pub fn index_func_strs(xs &[]string, f fn(string) bool) int

用途

下标回调strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
f fn(string) bool: 字节回调：参数为字节值 0..255，返回是否命中

int — 下标；未找到为 -1

`concat_strs`

XuAPI

pub fn concat_strs(a &[]string, b &[]string) []string

用途

concatstrs。

参数

a &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
b &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

[]string — 切片结果

`sort_ints_func`

XuAPI

pub fn sort_ints_func(a &mut []int, less fn(int, int) bool)

用途

排序int 切片回调。

参数

a &mut []int: 要处理的切片（独占借用；类型 &mut []int）
less fn(int, int) bool: 比较回调：true 表示左<右（函数值；类型 fn(int, int) bool）

`sort_strs_func`

XuAPI

pub fn sort_strs_func(a &mut []string, less fn(string, string) bool)

用途

排序strs回调。

参数

a &mut []string: 要处理的切片（独占借用；类型 &mut []string）
less fn(string, string) bool: 比较回调：true 表示左<右（函数值；类型 fn(string, string) bool）

`last_index_func_ints`

XuAPI

pub fn last_index_func_ints(xs &[]int, f fn(int) bool) int

用途

last下标回调int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
f fn(int) bool: 字节回调：参数为字节值 0..255，返回是否命中

int — 下标；未找到为 -1

`last_index_func_strs`

XuAPI

pub fn last_index_func_strs(xs &[]string, f fn(string) bool) int

用途

last下标回调strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
f fn(string) bool: 字节回调：参数为字节值 0..255，返回是否命中

int — 下标；未找到为 -1

`min_str`

XuAPI

pub fn min_str(xs &[]string) string

用途

最小str。失败时 throw。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

string — 结果字符串

`max_str`

XuAPI

pub fn max_str(xs &[]string) string

用途

最大str。失败时 throw。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

string — 结果字符串

`is_sorted_ints`

XuAPI

pub fn is_sorted_ints(xs &[]int) bool

用途

判断是否 sorted ints。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）

bool — 是否成立

`is_sorted_strs`

XuAPI

pub fn is_sorted_strs(xs &[]string) bool

用途

判断是否 sorted strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）

bool — 是否成立

`last_index_f64`

XuAPI

pub fn last_index_f64(xs &[]f64, v f64) int

用途

last下标f64。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
v f64: 值（f64）

int — 下标；未找到为 -1

`concat_f64s`

XuAPI

pub fn concat_f64s(a &[]f64, b &[]f64) []f64

用途

concatf64 切片。

参数

a &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
b &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

[]f64 — 切片结果

`replace_f64s`

XuAPI

pub fn replace_f64s(xs &[]f64, i int, j int, add &[]f64) []f64

用途

替换f64 切片。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
i int: 下标或整数（int）
j int: 下标（int）
add &[]f64: add（借用，调用方仍持有；类型 &[]f64）

[]f64 — 切片结果

`repeat_f64s`

XuAPI

pub fn repeat_f64s(xs &[]f64, n int) []f64

用途

重复f64 切片。失败时 throw。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）
n int: 数量、长度或上限（int）

[]f64 — 切片结果

`is_sorted_f64s`

XuAPI

pub fn is_sorted_f64s(xs &[]f64) bool

用途

判断是否 sorted f64s。

参数

xs &[]f64: 要处理的切片（借用，调用方仍持有；类型 &[]f64）

bool — 是否成立

`contains_func_strs`

XuAPI

pub fn contains_func_strs(xs &[]string, f fn(string) bool) bool

用途

包含回调strs。

参数

xs &[]string: 要处理的切片（借用，调用方仍持有；类型 &[]string）
f fn(string) bool: 字节回调：参数为字节值 0..255，返回是否命中

bool — 是否成立

`compact_func_ints`

XuAPI

pub fn compact_func_ints(xs &[]int, eq fn(int, int) bool) []int

用途

压成一行回调int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
eq fn(int, int) bool: eq（函数值；类型 fn(int, int) bool）

[]int — 切片结果

`delete_func_ints`

XuAPI

pub fn delete_func_ints(xs &[]int, f fn(int) bool) []int

用途

删除回调int 切片。

参数

xs &[]int: 要处理的切片（借用，调用方仍持有；类型 &[]int）
f fn(int) bool: 字节回调：参数为字节值 0..255，返回是否命中

[]int — 切片结果