Back to Questions
2.5k
views6
comments
Implementing IQueryable<T> in F#
f#compiler

Hi all,
I've been poking around LINQ recently, and decided that implenting a LINQ provider would be a good opportunity to try and learn F#. Unfortunately I've been struggling to get a compilable skeleton implementation of IQueryable<T> going in F#. This is what I've come up with so far: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

open System
open System.Collections
open System.Collections.Generic
open System.Linq
open System.Linq.Expressions

// Base type for desktop query results
type SearchableFile = { 
	FileName: string;
	FileExtension: string; 
	Folder: string;
	Size: int64; 
}

type DesktopSearchQuery = class
	interface IEnumerable with
		member x.GetEnumerator() = null
	end

	interface IEnumerable<SearchableFile> with
		member x.GetEnumerator() : IEnumerator<SearchableFile> = null
	end 

	interface IQueryable with
		member x.CreateQuery( exp ) = null
		member x.ElementType = null
		member x.Execute( exp  ) = null
		member x.Expression = null 
	end

	interface IQueryable<SearchableFile> with
		member x.CreateQuery( e : System.Linq.Expressions.Exp ) : IQueryable<'TElement>  = null
		member x.Execute<'TResult>( e : System.Linq.Expressions.Exp ) : 'TResult = failwith "oops"
	end
end

Note: I renamed System.Linq.Expressions.Expression to Exp to avoid the message board software messing with the word Expression
My problem is that the definition of Execute<'TResult> seems to make the F# compiler very unhappy. I get an error stating: 'Internal error: undefined type variable 'TResult. Please report this problem.' I struggled with getting the signatures for the various interface methods; is it possible I have declared the Execute method incorrectly? Or have I run in to a bug in the compiler that makes it impossible to implement IQueryable?
Thanks, John

.

Have you tried adding the 'TResult annotation at the top of your class definition ?

1

type 'TResult DesktopSearchQuery = class (* ... *) end

Hope this helps.

By on 7/22/2007 11:56 PM ()

Well I actually just want the Execute method to have a type parameter, not the class itself, so I dont want to add the declaration at the class level.

I did just try it though, and I got an explicit compilation error (as opposed to the more subtle error I got earier that sounded more like a bug in the compiler).

Thanks for the suggestion though; I guess I just need to dig deeper in to the documention. 'Expert F#' can't come out soon enough!

-John

By on 7/23/2007 3:01 AM ()

Hi John,
I think you're right - this looks like a compiler bug to me. I tried to reproduce it using the simplest possible case and the following code gives exactly the same error:

1
2
3
4
5
6

type ITest<'r> =
  abstract Foo<'t> : 't -> 't
  
type Test() = 
  interface ITest<int> with
    member x.Foo<'t>(v:'t) : 't = v

The F# team monitors this website, though it is usually better to report a bug like this directly to the fsbugs (at) microsoft (dot) com, so I would recommend sending them an email with these two examples, to make sure that it will be fixed in the future release.

(BTW: my code uses the #light syntax which makes writing many OO stuff easier in F# - the ITest is inferred to be an interface because it has only abstract methods and the Test type is using an implicit constructor syntax, so the type will have one parameterless constructor).

By on 7/24/2007 9:21 AM ()

Thanks for the comments. I'll report the bug to the F# team; I didnt want to do it before I got some confirmation that I wasn't doing anything silly...

And you're right...the #light styntax is much cleaner. Thanks for the tip.

By on 7/24/2007 5:15 PM ()

Bug already recorded - thanks - I've been following the thread.

The bug only occurs when a class type attempts to implement an interface with a generic method. You can however use an object expression to implement such an interface, e.g.

1
2
3
4
5
6
7
8
9
10
11
12

 

#light

type ITest<'r> =
  abstract Foo<'t> : 't -> 't

let Test() = 
  { new ITest<int> with
     member x.Foo(v) = v }

Thi will usually give you a workaround.

Kind regards

don

By on 7/24/2007 5:23 PM ()

Oh, here's the object expression version with an explicit type annotation at the implementation.

1
2
3
4
5
6
7
8

#light

type ITest<'r> =
  abstract Foo<'t> : 't -> 't

let Test() = 
  { new ITest<int> with
     member x.Foo<'u>(v:'u) = v }
By on 7/24/2007 5:24 PM ()

    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