Back to Questions
2.3k
views1
comment
for loops/comprehensions over non-generic collections in 1.9.4.19
f#compilercollections

The language manual for 1.9.3 suggests that F# will magically get "for" comprehensions correct even on collections which implement only IEnumerable (as opposed to IEnumerable<'a>) by looking to see if the class in question has a more strongly typed Item function, which it usually does. " The type of pat is typically determined by the return type of the

Current property on the enumerator value. However Current

property has return type obj and the collection type ty

has an Item property with a more specific (non-object) return type

ty2, then that type is used instead, and a dynamic cast is

inserted to convert v.Current to ty2."

This worked great under F# 1.9.3.14, but has broken under 1.9.4.19. The new specification is silent on the behavior of "for" computation expressions as regards this much-loved feature. Was this bit of cleverness removed from the language on purpose? I am somewhat sympathetic to its removal if so, as this might occasionally prove wrong at runtime to the chagrin of such a type-focused language. However, given the vast quantity of the .NET library which does not implement generic enumerators (e.g. ADO.NET), this gets ugly fast. 

1

[ for r in dataTable.Rows where ... -> r... ]

is nice.

the alternative, with casting, is uglier

1

[ for r in (dataTable.Rows |> Seq.untyped_to_typed<DataRow>) where ... -> ... ]

(*updated to add: I typed the above before trying it. I get a strange complaint from the compiler that untyped_to_typed requires two type variables, but was only given one. This is strange given the signature only has one free type variable *)

it might be nice for the sake of clean interoperability to either reinstate the old rule, or allow us to specify it

1

[ for (r:?DataRow) in dataTable.Rows where ... -> ... ]

- Sebastian

.

Could you post a repro? With 1.9.4.19 I can compile these:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

 
let e : System.Collections.IEnumerable = ([1;2;3] :> System.Collections.IEnumerable)

[ for r in e -> r ] // enumerating an IEnumerable

type C() = 
    member x.GetEnumerator() = e.GetEnumerator()

[ for r in C() -> r ]  // enumerating a type that just has a GetEnumerator

type DEnum() = 
    member x.MoveNext() = true
    member x.Current = 1

type D() = 
    member x.GetEnumerator() = new DEnum()

[ for r in D() -> r ]  // enumerating a type that just has a GetEnumerator with the MoveNext/Current pattern

Seq.untyped_to_typed as a # type in its argument, which counts as a type variable.

Thanks!

don

By on 7/24/2008 7:53 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper