Строковое представление переменной типа (выводимое также в отладчике) – это фактически значение свойства Hint, обработанное специальным образом. Свежие переменные обозначаются визуально как вопросительный знак – «?». Если для переменной задана только верхняя граница, то в конце к имени типа дописывается знак минус – «-». Если задана только нижняя граница, то к имени типа дописывается «+». Если же заданы и верхняя граница, и нижняя, то его строковое представлением будет выглядеть как «(L TILL H)», где L – это тип нижней границы, а H – верхней.

  match ((this, t)) {
    ...
    | (Fun (f1, t1), Fun (f2, t2)) =>
      // f2.Require (f1) && t1.Require (t2)
      f1.Unify (f2) && t1.Unify (t2)

  match ((this, t)) {
    ...
    | (Fun (f1, t1), Fun (f2, t2)) =>
      // f2.Require (f1) && t1.Require (t2)
      // f1.Unify (f2) && t1.Unify (t2)
      f1.Unify (f2) && t1.IsGeneralizedBy (t2)

  public macro @bind (_expr)
  syntax ("def", "!", _expr) { <[ () ]> }

D>Первоначально мне нужно было хотя бы гипотетическое соответствие. То есть, может ли выражение иметь такой-то тип. В общем, взял код FixedType.Unify и просто переписал под себя. Работает. Но теперь я понял, что и это мне не нужно.

D>  public macro @bind (_expr)
D>  syntax ("def", "!", _expr) { <[ () ]> }
D>

  public macro @bind (_expr)
  syntax ("!!", "def", _expr) { <[ () ]> }

!!def a = ...;

VD>  public macro @bind (_expr)
VD>  syntax ("!!", "def", _expr) { <[ () ]> }
VD>

VD>!!def a = ...;
VD>

    def coll = 
      comp enumerable
      {
        mutable i = 0;
        while (i < x)
        {
          yield i;
          i ++;
        }
      }

D>>    def coll = 
D>>      comp enumerable
D>>      {
D>>        mutable i = 0;
D>>        while (i < x)
D>>        {
D>>          yield i;
D>>          i ++;
D>>        }
D>>      }
D>>

    
    public Run (expr : PExpr) : PExpr
    {
      <[ EnumerableHelper.Delay (() => $expr) ]>
    }

VD>Вот тут я разницу не уловил.

def upTo (n : int) : IEnumerable [int]
{
  comp enumerable
  {
    mutable i = 0;
    while (i < n)
    {
      i ++;
      yield i
    }
  }
}

def manyTimes : IEnumerable [int] =
  comp enumerable
  {
    yieldcomp (upTo (2));  // 1 2
    yield 100;             // 100
    yieldcomp (upTo (3));  // 1 2 3
    yield 100;             // 100
    yieldcomp (upTo (10)); // 1 2 3 .. 10
  }

WH>А ты уверен что это не произошло из-за ограничений самого F#?

WH>Просто для кого? Лично я не хочу видеть кучу ключевых слов которых может и не быть.

yield $x      =>  $(acc : Name).Add ($x)
yieldcomp $x  =>  $(acc : Name).AddRange ($x)

D>Не-не, так нельзя. Это очень разные функции. Этому меня еще хаскель научил.

D>И я не представляю как одно можно было бы выразить через другое в общем случае... И то, и другое — must have однозначно.

module ListHelper
{
  public Yield[A](l : List[A], value : A) : void
  {
    l.Add(value);
  }

  public Yield[A](l : List[A], values : IEnumerable[A]) : void
  {
    l.AddRange(values);
  }
}

yield $x      =>  <[ ListHelper.Yield($(acc : Name), ($x)) ]>

WH>>Просто для кого? Лично я не хочу видеть кучу ключевых слов которых может и не быть.

D>yield $x      =>  $(acc : Name).Add ($x)
D>yieldcomp $x  =>  $(acc : Name).AddRange ($x)
D>

D>И я не представляю как одно можно было бы выразить через другое в общем случае... И то, и другое — must have однозначно.

ListAddHelper[T](ary : List[T], elem : T) { ... }
ListAddHelper[T](ary : List[T], elems : IEnumerable[T]) { ... }

...

| yield $x      =>  ListAddHelper($(acc : Name), $x)
| yieldcomp $x  =>  ListAddHelper($(acc : Name), $x)

foreach (method is IMethod when method.IsPublic in typeMembers)
  processMethod(method);

...

def expressions = [Literal(1.23), Mul(Literal(2), Literal(3))];
foreach (expr in expressions)
{
  | Mul(e1, e2) => WriteLine($"$(expr.Eval()) = $e1 * $e2");
  | Div(e1, e2) => WriteLine($"$(expr.Eval()) = $e1 * $e2");
  ...
}

foreach ($x in $coll) $body  

=>

$builder.ForEach ($coll, fun ($(var : Name)) {
  match ($(var : Name))
  {
    | $x => $body;
    | _ => ()
  }
})

for (mutable $x = $init; $cond; $next) $body

=>

{
  mutable $x = $init;

  def $(loop : Name) ()
  {
    if ($cond == false)
      LazyStream.Nil ()
    else
      LazyStream.Cons ($x, 
        fun () { $next; $(loop : Name) () })
  }

  $builder.ForEach ($(loop : Name) ().ToEnumerable(), fun ($x) $body)
}

foreach ($x in $coll) $body  

=>

$builder.ForEach ($coll, fun ($(var : Name)) {
  match ($(var : Name))
  {
    | $x => $body;
    | _ => $builder.Zero ()
  }
})

D>foreach ($x in $coll) $body  

D>=>

D>$builder.ForEach ($coll, fun ($(var : Name)) {
D>  match ($(var : Name))
D>  {
D>    | $x => $body;
D>    | _ => ()
D>  }
D>})
D>

public ForEachLazy[T](source : IEnumerable[T]) : IEnumerable[T]
{
  foreach (x in source)
    yeild x;
}

using Nemerle.ComputationExpressions;
using Nemerle.ComputationExpressions.Extensions;