Simple Single Linked List
Well, there's already a good review by Barry, but I'll take a different tack:


In general, it's a good idea to use existing types (like smart-pointers) as building-blocks.
Still, you should not deform your code, causing loss of efficiency or clarity, just so you can use one, especially not in library-code (and such a basic container is that).

So, no smart-pointers for you, sometimes one really should get down to it.
As an aside, your clear has a bug: It tries to assign the deleter after already having deleted the source. See std::unique_ptr::operator=(std::unique_ptr&amp;&amp;).
There's a reason a node is generally a wholly-owned passive and dumb aggregate without any behavior: It would just get in the way of the List defining it properly.
You should use the same names for members all the containers in the standard-library use, so you can use standard algorithms.
For that same reason, and so you can efficiently iterate over all elements, you should provide iterators.
Sacrificing some space in the class itself for a size can be a reaonable idea. Similar arguments can be made for including a pointer (node**) to the end, so you can speed up push_back/emplace_back.
Consider putting the next-pointer first, that might allow the compiler to merge code for different template-arguments more often.




This is how you clear a list:

void List::clear() {
    for(node *head = this-&gt;head, *temp; head; head = temp) {
        temp = head-&gt;next;
        delete head;
    }
    this-&gt;head = nullptr;
}