zu erstellen aus einem Tupel ein Array

Question

ich so einen Array aus einem Tupel erstellen:

let a = (1, 2, 3); 
let b = [a.0, a.1, a.2]; 

Gibt es eine Möglichkeit, es zu tun, ohne jedes Element des Tupels zu benennen? Etwas wie:

let b = a.to_array(); 

Answer 1

Es gibt keine solche Funktionalität im Moment, aber es wäre durchaus möglich, den Satz von Implementierungen des From Charakterzug erweitern diese usecase zu decken (und deren Rückseite).

würde diese Erweiterung wegen der Waise Regeln in der core Kiste sein, aber wir können es leicht mit kundenspezifischen Merkmalen zeigen:

use std::convert::Into; 

trait MyFrom<T> { 
    fn my_from(t: T) -> Self; 
} 

trait MyInto<U> { 
    fn my_into(self) -> U; 
} 

impl<T, U> MyInto<U> for T 
    where 
     U: MyFrom<T> 
{ 
    fn my_into(self) -> U { <U as MyFrom<T>>::my_from(self) } 
} 

impl<T> MyFrom<()> for [T; 0] { 
    fn my_from(_:()) -> Self { [] } 
} 

impl<T, A> MyFrom<(A,)> for [T; 1] 
    where 
     A: Into<T>, 
{ 
    fn my_from(t: (A,)) -> Self { [t.0.into()] } 
} 

impl<T, A, B> MyFrom<(A, B)> for [T; 2] 
    where 
     A: Into<T>, 
     B: Into<T>, 
{ 
    fn my_from(t: (A, B)) -> Self { [t.0.into(), t.1.into()] } 
} 

Einmal definieren, es ist genug, um einfach zu bedienen:

fn main() { 
    { 
     let array: [i64; 0] =().my_into(); 
     println!("{:?}", array); 
    } 
    { 
     let array: [i64; 1] = (1u32,).my_into(); 
     println!("{:?}", array); 
    } 
    { 
     let array: [i64; 2] = (1u32, 2i16).my_into(); 
     println!("{:?}", array); 
    } 
} 

druckt:

[] 
[1] 
[1, 2] 

Die umgekehrte Implementierung wäre so einfach, es gibt nichts mysteriöses hier ist es nur Vortex (Hurra für Makros!).

Answer 2

Nein, gibt es nicht. Außerdem können Sie nicht einmal über Tupel iterieren. Das Tupel ist heterogen, daher ist es für eine Umwandlung in einen homogenen Typ wie einen Vektor oder ein Array ungeeignet.

Sie könnten ein Makro schreiben, um Iterationen über den Inhalt eines Tupels mit einer generischen Länge zu erlauben und sie zu sammeln (solange alle Elemente desselben Typs sind), aber Sie müssten trotzdem auf jedes Element zugreifen/dieses verarbeiten individuell.