// rustfmt-spaces_within_parens_and_brackets: true
// Spaces within parens and brackets

fn lorem<T: Eq>(t: T) {
    let lorem = (ipsum, dolor);
    let lorem: [usize; 2] = [ipsum, dolor];
}

enum E {
    A(u32),
    B(u32, u32),
    C(u32, u32, u32),
    D(),
}

struct TupleStruct0();
struct TupleStruct1(u32);
struct TupleStruct2(u32, u32);

fn fooEmpty() {}

fn foo(e: E, _: u32) -> (u32, u32) {
    // Tuples
    let t1 = ();
    let t2 = (1,);
    let t3 = (1, 2);

    let ts0 = TupleStruct0();
    let ts1 = TupleStruct1(1);
    let ts2 = TupleStruct2(1, 2);

    // Tuple pattern
    let (a,b,c) = (1,2,3);

    // Expressions
    let x = (1 + 2) * (3);

    // Function call
    fooEmpty();
    foo(1, 2);

    // Pattern matching
    match e {
        A(_) => (),
        B(_, _) => (),
        C(..) => (),
        D => (),
    }

    (1,2)
}

struct Foo<T> {
    i: T,
}

struct Bar<T, E> {
    i: T,
    e: E,
}

struct Foo<'a> {
    i: &'a str,
}

enum E<T> {
    T(T),
}

enum E<T, S> {
    T(T),
    S(S),
}

fn foo<T>(a: T) {
    foo::<u32>(10);
}

fn foo<T, E>(a: T, b: E) {
    foo::<u32, str>(10, "bar");
}

fn foo<T: Send, E: Send>(a: T, b: E) {
    foo::<u32, str>(10, "bar");

    let opt: Option<u32>;
    let res: Result<u32, String>;
}

fn foo<'a>(a: &'a str) {
    foo("foo");
}

fn foo<'a, 'b>(a: &'a str, b: &'b str) {
    foo("foo", "bar");
}

impl Foo {
    fn bar() {
        <Foo as Foo>::bar();
    }
}

trait MyTrait<A, D> {}
impl<A: Send, D: Send> MyTrait<A, D> for Foo {}

fn foo() where for<'a> u32: 'a {}

fn main() {
    let arr: [i32; 5] = [1, 2, 3, 4, 5];
    let arr: [i32; 500] = [0; 500];

    let v = vec![1, 2, 3];
    assert_eq!(arr, [1, 2, 3]);

    let i = arr[0];

    let slice = &arr[1..2];

    let line100_________________________________________________________________________ = [1, 2];
    let line101__________________________________________________________________________ = [1, 2];
    let line102___________________________________________________________________________ = [1, 2];
    let line103____________________________________________________________________________ = [1, 2];
    let line104_____________________________________________________________________________ = [1, 2];

    let line100_____________________________________________________________________ = vec![1, 2];
    let line101______________________________________________________________________ = vec![1, 2];
    let line102_______________________________________________________________________ = vec![1, 2];
    let line103________________________________________________________________________ = vec![1, 2];
    let line104_________________________________________________________________________ = vec![1, 2];
}

fn f(slice: &[i32]) {}