typedef bool (*predicate)(int, void*);
collection filter(collection c, predicate pred, void* context )

collection filterlessthan(collection c, int limit)
{
  return filter(collection, &lessthan, &limit);
}

bool lessthan(int a, void* limit)
{
  return a < *(int*)limit;
}

template <class Collection, class Predicate>
Collection filter(const Collection &coll, const Predicate &predicate) {...}

template <class Collection, class Item>
Collection filterLessThan(const Collection &coll, const Item &limit)
{
    return filter(coll, [&limit](auto item){ return item < limit; });
}

static IEnumerable<T> Where<T>(this IEnumerable<T> coll, Func<T, bool> predicate) {...}

static IEnumerable<int> filterLessThan(this IEnumerable<int> coll, int limit)
{
    return coll.Where(item => item < limit);
}

interface ICollection
{
    TKey Add(TValue value);

    void Remove(TKey key);
}

class AsDisposable : IDisposable
{
    public AsDisposable(Action onDispose)
    {}

    //IDisposable
}

_>class AsDisposable : IDisposable
_>{
_>    public AsDisposable(Action onDispose)
_>    {}

_>    //IDisposable
_>}

_>

// (unit -> unit) -> IDisposable
let disp f = {new IDisposable with member it.Dispose() = f() }
use it = disp (fun _ -> printfn "it is work!")
it.Dispose()

//it is work!