ryley 0.1.1

Syntax unifies programmers
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! `ryley_slice_index` contains a custom trait for indices used inside ryley
use core::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};

use super::algorithm::safe_index;

/// A helper trait used for indexing operations
pub trait RyleySliceIndex<T: ?Sized> {
    /// Output type of index operation
    type Output: ?Sized;
    /// Performs the indexing (container[index]) operation
    fn index(self, slice: &T) -> &Self::Output;
    /// Performs the mutable indexing (container[index]) operation
    fn index_mut(self, slice: &mut T) -> &mut Self::Output;
}

impl<T> RyleySliceIndex<[T]> for isize {
    type Output = T;
    fn index(self, slice: &[T]) -> &Self::Output {
        &slice[safe_index(self, slice.len())]
    }
    fn index_mut(self, slice: &mut [T]) -> &mut Self::Output {
        let len=slice.len();
        &mut slice[safe_index(self, len)]
    }
}
impl<T> RyleySliceIndex<[T]> for Range<isize> {
    type Output = [T];
    fn index(self, mut slice: &[T]) -> &Self::Output {
        let len=slice.len();
        let mut idx=safe_index(self.end,len+1);
        if self.end<0 || self.end.unsigned_abs()!=idx {idx-=1;}
        slice=slice.split_at(idx).0;
        slice=slice.split_at(safe_index(self.start,len)).1;
        slice
    }
    fn index_mut(self, mut slice: &mut [T]) -> &mut Self::Output {
        let len=slice.len();
        let mut idx=safe_index(self.end,len+1);
        if self.end<0 || self.end.unsigned_abs()!=idx {idx-=1;}
        slice=slice.split_at_mut(idx).0;
        slice=slice.split_at_mut(safe_index(self.start,len)).1;
        slice
    }
}
impl<T> RyleySliceIndex<[T]> for RangeTo<isize> {
    type Output = [T];
    fn index(self, mut slice: &[T]) -> &Self::Output {
        let mut index=safe_index(self.end, slice.len()+1);
        if self.end<0 || index!=self.end.unsigned_abs() {index-=1;}
        slice=slice.split_at(index).0;
        slice
    }
    fn index_mut(self, mut slice: &mut [T]) -> &mut Self::Output {
        let mut index=safe_index(self.end, slice.len()+1);
        if self.end<0 || index!=self.end.unsigned_abs() {index-=1;}
        slice=slice.split_at_mut(index).0;
        slice
    }
}
impl<T> RyleySliceIndex<[T]> for RangeFrom<isize> {
    type Output = [T];
    fn index(self, mut slice: &[T]) -> &Self::Output {
        let mut index=safe_index(self.start, slice.len()+1);
        if self.start<0 || index!=self.start.unsigned_abs() {index-=1;}
        slice=slice.split_at(index).1;
        slice
    }
    fn index_mut(self, mut slice: &mut [T]) -> &mut Self::Output {
        let mut index=safe_index(self.start, slice.len()+1);
        if self.start<0 || index!=self.start.unsigned_abs() {index-=1;}
        slice=slice.split_at_mut(index).1;
        slice
    }
}
impl<T> RyleySliceIndex<[T]> for RangeFull {
    type Output = [T];
    fn index(self, slice: &[T]) -> &Self::Output {
        slice
    }
    fn index_mut(self, slice: &mut [T]) -> &mut Self::Output {
        slice
    }
}
impl<T> RyleySliceIndex<[T]> for RangeInclusive<isize> {
    type Output = [T];
    fn index(self, mut slice: &[T]) -> &Self::Output {
        let len=slice.len();
        let mut idx=safe_index(*self.end(),len+1);
        if *self.end()>=0 && idx==self.end().unsigned_abs() {idx+=1;}
        slice=slice.split_at(idx).0;
        slice=slice.split_at(safe_index(*self.start(),len)).1;
        slice
    }
    fn index_mut(self, mut slice: &mut [T]) -> &mut Self::Output {
        let len=slice.len();
        let mut idx=safe_index(*self.end(),len+1);
        if *self.end()>=0 && idx==self.end().unsigned_abs() {idx+=1;}
        slice=slice.split_at_mut(idx).0;
        slice=slice.split_at_mut(safe_index(*self.start(),len)).1;
        slice
    }
}
impl<T> RyleySliceIndex<[T]> for RangeToInclusive<isize> {
    type Output = [T];
    fn index(self, mut slice: &[T]) -> &Self::Output {
        let mut index=safe_index(self.end, slice.len()+1);
        if self.end>=0 && index==self.end.unsigned_abs() {index+=1;}
        slice=slice.split_at(index).0;
        slice
    }
    fn index_mut(self, mut slice: &mut [T]) -> &mut Self::Output {
        let mut index=safe_index(self.end, slice.len()+1);
        if self.end>=0 && index==self.end.unsigned_abs() {index+=1;}
        slice=slice.split_at_mut(index).0;
        slice
    }
}