Covariance/contravariance language support

[baronfel]

Submitted by Eriawan Kusumawardhono on 3/21/2014 12:00:00 AM
150 votes on UserVoice prior to migration

Covariance/contravariance has its beginning in CLR 2.0 and also with the introduction of generics in .NET 2.0 (also in F#, C# and VB)

Then in C# 4.0 and VB 10, we have covariance/contravariance supports in the language itself. Currently we don't have support for these covariance and contravariance in F#.

I know it is a runtime feature of CLR 2.0 and 4.0 and I don't want to play catch up with C# and VB.
But this covariance/contravariance support in C# and VB are powerful to use and also have proven to provide cleaner and clearer ways to understand the code and variances in the types, especially when using parameterized generic types.

This is not the same as this feedback:
http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2363794-ocaml-like-variance-annotations-a-and-a-

but we can use that OCaml syntax as well for starter.

This feature should also be constrained to only use covariance/contravariance in interfaces and delegates just like in C# and VB, but F# may provide more supports for other types such as events.
An example of this is the way F# has provided the capability to create extensions to properties and methods, not just methods only in C# and VB.

Original UserVoice Submission
Archived Uservoice Comments

[kurtschelfthout]

Is it worth creating a separate suggestion to allow just the declaration of variant delegates and interfaces, without changing anything else in F#? This would allow exposing such delegates and interfaces to C#/VB consumers from F# without having to go through the rigmarole of having a separate C# assembly, e.g. see fscheck/FsCheck#296

[dsyme]

@kurtschelfthout Hmmm... I suppose we could do that. It's reasonable to be able to declare these , e.g. an attribute.

[auduchinok]

I'd like to note that recently closed dotnet/fsharp#5277 is about not being able to consume types with such parameters, not about defining them in F#.

[vhogemann]

Been recently bitten by this. In my case I just wanted to create a simple wrapper function for declaring dependencies using SimpleInjector, like this

let registerInterfaceForService<'I,'S when 'S :> 'I> (container:Container):Container = ...

Ended up having to come up with a solution that uses dynamic casting... not nice.

[kunjee17]

I guess this could be issue.

Recently I am trying to port ML.net samples and stuck at a place because of this

New dynamic api allows pipelining. But to pipe line I need to have all classes in IEstimator<ITranformer> type. That couldn't be possible.

Here is code to mimic the issue.

public sealed class CategoricalEstimator : IEstimator<CategoricalTransform> which implement an interface. So, I can type cast to IEstimator<CategoricalTransform> but again public sealed class CategoricalTransform : ITransformer, ICanSaveModel is the case. So, now I can cast IEstimator<CategoricalTransform> into IEstimator<ITranformer> and because of that I am unable to create pipeline for ML sample.

It would be great if some one can help on this. @dsyme @cartermp

PS: If this is not possible at all then, it would be good to create issue on ML.net library? for better F# support?

[IvanAntipov]

Here's my work around. It is ugly, but it seems to work.

let ldaTransform = ml.Transforms.Text.LatentDirichletAllocation(inputColumnName = text_a_fieldName, outputColumnName = ldaFeatures, numTopic = 3)

type WrapCastEstimator(estimator: IEstimator<TransformWrapper>)  =
    interface IEstimator<ITransformer>  with
        member __.Fit(input: IDataView) : ITransformer = estimator.Fit(input) :> ITransformer        
        member __.GetOutputSchema(inputSchema : SchemaShape): SchemaShape = estimator.GetOutputSchema(inputSchema)
        
let wrapCastEstimator (estimator : IEstimator<TransformWrapper>)  = WrapCastEstimator(estimator) :> IEstimator<ITransformer>

let bagOfWordEstimator = ml.Transforms.Text.ProduceWordBags(text_a_fieldName) :> TrainedWrapperEstimatorBase :> IEstimator<TransformWrapper> |> wrapCastEstimator
let pipeline = 
    (bagOfWordEstimator)
        .Append(ldaTransform)

Upd. It is already suggested by @vhogemann

[reinux]

Gotchas like this end up becoming a giant time sink. I spent several hours trying to figure out that I need to write a cast function, which, frustratingly, does literally nothing but makes the compiler happy anyway.

type PolyType = interface end
type Convex = inherit PolyType
type Concave = inherit PolyType

type Polygon<'t when 't :> PolyType> = Polygon of (float*float) list

// Flexible types -- cool, no problem!
let printPoly (p:Polygon<#PolyType>) = printfn "%A" p

let p : Polygon<Convex> = Polygon [0.,0.]
printPoly p

// But let's try composing this type into another. Wait, you can't use flexible types here?
//type PolyGroup = PolyGroup of Polygon<#PolyType> list

// Well, whatever, I'll just have to cast when I lift to PolyGroup
type PolyGroup = PolyGroup of Polygon<PolyType> list

// Okay... well, without flexible types, it's not much of a surprise that this won't compile
//let p : Polygon<Convex> = Polygon [0.,0.]
//PolyGroup [p]

// So now I need to figure out how to cast it.
let p' : Polygon<PolyType> = match p with Polygon p -> Polygon p
PolyGroup [p']

// Okay... that's kind of ugly, but it works. Let's see if I can at least make a function to generalize this.
let cast p = match p with Polygon p -> Polygon p

//It works.
PolyGroup [cast p]

And then you look at cast's type, and it turns out to be Polygon<#PolyType> -> Polygon<#PolyType>.
It's literally doing nothing, but now PolyGroup is perfectly happy.

I guess the bigger problem here is that flexible types don't work inside type definitions for whatever reason.

[teo-tsirpanis]

Until co(ntra)variance gets natively supported by F#, anyone interested can use Covarsky.

[NinoFloris]

Neat, can remove our own variance weaver from the codebase. Thanks @teo-tsirpanis

[teo-tsirpanis]

@NinoFloris, you are welcome. Let me know if everything went well with your migration, or you need some help. 🙂