index-fixed 0.3.1

convert slices into arrays using indexes ([T] -> [T;N])
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
118
119
120
121
122
123
124
125
126
127
128

#![no_std]
#![forbid(unsafe_code)]

#[doc(hidden)]
pub use core::convert::TryInto;

/**
 * Slices (via the Index trait & operation) into fixed size arrays
 *
 * Will panic with the same rules as normal slicing.
 *
 * Will not compile if bounds are not static.
 *
 * Will not compile if end bound proceeds start bound.
 *
 * # Format
 *
 * ```notest
 * index_fixed! ( {&,&mut} <slice> ; .. <end>)
 * index_fixed! ( {&,&mut} <slice> ; <start> , .. <end>)
 * index_fixed! ( {&,&mut} <slice> ; <start> , ... <end>)
 * ```
 *
 * # Examples
 *
 * ```
 * #[macro_use]
 * extern crate index_fixed;
 *
 * fn main() {
 *   let my_slice = [1, 2, 3, 4];
 *   let slice_of_2 = index_fixed!(&my_slice ; .. 2);
 *   assert_eq!(slice_of_2, &my_slice[..2]);
 * }
 * ```
 */
// FIXME example test disabled because index_fixed!() is not defined
#[macro_export]
macro_rules! index_fixed {
    (&mut $s:expr ;  .. $e:expr) => {
        index_fixed!(&mut $s; 0 , .. $e )
    };
    (&mut $s:expr ; $b:expr , ... $e:expr) => {
        index_fixed!(&mut $s; $b , .. ($e + 1))
    };
    (&mut $s:expr ; $b:expr , .. $e:expr) => { {
        fn conv<T>(b: &mut[T]) -> &mut[T;$e - $b] {
            use $crate::TryInto;
            b.try_into().unwrap()
        }
        conv(&mut $s[$b..$e])
    } };
    (& $s:expr ; .. $e:expr) => {
        index_fixed!(& $s ; 0 , .. $e)
    };
    (& $s:expr ; $b:expr , ... $e:expr) => {
        index_fixed!(& $s ; $b , .. ($e + 1))
    };
    (& $s:expr ; $b:expr , .. $e:expr) => { {
        fn conv<T>(b: &[T]) -> &[T;$e - $b] {
            use $crate::TryInto;
            b.try_into().unwrap()
        }
        conv(& $s[$b..$e])
    } };
}

/**
 * `slice::get` and `slice::get_mut`, but return an `Option<&[T;N]>` or `Option<&mut [T;N]>`
 *
 * Will not compile if bounds are not static.
 *
 * Will not compile if end bound proceeds start bound.
 *
 * # Format
 *
 * ```notest
 * index_fixed_get! ( {&,&mut} <slice> ; .. <end>)
 * index_fixed_get! ( {&,&mut} <slice> ; <start> , .. <end>)
 * index_fixed_get! ( {&,&mut} <slice> ; <start> , ... <end>)
 * ```
 *
 * # Examples
 *
 * ```
 * #[macro_use]
 * extern crate index_fixed;
 *
 * fn main() {
 *   let my_slice = [1, 2, 3, 4];
 *   let slice_of_2 = index_fixed_get!(&my_slice ; .. 2);
 *   assert_eq!(slice_of_2, Some(&[1,2]));
 * }
 * ```
 */
#[macro_export]
macro_rules! index_fixed_get {
    (&mut $s:expr ;  .. $e:expr) => {
        index_fixed_get!(&mut $s; 0 , .. $e )
    };
    (&mut $s:expr ; $b:expr , ... $e:expr) => {
        index_fixed_get!(&mut $s; $b , .. ($e + 1))
    };
    (&mut $s:expr ; $b:expr , .. $e:expr) => { {
        fn conv<T>(a: Option<&mut[T]>) -> Option<&mut[T;$e - $b]> {
            a.map(|b| {
                  use $crate::TryInto;
                  b.try_into().unwrap()
            })
        }
        conv($s.get_mut($b..$e))
    } };
    (& $s:expr ; .. $e:expr) => {
        index_fixed_get!(& $s ; 0 , .. $e)
    };
    (& $s:expr ; $b:expr , ... $e:expr) => {
        index_fixed_get!(& $s ; $b , .. ($e + 1))
    };
    (& $s:expr ; $b:expr , .. $e:expr) => { {
        fn conv<T>(a: Option<&[T]>) -> Option<&[T;$e - $b]> {
            a.map(|b| {
                  use $crate::TryInto;
                  b.try_into().unwrap()
            })
        }
        conv($s.get($b..$e))
    } };
}