1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
use std::mem::swap;
#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
pub struct Vec1<T> {
head: T,
tail: Vec<T>,
}
impl<T> From<T> for Vec1<T> {
fn from(head: T) -> Self {
Self::new(head, Default::default())
}
}
impl<T> Vec1<T> {
pub fn new(head: T, tail: Vec<T>) -> Self {
Self { head, tail }
}
pub fn push(&mut self, new: T) {
self.tail.push(new)
}
pub fn insert(&mut self, index: usize, mut new: T) {
if index == 0 {
swap(&mut new, &mut self.head);
self.tail.insert(0, new)
} else {
self.tail.insert(index - 1, new)
}
}
pub fn map<R>(self, mut f: impl FnMut(T) -> R) -> Vec1<R> {
Vec1::new(f(self.head), self.tail.into_iter().map(f).collect())
}
pub fn try_map<E, R>(self, mut f: impl FnMut(T) -> Result<R, E>) -> Result<Vec1<R>, E> {
Ok(Vec1::new(
f(self.head)?,
self.tail.into_iter().map(f).collect::<Result<_, _>>()?,
))
}
pub fn try_fold1<E>(self, mut f: impl FnMut(T, T) -> Result<T, E>) -> Result<T, E> {
let mut accum = self.head;
for x in self.tail.into_iter() {
accum = f(accum, x)?;
}
Ok(accum)
}
pub fn fold1(self, f: impl FnMut(T, T) -> T) -> T {
self.tail.into_iter().fold(self.head, f)
}
pub fn fold<R>(self, init: R, mut f: impl FnMut(R, T) -> R) -> R {
let init = f(init, self.head);
self.tail.into_iter().fold(init, f)
}
pub fn rev_fold1(self, f: impl FnMut(T, T) -> T) -> T {
self.tail.into_iter().rev().fold(self.head, f)
}
pub fn rev_fold<R>(self, init: R, mut f: impl FnMut(R, T) -> R) -> R {
let init = f(init, self.head);
self.tail.into_iter().rev().fold(init, f)
}
}
impl<T: Default> Default for Vec1<T> {
fn default() -> Self {
Self::from(T::default())
}
}