Expected type parameter, found struct

I dont understand why this doesn't work:

trait KKK {
    fn hi();
}

struct Test<A>
where A : KKK {
    var : A,
}

impl<A> Test<A>
where A : KKK {
    fn haha(&mut self) {self.var = Test2{};}
}

struct Test2 {}

impl KKK for Test2 {
    fn hi() {}
}

fn main() {
    let ins2 = Test{var : Test2{}};
    ins2.haha();
}

I have this error:

error[E0308]: mismatched types
  --> trait.rs:12:36
   |
12 |     fn haha(&mut self) {self.var = Test2{};}
   |                                    ^^^^^^^ expected type parameter, found struct `Test2`
   |
   = note: expected type `A`
              found type `Test2`

error: aborting due to previous error

I can assign a Test2 instance to ins2's var in main, but I cant assign to var inside haha?
How do I modify haha to allow me assign any struct that implements KKK to var?

Because A can be type other than Test2 which also impls KKK. Assuming there's Test3 which also impls KKK, it's obvious that we can't call .haha() on Test<Test3>, as it's var is not a Test2.

If you want it to work only in case var is Test2, then:

impl Test<Test2> {
    fn haha(&mut self) {self.var = Test2{};}
}

If you want it to be able to use Test2 and some other type, then:

struct Test {
    var: Box<dyn A>,
}

or require A: From<Test2>.

Test<> is a container type. If the code would compile that means you can store objects of different type then the argument.
This also worked for me

trait KKK {
    fn hi();
}

struct Test<A>
    where A : KKK {
    var : A,
}

impl<A> Test<A>
    where A : KKK + Default {
    fn haha(&mut self) {self.var = A::default();}
}

#[derive(Default)]
struct Test2 {}

impl KKK for Test2 {
    fn hi() {}
}

#[derive(Default)]
struct Test3 {}

impl KKK for Test3 {
    fn hi() {}
}

impl Test3 {
    fn lol(&self) {}
}

fn main() {
    let mut ins2 = Test{var : Test2{}};
    ins2.haha();

    let mut ins3 = Test{var : Test3{}};
    ins3.haha(); // replace with Test2 ????
    ins3.var.lol();
}