Ограничители (sentinel) в связных списках. Смысл?

public abstract class List<T> {

    public abstract T Item { get; }

    public abstract List<T> Tail { get; }
   
    public abstract bool IsEmpty { get; }

    public abstract int Length { get; }

    public List<T> Push(T item) {
        return Cons(item, this);
    }
   
    public static List<T> Cons(T item, List<T> tail) {
        return new ListNode<T>(item, tail);
    }
   
    public static readonly List<T> Nil = new EmptyNode<T>();
   
    private sealed class ListNode<T> : List<T> {

        public ListNode(T item, List<T> tail) {
            this.item = item;
            this.tail = tail;
        }

        private readonly T item;
        public override T Item { get { return item; }  }

        private readonly List<T> tail;
        public override List<T> Tail { get { return tail; } }
       
        public override IsEmpty { get { return false; } }
       
        public override int Length { get { return 1 + Tail.Length; } }
    }

    private sealed class EmptyNode<T> : List<T> {

        public override T Item { get { throw new InvalidOperationException("List is empty!"); } }

        public override List<T> Tail { get { return this; } }
       
        public override bool IsEmpty { get { return true; } }

        public override int Length { get { return 0; } }
    }
}

// элементы добавляются в обратном порядке
// как в стеке:
var lst = List<int>.Nil.Push(4).Push(3).Push(2).Push(1);

// другой способ сделать тоже самое, LISP-style:
var lst = List<int>.Cons(1, List<int>.Cons(2, List<int>.Cons(3, List<int>.Cons(4, List<int>.Nil))));


var lst_len = lst.Length;

variant list[T] {
 | Cons { item : T; tail : list[T]; }
 | Nil
}

node* tmp = head;
while( tmp!=0 ){
     cout << tmp->data << endl;
     tmp = tmp->next;
}