covariance

Follow up question to a previous question , this has been identified as a co-variance issue. Taking this one step further, if I modify IFactory as follows: class Program { static void Main(string[] args) { IFactory<IProduct> factory = new Factory(); } } class Factory : IFactory<Product> { } class Product : IProduct { } interface IFactory<out T> where T : IProduct { List<T> MakeStuff(); } interface IProduct { } I get: Invalid variance: The type parameter T must be invariantly valid on Sandbox.IFactory.MakeStuff(). T is covariant. Why is this not invariantly valid? How can/should this be

I have a Dictionary<string, List<string>> and would like to expose the member as read only. I see that I can return it as a IReadOnlyDictionary<string, List<string>> , but I can't figure out how to return it as an IReadOnlyDictionary<string, IReadOnlyList<string>> . Is there a way to do this? In c++ I'd just be using const, but C# doesn't have that. Note that simply using a IReadOnlyDictionary does not help in this case, because I want the values to be read only as well. It appears the only way to do this is build another IReadOnlyDictionary, and add IReadOnlyList to them. Another option,

So, I've fitted a linear mixed model with two random intercepts in R: Y = X beta + Z b + e_i, where b ~ MVN (0, Sigma) ; X and Z are the fixed- and random-effects model matrices respectively, and beta and b are the fixed-effect parameters and random-effects BLUPs/conditional modes. I would like to get my hands on the underlying covariance matrix of b , which doesn't seem to be a trivial thing in lme4 package. You can get only the variances by VarCorr , not the actual correlation matrix. According to one of the package vignettes (page 2), you can calculate the covariance of beta: e_i * lambda *

Ah, SO came back just in time. I am getting a strange error: 'B::blah': overriding virtual function return type differs and is not covariant from 'A::blah' Here is the code causing the problem: class A { public: class Inner { }; virtual Inner blah() = 0; }; class B : public A { public: class Inner2 : public Inner { }; Inner2 blah() { return Inner2(); } }; I looked up the error, and according to a page I found on the Microsoft website , one of the ways types can be covariant is if: the class in the return type of B::f is the same class as the class in the return type of D::f or, is an

List("a").contains(5) Because an Int can never be contained in a list of String , this should generate an error at compile-time , but it does not. It wastefully and silently tests every String contained in the list for equality to 5 , which can never be true ( "5" never equals 5 in Scala). This has been named " the 'contains' problem ". And some have implied that if a type system cannot correctly type such semantics, then why go through the extra effort for enforcing types. So I consider it is an important problem to solve. The type parametrization B >: A of List.contains inputs any type that

Covariance is (roughly) the ability to mirror inheritance of "simple" types in complex types that use them. E.g. We can always treat an instance of Cat as an instance of Animal . A ComplexType<Cat> may be treated as a ComplexType<Animal> , if ComplexType is covariant. I'm wondering: what are the "types" of covariance, and how do they relate to C# (are they supported?) Code examples would be helpful. For instance, one type is return type covariance , supported by Java, but not C#. I'm hoping someone with functional programming chops can chime in, too! Cristi Diaconescu Here's what I can think

Understanding the C# Language Specification on overload resolution is clearly hard, and now I am wondering why this simple case fails: void Method(Func<string> f) { } void Method(Func<object> f) { } void Call() { Method(() => { throw new NotSupportedException(); }); } This gives compile-time error CS0121, The call is ambiguous between the following methods or properties: followed by my two Method function members (overloads). What I would have expected was that Func<string> was a better conversion target than Func<object> , and then the first overload should be used. Since .NET 4 and C# 4

I know what covariance and contravariance of types are. My question is why haven't I encountered discussion of these concepts yet in my study of Haskell (as opposed to, say, Scala)? It seems there is a fundamental difference in the way Haskell views types as opposed to Scala or C#, and I'd like to articulate what that difference is. Or maybe I'm wrong and I just haven't learned enough Haskell yet :-) There are two main reasons: Haskell lacks an inherent notion of subtyping, so in general variance is less relevant. Contravariance mostly appears where mutability is involved, so most data types