interface IFoo
{
    String getA();
}

IFoo a = () -> "$#@$%#%^";

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;
}

interface ICollection
{
    TKey Add(TValue value);

    void Remove(TKey key);
}

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

    //IDisposable
}

public Notificator(IEmailSender sender)

    EmailSender
IEmailSender 
    Notificator

type Notificator (sender: string -> string -> string -> bool) =
    if sender("guest@local", "hello", "who are you?") then

ServiceUtils
    Notificator

type Notificator (sender: email: string -> subject: string -> body: string -> sent successfully: bool) = ...

type SmtpOptions = {
 host : string
 port : int    
}

type IEmailSender : options : SmtpOptions -> mail : MailMessage -> Result

AA>type SmtpOptions = {
AA> host : string
AA> port : int    
AA>}

AA>type IEmailSender : options : SmtpOptions -> mail : MailMessage -> Result
AA>

type PackOfFunctions = {
 method1 : функция(набор параметров 1...)
 method2 : функция(набор параметров 2...)    
 method3 : функция(набор параметров 3...)    
}

interface IFoo
{
    string GetA();
}

var a = "%$#@$%#%^";
var bar = new<IFoo>
{
    GetA = () => { return a; }    
}

Y>var bar = new<IFoo>
Y>{
Y>    GetA = () => { return a; }    
Y>}
Y>

        btn.setOnAction(new EventHandler<ActionEvent>() {
 
            @Override
            public void handle(ActionEvent event) {
                System.out.println("Hello World!");
            }
        });

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);
}

_>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!