How to create a tuple from a vector?
Solution 1
You can't use Python-like list comprehension, as Rust doesn't have it. The closest thing is to do it explicitly via another iterator. You can't directly collect into a tuple, so you need another explicit step to convert the vector:
use std::str::FromStr;
fn main() {
let some_str = "123,321,312";
let num_pair_str = some_str.split(',').collect::<Vec<_>>();
if num_pair_str.len() == 3 {
let v = num_pair_str.iter().map(|s| i32::from_str(s).expect("failed to parse number"))
.collect::<Vec<_>>();
let num_pair: (i32, i32, i32) = (v[0], v[1], v[2]);
println!("Tuple {:?}", num_pair);
}
}
If you want to avoid the intermediate vectors you can do something like the following:
use std::str::FromStr;
fn main() {
let some_str = "123,321,312";
let it0 = some_str.split(',');
if it0.clone().count() == 3 {
let mut it = it0.map(|s| i32::from_str(s).expect("failed to parse number"));
let num_pair: (i32, i32, i32) =
(it.next().unwrap(), it.next().unwrap(), it.next().unwrap());
println!("Tuple {:?}", num_pair);
}
}
Solution 2
You can declare a trait with a method similar to Iterator::collect
and implement it to collect to various tuples sizes:
fn main() {
// Example with some simplifications
// Note that there is no extra allocation
let num_pair: (i32, i32, i32) = "123,321,312"
.split(',')
.map(|s| s.parse().expect("an i32"))
.try_collect()
.expect("a 3-tuple of i32");
assert_eq!(num_pair, (123, 321, 312));
}
trait TryCollect<T> {
fn try_collect(&mut self) -> Option<T>;
}
macro_rules! impl_try_collect_tuple {
() => { };
($A:ident $($I:ident)*) => {
impl_try_collect_tuple!($($I)*);
impl<$A: Iterator> TryCollect<($A::Item, $($I::Item),*)> for $A {
fn try_collect(&mut self) -> Option<($A::Item, $($I::Item),*)> {
let r = (try_opt!(self.next()),
// hack: we need to use $I in the expasion
$({ let a: $I::Item = try_opt!(self.next()); a}),* );
Some(r)
}
}
}
}
macro_rules! try_opt {
($e:expr) => (match $e { Some(e) => e, None => return None })
}
// implement TryCollect<T> where T is a tuple with size 1, 2, .., 10
impl_try_collect_tuple!(A A A A A A A A A A);
Other examples:
fn main() {
let mut iter = (0..7).into_iter();
let (a, b, c) = iter.try_collect().unwrap();
assert_eq!((a, b, c), (0, 1, 2));
let (d, e) = iter.try_collect().unwrap();
assert_eq!((d, e), (3, 4));
let (f,) = iter.try_collect().unwrap();
assert_eq!(f, 5);
let a: Option<(u32, u32)> = iter.try_collect();
assert_eq!(None, a);
}
Solution 3
EDIT: A simple one-liner solution: collect_tuple of the popular itertools
crate.
let iter = 1..3;
let (x, y) = iter.collect_tuple().unwrap(); // yeah!
Original answer
If you want better IDE type hinting, macros may not be a perfect solution. Here is my attempt:
fn tuple1<T>(a: &[T]) -> (&T) { (&a[0]) }
fn tuple2<T>(a: &[T]) -> (&T, &T) { (&a[0], &a[1]) }
fn tuple3<T>(a: &[T]) -> (&T, &T, &T) { (&a[0], &a[1], &a[2]) }
fn tuple4<T>(a: &[T]) -> (&T, &T, &T, &T) { (&a[0], &a[1], &a[2], &a[3]) }
fn tuple5<T>(a: &[T]) -> (&T, &T, &T, &T, &T) { (&a[0], &a[1], &a[2], &a[3], &a[4]) }
fn tuple6<T>(a: &[T]) -> (&T, &T, &T, &T, &T, &T) { (&a[0], &a[1], &a[2], &a[3], &a[4], &a[5]) }
Related videos on Youtube
ideasman42
Updated on June 04, 2022Comments
-
ideasman42 almost 2 years
Here's an example that splits a string and parses each item, putting it into a tuple whose size is known at compile time.
use std::str::FromStr; fn main() { let some_str = "123,321,312"; let num_pair_str = some_str.split(',').collect::<Vec<&str>>(); if num_pair_str.len() == 3 { let num_pair: (i32, i32, i32) = ( i32::from_str(num_pair_str[0]).expect("failed to parse number"), i32::from_str(num_pair_str[1]).expect("failed to parse number"), i32::from_str(num_pair_str[2]).expect("failed to parse number"), ); println!("Tuple {:?}", num_pair); } }
Is there a way to avoid repetition parsing the numbers?
This is an example of what it might look like if Rust supported Python-like comprehensions:
let num_pair: (i32, i32, i32) = ( i32::from_str(num_pair_str[i]).expect("failed to parse number") for i in 0..3 );
Is it possible to declare the tuple in a way that expands the vector?
-
rsalmei over 3 yearsWow, first recursive macro I've ever seen 👍
-
Charlie 木匠 almost 2 yearsWould you have the complete code? Thanks.