def l = array();

MAM>   def l = array();
MAM>

def a = array.[1]();

MAM>>   def l = array();
MAM>>

protected Card[] _list = null;
public Pack(String aStr)
{
    _list = new Card[0];
                
    String[] cards = aStr.Trim().Split(' ');
    
    int i=0;
    foreach(var c in cards)
    {
        Add(new Card(c){
            Index = i
            });
        i++;
    }
}

public int Add(Card aCard)
{            
    int res = _list.Length + 1;
    Array.Resize(ref _list, res);
    _list[Count - 1] = new Card(aCard);
    return res;
}

[Record]
class Card {
    public Str   : string;
    public Index : int;
}
class Test {
    _list : List[Card] = List();
    public Pack(str : string) : void {
        str.Trim().Split(' ').Select((s, i) => Card(s, i))
        |> _list.AddRange
    }
    public Add(card : Card) : int {
        _list.Add(card);
        _list.Count
    }
}

MAM>Смысл был в глюке компилятора, на который может напороться только зеленый новичек. Ну и доку надо читать. Хотя работа с массивами в немерле очень непривычна Чего только точка стОит, до сих пор не пойму ее смысл.

var ary = new int[1];
ary[0] = 42;

var ary = new int[] { 42 };
var ary = new [] { 42 };

// явное указание типа переменной
int[] ary = new [] { 42 };

// массив массивов (вложенный массив)
int[][] ary = new[] { new[] { 42 } };
var ary = new[] { new[] { 42 }, new[] { 33, 1 } };

// многомерные массивы
var ary = new[,] { { 42, 1 }, { 33, 2 } };
Console.WriteLine(ary[0, 0]);

def ary = array(1);
ary[0] = 42; // тип выводится из использования

def ary = array[1];


// явное указание типа переменной
def ary : array[int] = array[1];

// массив массивов (вложенный массив)
def ary : array[array[int]] = array[array[42]];
def ary = array[array[42], array[33, 1]];

// многомерные массивы
def ary = array.[2][[42]];
def ary = array.[2][[42, 1], [33, 2]];

Обратите внимание, что при указании параметров типов у конструкторов обобщенных типов необходимо указывать «.» для устранения неоднозначности с индексаторами. Это не очень красивое решение. Однако в Nemerle почти всегда можно просто не указывать параметры типов вовсе. Как показано в примере выше, Nemerle сам выводит значения параметров типов из использования.

x |> f |> g

g(f(x))