// Declares struct FnSliceIndexRet<T> // a type-level function (TypeFn implementor) from I to SliceIndexRet<I, T> typewit::type_fn! { struct FnSliceIndexRet;

impl<I: SliceIndex<T>> I => SliceIndexRet<I, T>

}

const fn slicerange(slice: &[T], range: Range) -> &[T] { let suffix = slice.splitat(range.start).1; suffix.split_at(range.end - range.start).0 }

```

When the wrong type is passed for the index, the compile-time error is the same as with normal generic functions: text error[E0277]: the trait bound `RangeFull: SliceIndex<{integer}>` is not satisfied --> src/main.rs:43:30 | 13 | assert_eq!(index(&array, ..), [13, 21]); | ----- ^^ the trait `SliceIndex<{integer}>` is not implemented for `RangeFull` | | | required by a bound introduced by this call | = help: the following other types implement trait `SliceIndex<T>`: std::ops::Range<usize> usize

Downcasting const generic type

This example demonstrates "downcasting" from a type with a const parameter to a concrete instance of that type.

This example requires the "const_marker" feature (enabled by default).

```rust use typewit::{const_marker::Usize, TypeEq};

asserteq!(*mutate(&mut Arr([])), Arr([])); asserteq!(mutate(&mut Arr([1])), Arr([1])); assert_eq!(mutate(&mut Arr([1, 2])), Arr([1, 2])); asserteq!(*mutate(&mut Arr([1, 2, 3])), Arr([1, 3, 6])); // this is different! asserteq!(*mutate(&mut Arr([1, 2, 3, 4])), Arr([1, 2, 3, 4]));

[derive(Debug, PartialEq)]

struct Arr([u8; N]);

fn mutate(arr: &mut Arr) -> &mut Arr { if let Ok(te) = Usize::.eq(Usize::<3>) { let tem = te // te is a TypeEq<Usize<N>, Usize<3>> .project::() // returns TypeEq<Arr<N>, Arr<3>> .in_mut(); // returns TypeEq<&mut Arr<N>, &mut Arr<3>>

    // `tem.to_right(arr)` downcasts `arr` to `&mut Arr<3>`
    tetra_sum(tem.to_right(arr));
}

arr

}

fn tetra_sum(arr: &mut Arr<3>) { arr.0[1] += arr.0[0]; arr.0[2] += arr.0[1]; }

// Declares struct GArr // a type-level function (TypeFn implementor) from Usize<N> to Arr<N> typewit::type_fn!{ struct GArr;

impl<const N: usize> Usize<N> => Arr<N>

} ```

Builder

Using a type witness to help encode a type-level enum, and to match on that type-level enum inside of a function.

The type-level enum is used to track the initialization of fields in a builder.

This example requires Rust 1.65.0, because it uses Generic Associated Types. ```rust use typewit::HasTypeWitness;

fn main() { // all default fields assert_eq!( StructBuilder::new().build(), Struct{foo: "default value".into(), bar: vec![3, 5, 8]}, );

// defaulted bar field
assert_eq!(
    StructBuilder::new().foo("hello").build(), 
    Struct{foo: "hello".into(), bar: vec![3, 5, 8]},
);

// defaulted foo field
assert_eq!(
    StructBuilder::new().bar([13, 21, 34]).build(), 
    Struct{foo: "default value".into(), bar: vec![13, 21, 34]},
);

// all initialized fields
assert_eq!(
    StructBuilder::new().foo("world").bar([55, 89]).build(), 
    Struct{foo: "world".into(), bar: vec![55, 89]},
);

}

[derive(Debug, PartialEq, Eq)]

struct Struct { foo: String, bar: Vec, }

struct StructBuilder { // If FooInit is Uninit, then this field is a () // If FooInit is Init, then this field is a String foo: BuilderField,

// If `BarInit` is `Uninit`, then this field is a `()`
// If `BarInit` is `Init`, then this field is a `Vec<u32>`
bar: BuilderField<BarInit, Vec<u32>>,

}

impl StructBuilder { pub const fn new() -> Self { Self { foo: (), bar: (), } } }

impl StructBuilder { /// Sets the foo field pub fn foo(self, foo: impl Into) -> StructBuilder { StructBuilder { foo: foo.into(), bar: self.bar, } }

/// Sets the `bar` field
pub fn bar(self, bar: impl Into<Vec<u32>>) -> StructBuilder<FooInit, Init> {
    StructBuilder {
        foo: self.foo,
        bar: bar.into(),
    }
}

/// Builds `Struct`, 
/// providing default values for fields that haven't been set.
pub fn build(self) -> Struct {
    typewit::type_fn! {
        struct HelperFn<T>;
        impl<I: InitState> I => BuilderField<I, T>
    }

    Struct {
        // matching on the type-level `InitState` enum by using `InitWit`.
        // `WITNESS` comes from the `HasTypeWitness` trait
        foo: match FooInit::WITNESS {
            // `te: TypeEq<FooInit, Init>`
            InitWit::InitW(te) => {
                te.map(HelperFn::NEW) //: TypeEq<BuilderField<FooInit, String>, String>
                  .to_right(self.foo)
            }
            InitWit::UninitW(_) => "default value".to_string(),
        },
        bar: match BarInit::WITNESS {
            // `te: TypeEq<BarInit, Init>`
            InitWit::InitW(te) => {
                te.map(HelperFn::NEW) //: TypeEq<BuilderField<BarInit, Vec<u32>>, Vec<u32>>
                  .to_right(self.bar)
            }
            InitWit::UninitW(_) => vec![3, 5, 8],
        },
    }
}

}

// Emulates a type-level enum InitState { Init, Uninit } trait InitState: Sized + HasTypeWitness> { // How a builder represents an initialized/uninitialized field. // If Self is Uninit, then this is (). // If Self is Init, then this is T. type BuilderField; }

// If I is Uninit, then this evaluates to () // If I is Init, then this evaluates to T type BuilderField = ::BuilderField::;