Nsryjdtyk

This is rather toy example of immutable datatype in C++. I've tried to follow functional languages like Scheme, Racket - making list as a cons cell: list is list or is empty.

/*

 * Abstract class

 */ 

template <class T>

class ImmutableList {



public:

~ImmutableList() {std::cout << "base class destructor";}

virtual bool is_empty() = 0;

virtual T head() = 0;

virtual ImmutableList<T> * tail() = 0; 

virtual int length() = 0;

};



/*

 * class non empty List

 */



template <class T>

class List: public ImmutableList<T> {



int size = 1;

T first;

ImmutableList<T> * rest;

public:



List(T _first, ImmutableList<T> * _tail){

    first = _first;

    rest = _tail;

    size += _tail->length();

}

~List() {std::cout << "List class destructor";}

bool is_empty() { return false; }



T head(){

    return first;

}



ImmutableList<T>* tail(){

    return  rest;

}



int length() {return size;}

};



/*

 * class empty list

 */

template <class T>

class Nil: public ImmutableList<T> {

    public:

    ~Nil();

    bool is_empty() {return true;}

    int length() {return 0;}

    T head() {

        throw std::logic_error("Head of empty list!");

    }

    ImmutableList<T> * tail() {

        throw std::logic_error("Tail of empty list!");

    }

};

There is more functions, like a reverse, there is also cons function - constructs a list.

Do this really need destructors? Will be better to use smart pointers?