Skip to content

Commit c292d61

Browse files
suptalentdevsuptalentdev
committed
Run rustfmt-preview
1 parent 033f598 commit c292d61

File tree

9 files changed

+123
-92
lines changed

9 files changed

+123
-92
lines changed

‎src/functional.rs

+12-10
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
//! Functional programming with generic sequences
22
3-
use core::iter::FromIterator;
4-
53
use super::ArrayLength;
4+
use core::iter::FromIterator;
65
use sequence::*;
76

87
/// Defines the relationship between one generic sequence and another,
@@ -12,13 +11,13 @@ where
1211
Self::Length: ArrayLength<U>,
1312
{
1413
/// Mapped sequence type
15-
type Mapped: GenericSequence<U, Length=Self::Length>;
14+
type Mapped: GenericSequence<U, Length = Self::Length>;
1615
}
1716

1817
unsafe impl<'a, T, U, S: MappedGenericSequence<T, U>> MappedGenericSequence<T, U> for &'a S
1918
where
2019
&'a S: GenericSequence<T>,
21-
S: GenericSequence<T, Length=<&'a S as GenericSequence<T>>::Length>,
20+
S: GenericSequence<T, Length = <&'a S as GenericSequence<T>>::Length>,
2221
<S as GenericSequence<T>>::Length: ArrayLength<U>,
2322
{
2423
type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
@@ -27,14 +26,15 @@ where
2726
unsafe impl<'a, T, U, S: MappedGenericSequence<T, U>> MappedGenericSequence<T, U> for &'a mut S
2827
where
2928
&'a mut S: GenericSequence<T>,
30-
S: GenericSequence<T, Length=<&'a mut S as GenericSequence<T>>::Length>,
29+
S: GenericSequence<T, Length = <&'a mut S as GenericSequence<T>>::Length>,
3130
<S as GenericSequence<T>>::Length: ArrayLength<U>,
3231
{
3332
type Mapped = <S as MappedGenericSequence<T, U>>::Mapped;
3433
}
3534

3635
/// Accessor type for a mapped generic sequence
37-
pub type MappedSequence<S, T, U> = <<S as MappedGenericSequence<T, U>>::Mapped as GenericSequence<U>>::Sequence;
36+
pub type MappedSequence<S, T, U> =
37+
<<S as MappedGenericSequence<T, U>>::Mapped as GenericSequence<U>>::Sequence;
3838

3939
/// Defines functional programming methods for generic sequences
4040
pub unsafe trait FunctionalSequence<T>: GenericSequence<T> {
@@ -60,9 +60,9 @@ pub unsafe trait FunctionalSequence<T>: GenericSequence<T> {
6060
fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
6161
where
6262
Self: MappedGenericSequence<T, U>,
63-
Rhs: MappedGenericSequence<B, U, Mapped=MappedSequence<Self, T, U>>,
63+
Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>>,
6464
Self::Length: ArrayLength<B> + ArrayLength<U>,
65-
Rhs: GenericSequence<B, Length=Self::Length>,
65+
Rhs: GenericSequence<B, Length = Self::Length>,
6666
F: FnMut(Self::Item, Rhs::Item) -> U,
6767
{
6868
rhs.inverted_zip2(self, f)
@@ -82,9 +82,11 @@ pub unsafe trait FunctionalSequence<T>: GenericSequence<T> {
8282
unsafe impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a S
8383
where
8484
&'a S: GenericSequence<T>,
85-
{}
85+
{
86+
}
8687

8788
unsafe impl<'a, T, S: GenericSequence<T>> FunctionalSequence<T> for &'a mut S
8889
where
8990
&'a mut S: GenericSequence<T>,
90-
{}
91+
{
92+
}

‎src/hex.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -16,10 +16,10 @@
1616
//!
1717
1818
use {ArrayLength, GenericArray};
19+
use core::cmp::min;
1920
use core::fmt;
2021
use core::ops::Add;
2122
use core::str;
22-
use core::cmp::min;
2323
use typenum::*;
2424

2525
static LOWER_CHARS: &'static [u8] = b"0123456789abcdef";
@@ -31,7 +31,7 @@ where
3131
<T as Add<T>>::Output: ArrayLength<u8>,
3232
{
3333
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
34-
let max_digits = f.precision().unwrap_or_else(|| self.len()*2);
34+
let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);
3535
let max_hex = (max_digits >> 1) + (max_digits & 1);
3636

3737
if T::to_usize() < 1024 {
@@ -69,7 +69,7 @@ where
6969
<T as Add<T>>::Output: ArrayLength<u8>,
7070
{
7171
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
72-
let max_digits = f.precision().unwrap_or_else(|| self.len()*2);
72+
let max_digits = f.precision().unwrap_or_else(|| self.len() * 2);
7373
let max_hex = (max_digits >> 1) + (max_digits & 1);
7474

7575
if T::to_usize() < 1024 {

‎src/impls.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,10 @@
1+
use super::{ArrayLength, GenericArray};
12
use core::borrow::{Borrow, BorrowMut};
23
use core::cmp::Ordering;
34
use core::fmt::{self, Debug};
45
use core::hash::{Hash, Hasher};
5-
6-
use super::{ArrayLength, GenericArray};
7-
use sequence::*;
86
use functional::*;
7+
use sequence::*;
98

109
impl<T: Default, N> Default for GenericArray<T, N>
1110
where

‎src/iter.rs

+3-7
Original file line numberDiff line numberDiff line change
@@ -57,9 +57,7 @@ where
5757
#[inline]
5858
fn next(&mut self) -> Option<T> {
5959
if self.index < self.index_back {
60-
let p = unsafe {
61-
Some(ptr::read(self.array.get_unchecked(self.index)))
62-
};
60+
let p = unsafe { Some(ptr::read(self.array.get_unchecked(self.index))) };
6361

6462
self.index += 1;
6563

@@ -107,9 +105,7 @@ where
107105
if self.index < self.index_back {
108106
self.index_back -= 1;
109107

110-
unsafe {
111-
Some(ptr::read(self.array.get_unchecked(self.index_back)))
112-
}
108+
unsafe { Some(ptr::read(self.array.get_unchecked(self.index_back))) }
113109
} else {
114110
None
115111
}
@@ -123,4 +119,4 @@ where
123119
fn len(&self) -> usize {
124120
self.index_back - self.index
125121
}
126-
}
122+
}

‎src/lib.rs

+53-29
Original file line numberDiff line numberDiff line change
@@ -50,10 +50,10 @@ mod impls;
5050
pub mod impl_serde;
5151

5252
use core::{mem, ptr, slice};
53+
use core::iter::FromIterator;
5354
use core::marker::PhantomData;
5455
use core::mem::ManuallyDrop;
5556
use core::ops::{Deref, DerefMut};
56-
use core::iter::FromIterator;
5757
use typenum::bit::{B0, B1};
5858
use typenum::uint::{UInt, UTerm, Unsigned};
5959

@@ -63,10 +63,9 @@ pub mod iter;
6363
pub mod sequence;
6464
pub mod functional;
6565

66-
use sequence::*;
6766
use functional::*;
68-
6967
pub use iter::GenericArrayIter;
68+
use sequence::*;
7069

7170
/// Trait making `GenericArray` work, marking types to be used as length of an array
7271
pub unsafe trait ArrayLength<T>: Unsigned {
@@ -220,7 +219,7 @@ impl<T, N: ArrayLength<T>> Drop for ArrayConsumer<T, N> {
220219

221220
impl<'a, T: 'a, N> IntoIterator for &'a GenericArray<T, N>
222221
where
223-
N: ArrayLength<T>
222+
N: ArrayLength<T>,
224223
{
225224
type IntoIter = slice::Iter<'a, T>;
226225
type Item = &'a T;
@@ -232,7 +231,7 @@ where
232231

233232
impl<'a, T: 'a, N> IntoIterator for &'a mut GenericArray<T, N>
234233
where
235-
N: ArrayLength<T>
234+
N: ArrayLength<T>,
236235
{
237236
type IntoIter = slice::IterMut<'a, T>;
238237
type Item = &'a mut T;
@@ -271,13 +270,16 @@ where
271270
#[inline(never)]
272271
#[cold]
273272
fn from_iter_length_fail(length: usize, expected: usize) -> ! {
274-
panic!("GenericArray::from_iter received {} elements but expected {}", length, expected);
273+
panic!(
274+
"GenericArray::from_iter received {} elements but expected {}",
275+
length, expected
276+
);
275277
}
276278

277279
unsafe impl<T, N> GenericSequence<T> for GenericArray<T, N>
278280
where
279281
N: ArrayLength<T>,
280-
Self: IntoIterator<Item=T>,
282+
Self: IntoIterator<Item = T>,
281283
{
282284
type Length = N;
283285
type Sequence = Self;
@@ -300,20 +302,29 @@ where
300302
}
301303

302304
#[doc(hidden)]
303-
fn inverted_zip<B, U, F>(self, lhs: GenericArray<B, Self::Length>, mut f: F) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
305+
fn inverted_zip<B, U, F>(
306+
self,
307+
lhs: GenericArray<B, Self::Length>,
308+
mut f: F,
309+
) -> MappedSequence<GenericArray<B, Self::Length>, B, U>
304310
where
305-
GenericArray<B, Self::Length>:
306-
GenericSequence<B, Length=Self::Length> +
307-
MappedGenericSequence<B, U>,
311+
GenericArray<B, Self::Length>: GenericSequence<B, Length = Self::Length>
312+
+ MappedGenericSequence<B, U>,
308313
Self: MappedGenericSequence<T, U>,
309314
Self::Length: ArrayLength<B> + ArrayLength<U>,
310-
F: FnMut(B, Self::Item) -> U
315+
F: FnMut(B, Self::Item) -> U,
311316
{
312317
let mut left = ArrayConsumer::new(lhs);
313318
let mut right = ArrayConsumer::new(self);
314319

315-
let ArrayConsumer { array: ref left_array, position: ref mut left_position } = left;
316-
let ArrayConsumer { array: ref right_array, position: ref mut right_position } = right;
320+
let ArrayConsumer {
321+
array: ref left_array,
322+
position: ref mut left_position,
323+
} = left;
324+
let ArrayConsumer {
325+
array: ref right_array,
326+
position: ref mut right_position,
327+
} = right;
317328

318329
FromIterator::from_iter(left_array.iter().zip(right_array.iter()).map(|(l, r)| {
319330
let left_value = unsafe { ptr::read(l) };
@@ -329,37 +340,44 @@ where
329340
#[doc(hidden)]
330341
fn inverted_zip2<B, Lhs, U, F>(self, lhs: Lhs, mut f: F) -> MappedSequence<Lhs, B, U>
331342
where
332-
Lhs: GenericSequence<B, Length=Self::Length> + MappedGenericSequence<B, U>,
343+
Lhs: GenericSequence<B, Length = Self::Length> + MappedGenericSequence<B, U>,
333344
Self: MappedGenericSequence<T, U>,
334345
Self::Length: ArrayLength<B> + ArrayLength<U>,
335-
F: FnMut(Lhs::Item, Self::Item) -> U
346+
F: FnMut(Lhs::Item, Self::Item) -> U,
336347
{
337348
let mut right = ArrayConsumer::new(self);
338349

339-
let ArrayConsumer { array: ref right_array, position: ref mut right_position } = right;
350+
let ArrayConsumer {
351+
array: ref right_array,
352+
position: ref mut right_position,
353+
} = right;
340354

341-
FromIterator::from_iter(lhs.into_iter().zip(right_array.iter()).map(|(left_value, r)| {
342-
let right_value = unsafe { ptr::read(r) };
355+
FromIterator::from_iter(
356+
lhs.into_iter()
357+
.zip(right_array.iter())
358+
.map(|(left_value, r)| {
359+
let right_value = unsafe { ptr::read(r) };
343360

344-
*right_position += 1;
361+
*right_position += 1;
345362

346-
f(left_value, right_value)
347-
}))
363+
f(left_value, right_value)
364+
}),
365+
)
348366
}
349367
}
350368

351369
unsafe impl<T, U, N> MappedGenericSequence<T, U> for GenericArray<T, N>
352370
where
353371
N: ArrayLength<T> + ArrayLength<U>,
354-
GenericArray<U, N>: GenericSequence<U, Length=N>,
372+
GenericArray<U, N>: GenericSequence<U, Length = N>,
355373
{
356374
type Mapped = GenericArray<U, N>;
357375
}
358376

359377
unsafe impl<T, N> FunctionalSequence<T> for GenericArray<T, N>
360378
where
361379
N: ArrayLength<T>,
362-
Self: GenericSequence<T, Item=T, Length=N>
380+
Self: GenericSequence<T, Item = T, Length = N>,
363381
{
364382
fn map<U, F>(self, mut f: F) -> MappedSequence<Self, T, U>
365383
where
@@ -369,7 +387,10 @@ where
369387
{
370388
let mut source = ArrayConsumer::new(self);
371389

372-
let ArrayConsumer { ref array, ref mut position } = source;
390+
let ArrayConsumer {
391+
ref array,
392+
ref mut position,
393+
} = source;
373394

374395
FromIterator::from_iter(array.iter().map(|src| {
375396
let value = unsafe { ptr::read(src) };
@@ -384,21 +405,24 @@ where
384405
fn zip<B, Rhs, U, F>(self, rhs: Rhs, f: F) -> MappedSequence<Self, T, U>
385406
where
386407
Self: MappedGenericSequence<T, U>,
387-
Rhs: MappedGenericSequence<B, U, Mapped=MappedSequence<Self, T, U>>,
408+
Rhs: MappedGenericSequence<B, U, Mapped = MappedSequence<Self, T, U>>,
388409
Self::Length: ArrayLength<B> + ArrayLength<U>,
389-
Rhs: GenericSequence<B, Length=Self::Length>,
410+
Rhs: GenericSequence<B, Length = Self::Length>,
390411
F: FnMut(T, Rhs::Item) -> U,
391412
{
392413
rhs.inverted_zip(self, f)
393414
}
394415

395416
fn fold<U, F>(self, init: U, mut f: F) -> U
396417
where
397-
F: FnMut(U, T) -> U
418+
F: FnMut(U, T) -> U,
398419
{
399420
let mut source = ArrayConsumer::new(self);
400421

401-
let ArrayConsumer { ref array, ref mut position } = source;
422+
let ArrayConsumer {
423+
ref array,
424+
ref mut position,
425+
} = source;
402426

403427
array.iter().fold(init, |acc, src| {
404428
let value = unsafe { ptr::read(src) };

0 commit comments

Comments
 (0)