f# member constraints and IEnumerable collections

Question

I'm new to F# and today I saw the member constraint feature of F#.

I was thinking of if one could (ab)use it in the following way...

Say I want to iterate get the texts of the items in a ListView. I could do it like this:

let listView = new System.Windows.Forms.ListView()
let itemTexts = 
    listView.Items
    |> Seq.cast<System.Windows.Forms.ListViewItem>
    |> Seq.map (fun item -> item.Text)

The Seq.cast above is not type safe and kind of ugly.

What I was thinking was this:

> let item (i:int) = listView.Items.Item i;;

val item : int -> System.Windows.Forms.ListViewItem

So the type of the IEnumerable is in fact encoded into the class, just in a round-about way.

The example of member constraints I saw was the following:

type Cat() = 
    member this.Walk() = printfn "cat walk"
type Dog() = 
    member this.Walk() = printfn "dog walk"

let adapter() = 
    let cat = Cat()
    let dog = Dog()
    let inline walk (x : ^T) = (^T : (member Walk : unit->unit) (x))
    walk(cat)
    walk(dog)

I got the idea that it's a bit similar to what I'd want to do above.

Could this be used to create a function to be use like the following instead?

let itemTexts = 
    listView.Items
    |> Seq.asSeq
    |> Seq.map (fun item -> item.Text)

Edit: The idea was to implement a general Seq.asSeq extension method that'd take something that implements the non-generic IEnumerable and that has a strongly typed Item-member as above and then invoke Seq.cast with the corresponding type from the Item-member.

Here's my first fumbling attempts:

let listView = new System.Windows.Forms.ListView()
let items = 
    listView.Items

type cat() = 
    member this.Item (i:int) = "cat walk"
    interface System.Collections.IEnumerable with
       member this.GetEnumerator() = ((seq { yield (this.Item 0) }) :> System.Collections.IEnumerable).GetEnumerator()

type dog() = 
    member this.Item (i:int) = 6
    interface System.Collections.IEnumerable with
       member this.GetEnumerator() = ((seq { yield (this.Item 0) }) :> System.Collections.IEnumerable).GetEnumerator()

let cat = cat()
let dog = dog()

let inline asSeq (x : ^t) =
    let dummy _ = (^t : (member Item : int -> 'a) (x, 0))
    Seq.cast<'a> x

This almost works, but not for the real type!

> cat;;
val it : cat = seq ["cat walk"]
> asSeq cat;;
val it : seq<string> = seq ["cat walk"]
> asSeq dog;;
val it : seq<int> = seq [6]
> asSeq items;;

  asSeq items;;
  ------^^^^^

C:\...\stdin(5,7): error FS0001: The type 'System.Windows.Forms.ListView.ListViewItemCollection' does not support any operators named 'Item'
>

I guess it's my fake-types that do not properly reflect the .NET indexed properties...

Any help?

Edit 2: This actually works!

let inline asSeq (x : ^t) =
    let dummy _ = (^t : (member Item : int -> 'a with get) (x, 0))
    Seq.cast<'a> x

Answer 1

It sounds like you want something along these lines, in which case your code is nearly right.

Note that one issue is that you're attempting to use indexed properties interchangeably with methods, but you're not doing it quite right: for an indexed property named Item, the method's actual name will be get_Item (alternatively, you can use the syntax member Item : int -> 'a with get instead of using the get_Item method directly).