def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int], string, int](keyGenerator);

// да, я знаю, что синтаксически неверны оба варианта...
def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int]](keyGenerator);
// или
def wrappedBST = TreeWrapper.Create.[BinarySearchTree, string, int](keyGenerator);

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Console;
using System.Linq;

interface ITree[TKey, TValue] { Add(_ : TKey, _ : TValue) : void; }

class RedBlackTree[TKey, TValue] : ITree[TKey, TValue]
{
  public Add(_ : TKey, _ : TValue) : void { }
}

class BinarySearchTree[TKey, TValue] : ITree[TKey, TValue]
{
  public Add(_ : TKey, _ : TValue) : void { }
}
    
class TreeWrapper[TKey, TValue]
{
  public static Create [TTree, TK, TV] (keyGenerator : TV -> TK) : TreeWrapper[TK, TV]
        where TTree : ITree[TK, TV], new()
        // where TK : TKey
        // where TV : TValue
  {
    def tree = TTree();
    TreeWrapper(keyGenerator, tree);
  }
    
  private this(keyGenerator : TValue -> TKey, tree : ITree[TKey, TValue])
  {
    // Сохранение неудобного в использовании объекта-реализации  tree,
    // чтобы затем работать с ним через удобный класс-обёртку TreeWrapper.
    this.tree = tree;
    this.keyGenerator = keyGenerator;
  }
    
  keyGenerator : TValue -> TKey;
  tree : ITree[TKey, TValue];
    
  public Add(value : TValue) : void
  {
    def key = keyGenerator(value);
    tree.Add(key, value);
  }
}

module Program
{
  Main() : void
  {
    def keyGenerator = @int : int => @int.ToString();
        
    // Ниже я пытаюсь выразить следующее: "Фабричный метод, создай мне обёртку над BinarySearchTree, у которого
    // ключи типа string, и значения типа int. Аргумент правильного типа также предоставляю."
    def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int], string, int](keyGenerator);
        
    // А хотелось бы не дублировать типы int и string. Вместо этого, например, писать так:
    //def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int]](keyGenerator);
    // или так
    //def wrappedBST = TreeWrapper.Create.[BinarySearchTree[?,?]](keyGenerator);
    // или так
    //def wrappedBST = TreeWrapper.Create.[BinarySearchTree[,]](keyGenerator);
    // или так
    //def wrappedBST = TreeWrapper.Create.[BinarySearchTree](keyGenerator);
        
    wrappedBST.Add(10);
  }
}

def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int], string, int](keyGenerator);

    def variant1 = TreeWrapper.Create(keyGenerator); // Немерле должен вывести тип вообще без параметров; но если что,
    def variant2 = TreeWrapper.Create.[BinarySearchTree[string, int], _, _](keyGenerator); // собственно фича — пропуск вместо типа
    def variant3 = TreeWrapper.Create.[_, string, int](keyGenerator); // так даже проще

def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int], string, int](keyGenerator);

  public static Create [TTree, TK, TV] (newTree : void -> TTree, keyGenerator : TV -> TK) : TreeWrapper[TK, TV]
        where TTree : ITree[TK, TV]
        // where TK : TKey
        // where TV : TValue
  {
    def tree = newTree();
    TreeWrapper(keyGenerator, tree);
  }

    def wrappedBST = TreeWrapper.Create(BinarySearchTree.[string, int], null);

def wrappedBST = TreeWrapper.Create(BinarySearchTree.[_, _], keyGenerator);

def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int], string, int](keyGenerator);

def wrappedBST = TreeWrapper.Create.[BinarySearchTree[_, _], _, _](keyGenerator);

// да, я знаю, что синтаксически неверны оба варианта...
KK>def wrappedBST = TreeWrapper.Create.[BinarySearchTree[string, int]](keyGenerator);
KK>// или
KK>def wrappedBST = TreeWrapper.Create.[BinarySearchTree, string, int](keyGenerator);

public static Create[K, V](treeCtor : void -> ITree[K, V], keyGenerator : V -> K) : TreeWrapper[K, V]
{
  TreeWrapper(keyGenerator, treeCtor())
}

def wrappedBST = TreeWrapper.Create(BinarySearchTree, keyGenerator);

Create(BinarySearchTree, keyGenerator)

TreeWrapper.Create.[BinarySearchTree[string, int], string, int](keyGenerator)

using Nemerle;
using Nemerle.Collections;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Compiler.Typedtree;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Linq;

namespace MacroLibrary
{
  macro Create(type : PExpr, func : PExpr)
  {
    CreateImpl.DoTransform(Macros.ImplicitCTX(), type, func)
  }
  
  module CreateImpl
  {
    public DoTransform(typer : Typer, type : PExpr, func : PExpr) : PExpr
    {
      Macros.DefineCTX(typer);
      
      def typeVar1 = <[ $(typer.FreshTypeVar() : typed) ]>; // создаем переменную типа и запаковываем ее в выражение
      def typeVar2 = <[ $(typer.FreshTypeVar() : typed) ]>;
      
      <[ TreeWrapper.Create.[$type[$typeVar1, $typeVar2], $typeVar1, $typeVar2]($func) ]>
    }
  }
}

def wrappedBST = TreeWrapper.Create(BinarySearchTree.[_, _], keyGenerator);

def wrappedBST = TreeWrapper.Create(BinarySearchTree, keyGenerator);