conspire 0.7.1

The Rust interface to conspire.
Documentation 
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

pub mod sets;

use crate::math::Tensor;
use std::vec::IntoIter;

pub struct Set<S> {
    members: S,
    numbers: Option<Vec<usize>>,
}

impl<S> Set<S> {
    pub fn members(&self) -> &S {
        &self.members
    }
    pub fn members_mut(&mut self) -> &mut S {
        &mut self.members
    }
    pub fn into_members(self) -> S {
        self.members
    }
    pub fn numbers(&self) -> Option<&[usize]> {
        self.numbers.as_deref()
    }
    pub fn set_numbers(&mut self, numbers: Vec<usize>) {
        self.numbers = Some(numbers);
    }
}

impl<S> From<S> for Set<S> {
    fn from(members: S) -> Self {
        Self {
            members,
            numbers: None,
        }
    }
}

impl<S> From<(S, Vec<usize>)> for Set<S> {
    fn from((members, numbers): (S, Vec<usize>)) -> Self {
        Self {
            members,
            numbers: Some(numbers),
        }
    }
}

impl<S> From<Set<S>> for (S, Option<Vec<usize>>) {
    fn from(set: Set<S>) -> Self {
        (set.members, set.numbers)
    }
}

impl<S, T> IntoIterator for Set<S>
where
    S: IntoIterator<Item = T, IntoIter = IntoIter<T>>,
{
    type Item = T;
    type IntoIter = IntoIter<Self::Item>;
    fn into_iter(self) -> Self::IntoIter {
        self.members.into_iter()
    }
}

impl<S> Set<S>
where
    S: Tensor,
{
    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut S::Item> {
        self.members.iter_mut()
    }
}