bendns' repos / atools
const generic expr based fixed length array manipulation crate
Diffstat
-rw-r--r--.gitignore2
-rw-r--r--Cargo.toml10
-rw-r--r--LICENSE21
-rw-r--r--README.md5
-rw-r--r--src/lib.rs394
-rw-r--r--src/pervasive.rs91
-rw-r--r--src/tuple.rs95
7 files changed, 618 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..869df07
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+/target
+Cargo.lock \ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..161c6cc
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "atools"
+version = "0.1.0"
+edition = "2021"
+description = "const generic expr based fixed length array manipulation"
+authors = ["bend-n <[email protected]>"]
+license = "MIT"
+repository = "https://github.com/bend-n/atools"
+keywords = ["array"]
+categories = ["no-std"]
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..2f002a4
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 bendn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..31b1579
--- /dev/null
+++ b/README.md
@@ -0,0 +1,5 @@
+# atools
+
+const generic expr based fixed length array manipulation crate
+
+it is very nightly. \ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..dcc52d9
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,394 @@
+//! a collection of useful features for working with arrays
+#![cfg_attr(not(test), no_std)]
+#![allow(incomplete_features, internal_features)]
+#![feature(
+ generic_const_exprs,
+ core_intrinsics,
+ iter_intersperse,
+ maybe_uninit_array_assume_init,
+ inline_const,
+ array_windows,
+ iter_map_windows
+)]
+#![warn(
+ clippy::undocumented_unsafe_blocks,
+ clippy::missing_const_for_fn,
+ clippy::missing_safety_doc,
+ clippy::suboptimal_flops,
+ unsafe_op_in_unsafe_fn,
+ clippy::dbg_macro,
+ clippy::use_self,
+ missing_docs
+)]
+
+/// The prelude. You should
+/// ```
+/// use atools::prelude::*;
+/// ```
+pub mod prelude {
+ #[doc(inline)]
+ pub use super::{
+ pervasive::prelude::*, range, splat, Array, ArrayTools, Chunked, CollectArray, Couple,
+ DropFront, Join, Pop, Trunc, Tuple,
+ };
+ #[doc(inline)]
+ pub use core::array::from_fn;
+}
+
+use core::{array::from_fn, mem::ManuallyDrop as MD};
+pub mod pervasive;
+mod tuple;
+pub use tuple::*;
+
+/// Convenience function for when clonage is required; prefer `[T; N]` if possible. Also useful if `N` should be inferred.
+pub fn splat<T: Clone, const N: usize>(a: T) -> [T; N] {
+ from_fn(|_| a.clone())
+}
+
+const fn id<T>(x: T) -> T {
+ x
+}
+
+/// Creates a array of indices.
+/// ```
+/// # use atools::prelude::*;
+/// assert_eq!(range::<5>(), [0, 1, 2, 3, 4]);
+/// ```
+pub fn range<const N: usize>() -> [usize; N] {
+ from_fn(id)
+}
+
+/// Collect an iterator into a array.
+pub trait CollectArray<T> {
+ /// Collect an iterator into a array.
+ ///
+ /// # Panics
+ ///
+ /// if the array isn't big enough.
+ fn carr<const N: usize>(&mut self) -> [T; N];
+}
+
+impl<T, I: Iterator<Item = T>> CollectArray<T> for I {
+ fn carr<const N: usize>(&mut self) -> [T; N] {
+ from_fn(|_| self.next().unwrap())
+ }
+}
+
+/// Pop parts of a array.
+/// Use
+/// ```
+/// let [t, arr @ ..] = [1, 2];
+/// ```
+/// when possible. If the length of the array is a const generic, use
+/// ```
+/// # use atools::prelude::*;
+/// let (t, arr) = [1, 2].pop_front();
+/// ```
+pub trait Pop<T, const N: usize> {
+ /// Pop the front of a array.
+ /// ```
+ /// # use atools::prelude::*;
+ /// let (t, arr) = b"abc".pop_front();
+ /// # assert_eq!(t, b'a');
+ /// # assert_eq!(arr, *b"bc");
+ /// ```
+ fn pop_front(self) -> (T, [T; N - 1]);
+ /// Pop the back (end) of a array.
+ /// ```
+ /// # use atools::prelude::*;
+ /// let (arr, t) = [0.1f32, 0.2, 0.3].pop();
+ /// # assert_eq!(arr, [0.1, 0.2]);
+ /// assert_eq!(t, 0.3);
+ /// ```
+ fn pop(self) -> ([T; N - 1], T);
+}
+
+impl<T, const N: usize> Pop<T, N> for [T; N] {
+ fn pop_front(self) -> (T, [T; N - 1]) {
+ // SAFETY: hi crater
+ unsafe { core::intrinsics::transmute_unchecked(self) }
+ }
+
+ fn pop(self) -> ([T; N - 1], T) {
+ // SAFETY: i am evil
+ unsafe { core::intrinsics::transmute_unchecked(self) }
+ }
+}
+
+/// Removes the last element of a array. The opposite of [`DropFront`].
+pub trait Trunc<T, const N: usize> {
+ /// Remove the last element of a array.
+ /// You can think of this like <code>a.[pop()](Pop::pop).0</code>
+ /// ```
+ /// # use atools::prelude::*;
+ /// let a = [1u64, 2].trunc();
+ /// assert_eq!(a, [1]);
+ /// ```
+ fn trunc(self) -> [T; N - 1];
+}
+
+impl<const N: usize, T> Trunc<T, N> for [T; N] {
+ fn trunc(self) -> [T; N - 1] {
+ self.pop().0
+ }
+}
+
+/// Remove the first element of a array. The opposite of [`Trunc`].
+pub trait DropFront<T, const N: usize> {
+ /// Removes the first element.
+ fn drop_front(self) -> [T; N - 1];
+}
+
+impl<const N: usize, T> DropFront<T, N> for [T; N] {
+ fn drop_front(self) -> [T; N - 1] {
+ self.pop_front().1
+ }
+}
+
+/// Join scalars together.
+pub trait Join<T, const N: usize, const O: usize, U> {
+ /// Join a array and an scalar together. For joining two arrays together, see [`Couple`].
+ /// ```
+ /// # use atools::prelude::*;
+ /// let a = [1, 2].join(3);
+ /// let b = 1.join([2, 3]);
+ /// let c = 1.join(2).join(3);
+ /// ```
+ fn join(self, with: U) -> [T; N + O];
+}
+
+/// Couple two arrays together.
+pub trait Couple<T, const N: usize, const O: usize> {
+ /// Couple two arrays together. This could have been [`Join`], but the methods would require disambiguation.
+ /// ```
+ /// # use atools::prelude::*;
+ /// let a = 1.join(2).couple([3, 4]);
+ /// ```
+ fn couple(self, with: [T; O]) -> [T; N + O];
+}
+
+impl<T, const N: usize, const O: usize> Couple<T, N, O> for [T; N] {
+ fn couple(self, with: [T; O]) -> [T; N + O] {
+ self.into_iter().chain(with).carr()
+ }
+}
+
+impl<T, const N: usize> Join<T, N, 1, T> for [T; N] {
+ fn join(self, with: T) -> [T; N + 1] {
+ self.couple([with])
+ }
+}
+
+impl<T> Join<T, 1, 1, T> for T {
+ fn join(self, with: T) -> [T; 2] {
+ [self, with]
+ }
+}
+
+impl<T, const O: usize> Join<T, 1, O, [T; O]> for T {
+ fn join(self, with: [T; O]) -> [T; 1 + O] {
+ [self].couple(with)
+ }
+}
+
+pub(crate) const fn assert_zero(x: usize) -> usize {
+ if x != 0 {
+ panic!("expected zero");
+ } else {
+ 0
+ }
+}
+
+/// 🍪
+#[allow(private_bounds)]
+pub trait Chunked<T, const N: usize> {
+ /// Chunks.
+ /// This will compile fail if `N ∤ (does not divide) C`
+ /// ```
+ /// # use atools::prelude::*;
+ /// assert_eq!(range::<6>().chunked::<3>(), [[0, 1, 2], [3, 4, 5]]);
+ /// ```
+ #[allow(private_bounds)]
+ fn chunked<const C: usize>(self) -> [[T; C]; N / C]
+ where
+ // N % C == 0
+ [(); assert_zero(N % C)]:;
+}
+
+impl<const N: usize, T> Chunked<T, N> for [T; N] {
+ #[allow(private_bounds)]
+ fn chunked<const C: usize>(self) -> [[T; C]; N / C]
+ where
+ [(); assert_zero(N % C)]:,
+ {
+ // SAFETY: N != 0 && wont leak as N % C == 0.
+ unsafe { MD::new(self).as_ptr().cast::<[[T; C]; N / C]>().read() }
+ }
+}
+
+/// Array tools.
+pub trait ArrayTools<T, const N: usize> {
+ /// Skip `BY` elements.
+ fn skip<const BY: usize>(self) -> [T; N - BY];
+ /// Skip every `BY` elements.
+ ///
+ /// ```
+ /// # use atools::prelude::*;
+ /// let x = range::<5>().step::<2>();
+ /// assert_eq!(x, [0, 2, 4]);
+ /// let x = range::<20>().step::<5>();
+ /// assert_eq!(x, [0, 5, 10, 15]);
+ /// assert_eq!(range::<50>().step::<3>(), [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48]);
+ /// ```
+ fn step<const STEP: usize>(self) -> [T; 1 + (N - 1) / (STEP)];
+ /// Zip arrays together.
+ fn zip<U>(self, with: [U; N]) -> [(T, U); N];
+ /// Intersperse a element in between items.
+ /// ```
+ /// # use atools::prelude::*;
+ /// let x = range::<3>().intersperse(5);
+ /// assert_eq!(x, [0, 5, 1, 5, 2]);
+ /// ```
+ fn intersperse(self, with: T) -> [T; (N * 2) - 1]
+ where
+ T: Clone;
+ /// Run a function on every element.
+ fn each(self, apply: impl FnMut(T));
+ /// Embed the index.
+ fn enumerate(self) -> [(T, usize); N];
+ /// Take `M` elements, discarding the rest.
+ /// ```
+ /// # use atools::prelude::*;
+ /// assert_eq!(range::<50>().take::<5>(), range::<5>());
+ /// ```
+ fn take<const M: usize>(self) -> [T; M];
+ /// Get the sliding windows of this array.
+ /// ```
+ /// # use atools::prelude::*;
+ /// assert_eq!(range::<5>().windowed::<2>(), [&[0, 1], &[1, 2], &[2, 3], &[3, 4]]);
+ /// ```
+ fn windowed<const W: usize>(&self) -> [&[T; W]; N - W + 1];
+ /// Inspect every element of this array.
+ fn inspect(self, f: impl FnMut(&T)) -> Self;
+ /// Reverse this array.
+ fn rev(self) -> Self;
+ /// Interleave items from two arrays.
+ /// ```
+ /// # use atools::prelude::*;
+ /// assert_eq!([0u8, 2, 4].interleave([1, 3, 5]), [0, 1, 2, 3, 4, 5]);
+ /// ```
+ fn interleave(self, with: [T; N]) -> [T; N * 2];
+ /// [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) (`A  ×  B`) of two arrays.
+ /// ```
+ /// # use atools::prelude::*;
+ /// assert_eq!([1u64, 2].cartesian_product(&["Π", "Σ"]), [(1, "Π"), (1, "Σ"), (2, "Π"), (2, "Σ")]);
+ /// ```
+ fn cartesian_product<U: Clone, const M: usize>(&self, with: &[U; M]) -> [(T, U); N + M]
+ where
+ T: Clone;
+ /// Sorts it. This uses <code>[[T](slice)]::[sort_unstable](slice::sort_unstable)</code>.
+ fn sort(self) -> Self
+ where
+ T: Ord;
+ /// Sum of the array.
+ fn sum(self) -> T
+ where
+ T: core::iter::Sum<T>;
+ /// Product of the array.
+ fn product(self) -> T
+ where
+ T: core::iter::Product<T>;
+}
+
+impl<T, const N: usize> ArrayTools<T, N> for [T; N] {
+ fn skip<const BY: usize>(self) -> [T; N - BY] {
+ self.into_iter().skip(BY).carr()
+ }
+ fn step<const STEP: usize>(self) -> [T; 1 + (N - 1) / (STEP)] {
+ self.into_iter().step_by(STEP).carr()
+ }
+ fn zip<U>(self, with: [U; N]) -> [(T, U); N] {
+ self.into_iter().zip(with).carr()
+ }
+
+ fn intersperse(self, with: T) -> [T; (N * 2) - 1]
+ where
+ T: Clone,
+ {
+ self.into_iter().intersperse(with).carr()
+ }
+
+ fn each(self, apply: impl FnMut(T)) {
+ self.into_iter().for_each(apply);
+ }
+
+ fn enumerate(self) -> [(T, usize); N] {
+ let mut n = 0;
+ self.map(|x| {
+ let o = n;
+ n += 1;
+ (x, o)
+ })
+ }
+
+ fn take<const M: usize>(self) -> [T; M] {
+ self.into_iter().take(M).carr()
+ }
+
+ fn windowed<const W: usize>(&self) -> [&[T; W]; N - W + 1] {
+ self.array_windows().carr()
+ }
+
+ fn inspect(self, f: impl FnMut(&T)) -> Self {
+ self.iter().for_each(f);
+ self
+ }
+
+ fn rev(self) -> Self {
+ self.into_iter().rev().carr()
+ }
+
+ fn interleave(self, with: [T; N]) -> [T; N * 2] {
+ let mut which = true;
+ let mut a = self.into_iter();
+ let mut b = with.into_iter();
+ from_fn(|_| {
+ which = !which;
+ match which {
+ false => a.next().unwrap(),
+ true => b.next().unwrap(),
+ }
+ })
+ }
+
+ fn cartesian_product<U: Clone, const M: usize>(&self, with: &[U; M]) -> [(T, U); N + M]
+ where
+ T: Clone,
+ {
+ self.iter()
+ .flat_map(|a| with.iter().map(move |b| (a.clone(), b.clone())))
+ .carr()
+ }
+
+ fn sort(mut self) -> Self
+ where
+ T: Ord,
+ {
+ <[T]>::sort_unstable(&mut self);
+ self
+ }
+
+ fn sum(self) -> T
+ where
+ T: core::iter::Sum<T>,
+ {
+ self.into_iter().sum()
+ }
+
+ fn product(self) -> T
+ where
+ T: core::iter::Product<T>,
+ {
+ self.into_iter().product()
+ }
+}
diff --git a/src/pervasive.rs b/src/pervasive.rs
new file mode 100644
index 0000000..3672780
--- /dev/null
+++ b/src/pervasive.rs
@@ -0,0 +1,91 @@
+//! pervasive array operations.
+pub mod scalar_and_array {
+ //! traits for scalar $op array
+ macro_rules! op {
+ ($op:ident, $n:ident, $f:ident) => {
+ #[doc = concat!("see [`", stringify!($f), "`](core::ops::", stringify!($op), "::", stringify!($f), ")")]
+ pub trait $n<T, const N: usize> {
+ #[doc = concat!("apply the [`", stringify!($f), "`](core::ops::", stringify!($op), "::", stringify!($f), ") function to each element of this array.")]
+ fn $f(self, rhs: [T; N]) -> [T; N];
+ }
+
+ impl<T: core::ops::$op<Output = T> + Copy, const N: usize> $n<T, N> for T {
+ fn $f(self, rhs: [T; N]) -> [T; N] {
+ rhs.map(|x| core::ops::$op::$f(x, self))
+ }
+ }
+ };
+ }
+ op!(Add, SAAAdd, add);
+ op!(BitAnd, SAAAnd, bitand);
+ op!(BitOr, SAAOr, bitor);
+ op!(BitXor, SAAXor, bitxor);
+ op!(Div, SAADiv, div);
+ op!(Mul, SAAMul, mul);
+ op!(Rem, SAARem, rem);
+ op!(Shl, SAAShl, shl);
+ op!(Shr, SAAShr, shr);
+ op!(Sub, SAASub, sub);
+}
+
+pub mod array_and_scalar {
+ //! traits for array $op scalar
+ macro_rules! op {
+ ($op:ident, $n:ident, $f:ident) => {
+ #[doc = concat!("see [`", stringify!($f), "`](core::ops::", stringify!($op), "::", stringify!($f), ")")]
+ pub trait $n<T, const N: usize> {
+ #[doc = concat!("apply the [`", stringify!($f), "`](core::ops::", stringify!($op), "::", stringify!($f), ") function to each element of this array.")]
+ fn $f(self, rhs: T) -> Self;
+ }
+
+ impl<T: core::ops::$op<Output = T> + Copy, const N: usize> $n<T, N> for [T; N] {
+ fn $f(self, rhs: T) -> Self {
+ self.map(|x| core::ops::$op::$f(x, rhs))
+ }
+ }
+ };
+ }
+ op!(Add, AASAdd, add);
+ op!(BitAnd, AASAnd, bitand);
+ op!(BitOr, AASOr, bitor);
+ op!(BitXor, AASXor, bitxor);
+ op!(Div, AASDiv, div);
+ op!(Mul, AASMul, mul);
+ op!(Rem, AASRem, rem);
+ op!(Shl, AASShl, shl);
+ op!(Shr, AASShr, shr);
+ op!(Sub, AASSub, sub);
+}
+
+/// see [`not`](core::ops::Not::not)
+pub trait ANot<T, const N: usize> {
+ /// apply the [`not`](core::ops::Not::not) function to each element of this array.
+ fn not(self) -> Self;
+}
+impl<T: core::ops::Not<Output = T>, const N: usize> ANot<T, N> for [T; N] {
+ fn not(self) -> Self {
+ self.map(core::ops::Not::not)
+ }
+}
+
+/// see [`neg`](core::ops::Not::not)
+pub trait ANeg<T, const N: usize> {
+ /// apply the [`not`](core::ops::Not::not) function to each element of this array.
+ fn neg(self) -> Self;
+}
+impl<T: core::ops::Neg<Output = T>, const N: usize> ANeg<T, N> for [T; N] {
+ fn neg(self) -> Self {
+ self.map(core::ops::Neg::neg)
+ }
+}
+
+/// Prelude for pervasive operations.
+pub mod prelude {
+ #[doc(inline)]
+ pub use super::{array_and_scalar::*, scalar_and_array::*, ANeg, ANot};
+}
+#[test]
+fn x() {
+ use prelude::*;
+ assert_eq!(2.mul([5, 2].add(5)), [20, 14]);
+}
diff --git a/src/tuple.rs b/src/tuple.rs
new file mode 100644
index 0000000..f88474f
--- /dev/null
+++ b/src/tuple.rs
@@ -0,0 +1,95 @@
+/// Turn a tuple into a array. Implemented for N≤32
+pub trait Array<const N: usize, T> {
+ /// Turn a tuple into a array
+ fn array(self) -> [T; N];
+}
+
+impl<T> Array<1, T> for (T,) {
+ fn array(self) -> [T; 1] {
+ [self.0]
+ }
+}
+
+/// Turn a array into a tuple. Implemented for N≤32
+pub trait Tuple<O> {
+ /// Turn a array into a tuple.
+ fn tuple(self) -> O;
+}
+
+impl<T> Tuple<(T,)> for [T; 1] {
+ fn tuple(self) -> (T,) {
+ let [t] = self;
+ (t,)
+ }
+}
+
+#[rustfmt::skip]
+// for n in range(1, 32):
+// print(f"impl <T> Tuple<(T{', T' * n})> for [T; {n + 1}] {{ fn tuple(self) -> (T{', T' * n}) {{ let [{', '.join([f't{n}' for n in range(1,n+2)])}] = self; ({', '.join([f't{n}' for n in range(1,n+2)])}) }} }}")
+// print(f"impl <T> Array<{n+1}, T> for (T{', T' * n}) {{ fn array(self) -> [T; {n + 1}] {{ [{', '.join([f'self.{n}' for n in range(0,n+1)])}] }} }}")
+mod rest {
+ use super::{Array,Tuple};
+ impl <T> Tuple<(T, T)> for [T; 2] { fn tuple(self) -> (T, T) { let [t1, t2] = self; (t1, t2) } }
+ impl <T> Array<2, T> for (T, T) { fn array(self) -> [T; 2] { [self.0, self.1] } }
+ impl <T> Tuple<(T, T, T)> for [T; 3] { fn tuple(self) -> (T, T, T) { let [t1, t2, t3] = self; (t1, t2, t3) } }
+ impl <T> Array<3, T> for (T, T, T) { fn array(self) -> [T; 3] { [self.0, self.1, self.2] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T)> for [T; 4] { fn tuple(self) -> (T, T, T, T) { let [t1, t2, t3, t4] = self; (t1, t2, t3, t4) } }
+ #[doc(hidden)] impl <T> Array<4, T> for (T, T, T, T) { fn array(self) -> [T; 4] { [self.0, self.1, self.2, self.3] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T)> for [T; 5] { fn tuple(self) -> (T, T, T, T, T) { let [t1, t2, t3, t4, t5] = self; (t1, t2, t3, t4, t5) } }
+ #[doc(hidden)] impl <T> Array<5, T> for (T, T, T, T, T) { fn array(self) -> [T; 5] { [self.0, self.1, self.2, self.3, self.4] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T)> for [T; 6] { fn tuple(self) -> (T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6] = self; (t1, t2, t3, t4, t5, t6) } }
+ #[doc(hidden)] impl <T> Array<6, T> for (T, T, T, T, T, T) { fn array(self) -> [T; 6] { [self.0, self.1, self.2, self.3, self.4, self.5] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T)> for [T; 7] { fn tuple(self) -> (T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7] = self; (t1, t2, t3, t4, t5, t6, t7) } }
+ #[doc(hidden)] impl <T> Array<7, T> for (T, T, T, T, T, T, T) { fn array(self) -> [T; 7] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T)> for [T; 8] { fn tuple(self) -> (T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8] = self; (t1, t2, t3, t4, t5, t6, t7, t8) } }
+ #[doc(hidden)] impl <T> Array<8, T> for (T, T, T, T, T, T, T, T) { fn array(self) -> [T; 8] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T)> for [T; 9] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9) } }
+ #[doc(hidden)] impl <T> Array<9, T> for (T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 9] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T)> for [T; 10] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) } }
+ #[doc(hidden)] impl <T> Array<10, T> for (T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 10] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) } }
+ #[doc(hidden)] impl <T> Array<11, T> for (T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 11] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) } }
+ #[doc(hidden)] impl <T> Array<12, T> for (T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 12] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 13] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) } }
+ #[doc(hidden)] impl <T> Array<13, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 13] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 14] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) } }
+ #[doc(hidden)] impl <T> Array<14, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 14] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 15] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) } }
+ #[doc(hidden)] impl <T> Array<15, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 15] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 16] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16) } }
+ #[doc(hidden)] impl <T> Array<16, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 16] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 17] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17) } }
+ #[doc(hidden)] impl <T> Array<17, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 17] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 18] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18) } }
+ #[doc(hidden)] impl <T> Array<18, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 18] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 19] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19) } }
+ #[doc(hidden)] impl <T> Array<19, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 19] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 20] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) } }
+ #[doc(hidden)] impl <T> Array<20, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 20] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 21] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21) } }
+ #[doc(hidden)] impl <T> Array<21, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 21] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 22] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22) } }
+ #[doc(hidden)] impl <T> Array<22, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 22] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 23] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23) } }
+ #[doc(hidden)] impl <T> Array<23, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 23] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 24] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24) } }
+ #[doc(hidden)] impl <T> Array<24, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 24] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 25] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25) } }
+ #[doc(hidden)] impl <T> Array<25, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 25] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 26] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26) } }
+ #[doc(hidden)] impl <T> Array<26, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 26] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24, self.25] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 27] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27) } }
+ #[doc(hidden)] impl <T> Array<27, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 27] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24, self.25, self.26] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 28] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28) } }
+ #[doc(hidden)] impl <T> Array<28, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 28] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24, self.25, self.26, self.27] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 29] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29) } }
+ #[doc(hidden)] impl <T> Array<29, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 29] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24, self.25, self.26, self.27, self.28] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 30] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30) } }
+ #[doc(hidden)] impl <T> Array<30, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 30] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24, self.25, self.26, self.27, self.28, self.29] } }
+ #[doc(hidden)] impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 31] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30, t31] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30, t31) } }
+ #[doc(hidden)] impl <T> Array<31, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 31] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24, self.25, self.26, self.27, self.28, self.29, self.30] } }
+ impl <T> Tuple<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 32] { fn tuple(self) -> (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { let [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30, t31, t32] = self; (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28, t29, t30, t31, t32) } }
+ impl <T> Array<32, T> for (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) { fn array(self) -> [T; 32] { [self.0, self.1, self.2, self.3, self.4, self.5, self.6, self.7, self.8, self.9, self.10, self.11, self.12, self.13, self.14, self.15, self.16, self.17, self.18, self.19, self.20, self.21, self.22, self.23, self.24, self.25, self.26, self.27, self.28, self.29, self.30, self.31] } }
+
+}