traits

Traits in Rust seem at least superficially similar to typeclasses in Haskell, however I've seen people write that there are some differences between them. I was wondering exactly what these differences are. At the basic level, there's not much difference, but they're still there. Haskell describes functions or values defined in a typeclass as 'methods', just as traits describe OOP methods in the objects they enclose. However, Haskell deals with these differently, treating them as individual values rather than pinning them to an object as OOP would lead one to do. This is about the most obvious

I am struggling with the basics of object safety. If I have this code struct S { x: i32 } trait Trait: Sized { fn f(&self) -> i32 where Self: Sized; } fn object_safety_dynamic(x: Trait) {} I receive fn object_safety_dynamic(x: Trait) { | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `traits::Trait` cannot be made into an object = note: the trait cannot require that `Self : Sized` When adding / changing :Sized as the trait's inheritance or f 's bound I receive slightly different error messages. Could someone explain: Why does this particular example not work? The chapter Trait Objects states "So

The following code won't compile due to two instances of this error: error[E0277]: the trait bound Self: std::marker::Sized is not satisfied I don't understand why Sized is required in this instance as both &self and &Any are pointers and the operation does not require knowledge of the size of the structure that implements the trait, it only requires knowledge of the pointer itself and the type it is converting from and to, which it will have because &self is generic when implemented inside a trait. I think this may be an instance of the compiler enforcing unnecessary constraints and I've

Consider these two traits: pub trait Foo { fn new(arg: u32) -> Self; } pub trait Bar<P>: Foo { fn with_parameter(arg: u32, parameter: P) -> Self; } I'd like to add the blanket impl: impl<T: Bar<P>, P: Default> Foo for T { fn new(arg: u32) -> Self { Self::with_parameter(arg, P::default()) } } But I get the compiler error: error[E0207]: the type parameter `P` is not constrained by the impl trait, self type, or predicates --> src/lib.rs:9:17 | 9 | impl<T: Bar<P>, P: Default> Foo for T { | ^ unconstrained type parameter I think I get this error because I'm violating trait coherence rules, but I

I have a design issue, when using something like : trait MyTrait<K: OtherTrait> { ... } impl<K: OtherTrait, M: MyTrait<K>> AnyTrait for M { ... } I cannot implement trait for this trait due to E207 error ("the type parameter K is not constrained by the impl trait, self type, or predicates"). Finding no way to get rid of this error, I apply this not-so-good-looking workaround (verbose and struct with no intrinsic value): use std::fmt; use std::marker::PhantomData; pub trait MyTrait<K: fmt::Display> { fn get_some_k(&self) -> Option<K>; } /* // This is my target impl but results in E207 due to K

This question already has an answer here: How do I return an instance of a trait from a method? 3 answers I have two enums, NormalColour and BoldColour , both of which implement the Colour trait. They contain Blue , BoldGreen , and so on. I'd like to return values of both of these types from the same function, treating them as though they're just a Colour value, calling the paint function on the result, but I can't find a way to coerce the Rust complier into doing this for me. I'd like to be able to write something like this: pub trait Colour { fn paint(&self, input: &str) -> String; } fn file

I have a struct that contains a function object: struct Foo<F> { func: F, } I want to add an Fn trait bound to the struct definition. The problem is: I do care about the first parameter (it has to be i32 ), but not the second one. What I actually want to write is something like this: struct Foo<F> where ∃ P so that F: Fn(i32, P), { func: F, } So in English: the type F has to be a function that takes two parameters, the first of which is an i32 (and the second one can be anything). The syntax above is obviously not valid. I thought about three potential solutions: The for<> syntax won't help

Is it at all possible to define functions inside of traits as having impl Trait return types? I want to create a trait that can be implemented by multiple structs so that the new() functions of all of them returns an object that they can all be used in the same way without having to write code specific to each one. #![feature(conservative_impl_trait)] trait A { fn new() -> impl A; } However, I get the following error: impl Trait not allowed outside of function and inherent method return types Is this just a limitation of the current implementation of impl Trait in Rust or am I using it wrong?

Is it possible to extend only some specific part from multiple classes? Example: class Walker { walk() { console.log("I am walking"); } // more functions } class Runner { run() { console.log("I am running"); } // more functions } // Make a class that inherits only the run and walk functions You can pick and choose which methods from other classes you want to add to an existing class as long as your new object has the instance data and methods that the methods you are adding expect to be on that object. class Walker { constructor() {} walk() { console.log("I am walking"); } // more functions }