permutations :: Eq a => [a] -> [[a]]
permutations [] = [[]]
permutations l = concatMap (p l) l where
    p :: Eq a => [a] -> a -> [[a]]
    p l x = map (x :) (permutations (filter (x /=) l))

permutations [] = [[]]
permutations l = concatMap (p l) l where
    p l x = map (x :) (permutations (filter (x /=) l))

permutations [1 .. 4]

public static List<P> GetAllPermutations(int length) {
    List<P> list = new List<P>();
    P p = new P(), init = p;
    do {
        list.Add(p);
        p = p.GetNextPermutation(length, (int l, int r) => l >= r);
    } while(p != init);
    return list;
}
public P GetNextPermutation(int maxLength, Order<int> match) {
    int[] a = ToArray();
    ApplyNextPermutation<int>(a, maxLength, match);
    int r = 0;
    for(int i = 0; i < _count; ++i)
        r |= a[i] << (i << _s);
    return new P(r ^ _mix);
}
public static void ApplyNextPermutation<T>(T[] a, int maxLength, Order<T> match) {
    int length = a.GetLength(0);
    if(length > maxLength) length = maxLength;
    int n = 0, i;
    while(++n < length && match(a[n - 1], a[n])) ;
    if(n < length) {
        for(i = 0; match(a[i], a[n]); ++i) ;
        T t = a[n];
        a[n] = a[i];
        a[i] = t;
    }
    for(i = 0; i < --n; ++i) {
        T t = a[n];
        a[n] = a[i];
        a[i] = t;
    }
}

using System;
using System.Collections.Generic;
using StringBuilder = System.Text.StringBuilder;
using CultureInfo = System.Globalization.CultureInfo;

namespace PermutationsList {
    using P = Permutation;

    public delegate bool Order<in T>(T l, T r);

    class Permutation : IEquatable<P> {
        private readonly int _length;
        private readonly int[] _array;

        private Permutation(int length, int[] array) {
            _length = length;
            _array = array;
        }
        public Permutation(int length) {
            if(length < 0) throw new ArgumentException();
            _length = length;
            _array = new int[length];
            for(int i = 0; i < length; ++i)
                _array[i] = i;
        }

        public int this[int index] {
            get { return _array[index]; }
        }
        public int[] ToArray() {
            int[] a = new int[_length];
            for(int i = 0; i < _length; ++i)
                a[i] = _array[i];
            return a;
        }
        public P GetNextPermutation(int maxLength, Order<int> match) {
            int[] a = ToArray();
            ApplyNextPermutation<int>(a, maxLength, match);
            return new P(_length, a);
        }
        public P GetNextPermutation(int maxLength) {
            return GetNextPermutation(maxLength, (int l, int r) => l >= r);
        }
        public override string ToString() {
            StringBuilder sb = new StringBuilder();
            sb.Append("[");
            if(_length > 0) {
                int i = _length - 1;
                sb.Append(_length - _array[i]);
                for(--i; i >= 0; --i)
                    sb.AppendFormat(",{0}", _length - _array[i]);
            }
            sb.Append("]");
            return sb.ToString();
        }
        public override int GetHashCode() {
            int hash = _length;
            const int s = 32;
            for(int i = 0; i < _length; ++i) {
                int r = i % s;
                hash ^= _array[i] >> r;
                hash ^= _array[i] << (s - r);
            }
            return hash;
        }
        public override bool Equals(object obj) {
            return Equals(obj as P);
        }
        public virtual bool Equals(P other) {
            if(ReferenceEquals(other, null))
                return false;
            if(_length != other._length)
                return false;
            for(int i = 0; i < _length; ++i)
                if(this[i] != other[i])
                    return false;
            return true;
        }

        public static bool operator ==(P l, P r) {
            return ReferenceEquals(l, r) ||
                !ReferenceEquals(l, null) && l.Equals(r);
        }
        public static bool operator !=(P l, P r) {
            return !(l == r);
        }

        public static void ApplyNextPermutation<T>(T[] a, int maxLength, Order<T> match) {
            int length = a.GetLength(0);
            if(length > maxLength) length = maxLength;
            int n = 0, i;
            while(++n < length && match(a[n - 1], a[n])) ;
            if(n < length) {
                for(i = 0; match(a[i], a[n]); ++i) ;
                T t = a[n];
                a[n] = a[i];
                a[i] = t;
            }
            for(i = 0; i < --n; ++i) {
                T t = a[n];
                a[n] = a[i];
                a[i] = t;
            }
        }
        public static List<P> GetAllPermutations(int length) {
            List<P> list = new List<P>();
            P p = new P(length), init = p;
            do {
                list.Add(p);
                p = p.GetNextPermutation(length, (int l, int r) => l >= r);
            } while(p != init);
            return list;
        }
    }

    static class Program {
        static void Main(string[] args) {
            Console.Write("Enter length of permutation (int) : ");
            int length = int.Parse(Console.ReadLine(), CultureInfo.InvariantCulture);
            List<P> perms = P.GetAllPermutations(length);
            foreach(P p in perms)
                Console.WriteLine(p);
            Console.WriteLine();
            Console.WriteLine("Press enter to exit ...");
            Console.ReadLine();
        }
    }
}