Есть ли способ создать структуру на основе реализации признака?

Черты характера используются для определения общего поведения. В вашем примере вы хотите реализовать одну и ту же черту разными способами. Это противоречит назначению черты характера. Вместо того, чтобы иметь две структуры, как вы пытались, у вас, вероятно, должны быть две черты:

trait ThisWay {
    fn apply(&self) -> Vec<usize>;
}

trait ThatWay {
    fn apply(&self) -> Vec<usize>;
}

Теперь вы можете реализовать оба трейта для своей структуры:

struct Bar {
    vec: Vec<usize>,
}

impl ThisWay for Bar {
    fn apply(&self) -> Vec<usize> {
        self.vec.iter().map(|x| x.pow(2)).collect()
    }
}

impl ThatWay for Bar {
    fn apply(&self) -> Vec<usize> {
        self.vec.iter().map(|x| x + 2).collect()
    }
}

Поскольку Bar реализует ThisWay и ThatWay, теперь у него есть два определения для метода apply. Чтобы устранить неоднозначность между ними, мы должны использовать полностью квалифицированный синтаксис:

let this_bar = Bar::new(vec![1, 2, 3]);
println!("Method: {:?}", <Bar as ThisWay>::apply(&this_bar));
    
let that_bar = Bar::new(vec![1, 2, 3]);
println!("Method: {:?}", <Bar as ThatWay>::apply(&that_bar));

И, как и ожидалось, вы получите два разных результата:

Method: [1, 4, 9]
Method: [3, 4, 5]

В качестве альтернативы другому ответу вы также можете использовать что-то более похожее на ваш исходный пример, используя универсальные типы и типы структур нулевого размера в качестве маркеров того метода, который вы хотите использовать. Вот полный пример:

// PhantomData allows us to "use" a generic without having an actual field
use std::marker::PhantomData;

// These structs will be used to indicate which implementation we want
struct ThisWay;
struct ThatWay;

trait Trait { fn apply(&self) -> Vec<usize>; }

struct Bar<X> {
    vec: Vec<usize>,
    // This extra field is here to stop the compiler complaining about not using X
    _marker: PhantomData<X>,
}

impl<X> Bar<X> {
    pub fn new(vec: Vec<usize>) -> Self { Self { vec, _marker: PhantomData } }

    // Note the new "where" clause here - we can only implement this function if Bar<X> implements Trait
    pub fn test(&self) where Self: Trait {
        // Things here
        println!("Method: {:?}", self.apply()); 
        // Things there
    }
}

impl Trait for Bar<ThisWay> {
    fn apply(&self) -> Vec<usize> { self.vec.iter().map(|x| x.pow(2)).collect() }
}

impl Trait for Bar<ThatWay> {
    fn apply(&self) -> Vec<usize> { self.vec.iter().map(|x| x + 2).collect() }
}

fn main() {
   Bar::<ThisWay>::new(vec![1,2,3]).test();
   Bar::<ThatWay>::new(vec![1,2,3]).test();
}

При запуске вывод правильно отражает различные используемые функции:

Method: [1, 4, 9]
Method: [3, 4, 5]

Этот подход имеет семантику, отличную от другого ответа: в то время как другой ответ позволяет вам создать Bar, который может использоваться с обеими функциями, этот подход ограничивает вас одной реализацией на уровне типа, поскольку Bar<ThisWay> и Bar<ThatWay> - это два отдельных типа, которые каждый обеспечивает только одну apply функцию. Это может быть желательно для безопасности типов в некоторых сценариях, но может быть не тем, что вам нужно в этом конкретном случае.

// since x is declared as `Bar<ThatWay>`, we can only ever use the `ThatWay` implementation of `apply`/`test`
let x: Bar<ThatWay> = Bar::new(vec![1, 2, 3]);
x.test(); // -> Method: [3, 4, 5]