permutations of a list, adapted from http://stackoverflow.com/a/28241384/2889760

permutations.ceylon

shared void run() {
    for (perm in permutations("ABCD").indexed) {
        print(perm);
    }
}

shared {Element[]*} permutations<Element>
            (List<Element> list) 
        => object satisfies {Element[]*} {
    
    iterator() 
            => object satisfies Iterator<Element[]> {
        
        value length = list.size;
        value permutation = Array(0:length);
        value indexes = Array(0:length);
        value swaps = Array(0:length);
        value directions = Array.ofSize(length, -1);
        
        variable value counter = length;
        
        shared actual Element[]|Finished next() {
            while (counter > 0) {
                if (counter == length) {
                    counter--;
                    return permutation.collect((i) { 
                        assert (exists elem = list[i]);
                        return elem;
                    });
                }
                else {
                    assert (exists swap = swaps[counter],
                            exists dir = directions[counter]);
                    if (swap > 0) {
                        assert (exists index = indexes[counter]);
                        value otherIndex = index + dir;
                        assert (exists swapIndex = permutation[otherIndex]);
                        permutation.set(index, swapIndex);
                        permutation.set(otherIndex, counter);
                        indexes.set(swapIndex, index);
                        indexes.set(counter, otherIndex);
                        swaps.set(counter, swap-1);
                        counter = length;
                    }
                    else {
                        swaps.set(counter, counter);
                        directions.set(counter, -dir);
                        counter--;
                    }
                }
            }
            return finished;
        }
    };
    
};