Quick Fluent Interface to wrap Mongo queries in an order safe interface

fluent-mongo-query.fs

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

type SortOrder = Asc | Desc

type MongoQuery<'a> private(queryable:IQueryable<'a>, filters, sortFn, takeQty, skipQty) as this = 
  new(query) = MongoQuery(query, [], None, None, None)
  member this.Where(filter:Expression<Func<'a,bool>>) = 
    MongoQuery(queryable, filter::filters, sortFn, takeQty, skipQty)
  member this.OrderBy(sortFn:Expression<Func<'a,'b>>) = 
    MongoQuery(queryable, filters, Some(SortOrder.Asc, sortFn), takeQty, skipQty)
  member this.OrderByDescending(sortFn:Expression<Func<'a,'b>>) = 
    MongoQuery(queryable, filters, Some(SortOrder.Desc, sortFn), takeQty, skipQty)
  member this.Take(takeQty) = 
    MongoQuery(queryable, filters, sortFn, Some(takeQty), skipQty)
  member this.Skip(skipQty) = 
    MongoQuery(queryable, filters, sortFn, takeQty, Some(skipQty))
  member this.ToEnumerable() = 
    let mutable query = queryable
    for f in filters do
      query <- query.Where(f)
    query <- match sortFn with | Some(SortOrder.Asc, fn) -> query.OrderBy(fn) :> IQueryable<'a>
                               | Some(SortOrder.Desc, fn) -> query.OrderByDescending(fn) :> IQueryable<'a>
                               | None -> query
    query <- match skipQty with Some(skipQty) -> query.Skip(skipQty) | None -> query
    query <- match takeQty with Some(takeQty) -> query.Take(takeQty) | None -> query
    query.AsEnumerable()
  interface IEnumerable<'a> with
    member __.GetEnumerator(): Collections.IEnumerator = 
      this.ToEnumerable().GetEnumerator() :> Collections.IEnumerator
    member __.GetEnumerator() = this.ToEnumerable().GetEnumerator()