typle

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

★ 9 Open GitHub ↗

Rust macro to create items for different sized tuples

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# typle

The `typle` crate provides the ability to constrain generic arguments to be
tuples and supports manipulation of the tuple components.

It allows you to write a single function or impl that "unrolls" into multiple
concrete versions: one for `(T0,)`, one for `(T0, T1)`, and so on.

With `typle` you can easily define a function to zip a pair of tuples
into a tuple of pairs:

```rust
#[typle(Tuple for 0..=12)]
pub fn zip<A: Tuple, B: Tuple>(a: A, b: B) -> (typle! {
 i in .. => (A<{i}>, B<{i}>)
}) {
 (typle! {
 i in .. => (a[[i]], b[[i]])
 })
}
```

The `#[typle]` attribute macro introduces `Tuple` which acts like a trait within
the annotated item. The types `A` and `B` are generic but are constrained by the
`Tuple` bound to be tuples. The tuples can have 0 to 12 components of any
(sized) type, but both tuples must have the same length.

`A<{i}>` refers to the type of the tuple component at index `i`. `a[[i]]` refers
to the value of the tuple component at index `i` (unrolls to `a.0`, `a.1`,...).

The `typle!` macro loops over a range returning a new sequence with the
specified components. For the function return type it creates a type tuple:
`((A<0>, B<0>), (A<1>, B<1>),...)`. In the function body it creates a value tuple:
`((a.0, b.0), (a.1, b.1),...)`.

```rust
assert_eq!(
    zip(("LHR", "FCO", "ZRH"), (51.5, 41.8, 47.5)),
    (("LHR", 51.5), ("FCO", 41.8), ("ZRH", 47.5))
);
assert_eq!(
    zip((2.0, "test"), (Some(9u8), ('a', 'b'))),
    ((2.0, Some(9u8)), ("test", ('a', 'b')))
);
assert_eq!(
    zip((), ()),
    ()
);
```

A common use of `typle` is to implement a trait for tuples of multiple lengths.
Compared to using declarative macros, the `typle` code looks more Rust-like and
provides access to individual components and their position.

```rust
trait HandleStuff {
 type Output;

fn handle_stuff(&self, input: I) -> Self::Output;
}

struct MultipleHandlers<T> {
 handlers: T,
}

#[typle(Tuple for 1..=3)]
impl<I, T> HandleStuff for MultipleHandlers<T>
where
 T: Tuple, // `T` is a tuple with 1 to 3 components.
 T<_>: HandleStuff, // All components implement `HandleStuff`.
 // Conditionally add `Clone` bound to `I`:
 typle!(=> if T::LEN > 1 { I: Clone }): Tuple::Bounds,
{
 // Return a tuple of the output from each handler.
 type Output = (typle! {i in .. => T<{i}>::Output});

fn handle_stuff(&self, input: I) -> Self::Output {
        (
            typle! {
                i in ..T::LAST =>
                    self.handlers[[i]].handle_stuff(input.clone())
            },
            // Avoid expensive clone for the last handler.
            self.handlers[[T::LAST]].handle_stuff(input),
        )
    }
}
```

This generates the implementations
```rust
impl<I, T0> HandleStuff for MultipleHandlers<(T0,)>
where
 T0: HandleStuff,
{
 type Output = (T0::Output,);
 fn handle_stuff(&self, input: I) -> Self::Output {
 (self.handlers.0.handle_stuff(input),)
 }
}
impl<I, T0, T1> HandleStuff for MultipleHandlers<(T0, T1)>
where
 T0: HandleStuff,
 T1: HandleStuff,
 I: Clone,
{
 type Output = (T0::Output, T1::Output);
 fn handle_stuff(&self, input: I) -> Self::Output {
 (
 self.handlers.0.handle_stuff(input.clone()),
 self.handlers.1.handle_stuff(input),
 )
 }
}
impl<I, T0, T1, T2> HandleStuff for MultipleHandlers<(T0, T1, T2)>
where
 T0: HandleStuff,
 T1: HandleStuff,
 T2: HandleStuff,
 I: Clone,
{
 type Output = (T0::Output, T1::Output, T2::Output);
 fn handle_stuff(&self, input: I) -> Self::Output {
 (
 self.handlers.0.handle_stuff(input.clone()),
 self.handlers.1.handle_stuff(input.clone()),
 self.handlers.2.handle_stuff(input),
 )
 }
}
```
See the [crate documentation](https://docs.rs/typle/) for more examples.

typle

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README