I think Miles Sabin solution is way too complex. Scala’s collection already have the necessary machinery to make it work, with a very small change: import scala.collection.TraversableLike def multiMinBy[A, B: Ordering, C <: Traversable[A]] (xs: C with TraversableLike[A, C]) (f: A => B): C = { val minVal = f(xs minBy f) xs filter (f(_) … Read more
Dart does not support instantiating from a generic type parameter. It doesn’t matter if you want to use a named or default constructor (T() also does not work). There is probably a way to do that on the server, where dart:mirrors (reflection) is available (not tried myself yet), but not in Flutter or the browser. … Read more
what does it mean “generic type parameters that are filled in with concrete type parameters when the trait is used” An example that won’t work is when the type parameter is part of a method: trait Foo { fn foo<T>(t: T) {} } When a function has a type parameter, Rust will monomorphize the function … Read more
The error comes from the fact that you can’t create trait objects for DnsRecordData due to the trait not being “object-safe”. This concept is explained in the trait objects section of The Rust Programming Language. In your particular case, the trait contains a generic method. To create a trait object, the compiler has to synthesize … Read more
Instead of flattening out the nested option, as the other answer shows, I’d advocate that you never create an Option<Option<T>> that you need to flatten in the first place. In the majority of cases I’ve seen, it’s because someone misuses Option::map when they should have used Option::and_then: fn main() { let input = user_input(); let … Read more
It’s not explicitly writing the constraints that is the issue, it’s that the syntax is not so nice that you can place a member constraint on a parameter and then invoke the member in the usual way. The body of walk_the_creature and walk_the_creature2 would be the same here: let inline walk_the_creature_2 (creature:^a when ^a:(member Walk … Read more
As brian mentioned, there is some built-in support for generic arithmethic and you can use ‘static constraints’ which allow you to define some generic functions yourself (although this is a bit limited). In addition to this, you can also use dynamic ‘numeric associations’, which is a bit slower when using in a function, but it … Read more
This is a case for Higher Ranked Trait Bounds (HRTB). The point is that you do not want &L to implement IntoIterator<Item = &T> for one lifetime but for all potential lifetimes that L may happen to have. In this case, you need to use a Higher Ranked Trait Bound: for<‘a> will take care of … Read more
It’s a placeholder. In this context, it means that there isn’t enough information for the compiler to infer a type. You can use this in your code to make the compiler infer the type for you. For example: pub fn main() { let letters: Vec<_> = vec![“a”, “b”, “c”]; // Vec<&str> } This is particularly … Read more
I think the key to understanding what is going on here is distinguishing between things that are determined dynamically at runtime, and things that are determined statically at compile time. It doesn’t help that, in most languages like Java, protocols (or interfaces) are all about getting polymorphic behavior at run time, whereas in Swift, protocols … Read more