error: cannot call member function `std::ostream& List<T>::recOstream(std::ostream&, Node<T>*) [with T = int]' without object - c++

Hello everyone,

I'm a first time post here. I tried searching the net for the answer,
but couldn't find anything. I'm having trouble with this error
message:

error: cannot call member function `std:stream&
List<T>::recOstream(std:stream&, Node<T>*) [with T = int]' without
object

The relevent code is:
=====================================
friend ostream& operator<<(ostream& out, List<T>& l)
{
return List<T>::recOstream(out, l.front); // error on this line
}

ostream& recOstream(ostream& o, Node<T>* n)
{
if (n == NULL) {
return o;
}
else {
o << n->item << " ";
return recOstream(o, n->next);
}
}
===================================

I have to use recursion because it's a homework assignment. List<T> is
a singlely linked list. Front is a Node<T>* to the first node in the
list. next is a Node<T>* to next item on the list. (both are public).

Does anyone have any idea's what the problem is? Any help would be
greatly appreciated.

P.S. I'm using gcc on a solaris machine. If you need more info, then
please just let me know.

The full code is:
===================================
#ifndef BERLING_LIST_H
#define BERLING_LIST_H

#include <iostream>
#include <iomanip>

using namespace std;

template <typename T>
class Node
{
public:

T item;
Node<T> *next;

Node(T itemParam = T())
{
item = itemParam;
next = NULL;
}

~Node()
{
if (next != NULL)
delete next;
}
};

template <typename T>
class List
{
protected:

Node<T> *front;
int iSize;

public:
List()
{
front = NULL;
}

List(const List<T>& ol)
{
if (ol.front == NULL)
{
front = NULL;
return;
}

front = new Node<T>(ol.front->item);

Node<T> *on = ol.front; // old node
Node<T> *nn = front; // new node

while (on->next != NULL)
{
nn->next = new Node<T>(on->next->item);

nn = nn->next;
on = on->next;
}
}

~List()
{
delete front;
}

inline int size()
{
return iSize;
}

inline bool empty()
{
return (iSize == 0);
}

void insert(const T& itm)
{
// I know that this is not efficent, but it does
// test the recursion
insert(itm, iSize);
}

void insert(const T& itm, int pos)
{
Node<T>* nn = new Node<T>(itm);
recInsert(front, front, nn, pos);
}

void recInsert(Node<T> *&prevNode, Node<T>* nextNode, Node<T>
*newNode, int pos)
{
if (pos == 0)
{
// insert node
newNode->next = nextNode;
prevNode = newNode;
iSize++;
}
else
{
recInsert(nextNode->next, nextNode->next, newNode, pos - 1);
}
}

void reverse()
{
front = recReverse(NULL, front);
}

Node<T>* recReverse(Node<T>* prevNode, Node<T>* nextNode)
{
if (nextNode == NULL)
{
return prevNode;
}
else
{
Node<T> *currentNode = nextNode->next;
nextNode->next = prevNode;
return recReverse(nextNode, currentNode);
}
}

T get(int i)
{
return recGet(i, front);
}

T recGet(int i, Node<T> *n)
{
if (i == 0)
return n->item;
else
return recGet(i - 1, n->next);
}

/**
// works correctly
friend ostream& operator<<(ostream &out, List<T> &l)
{
Node<T> *cur = l.front;
while (cur != NULL)
{
out << setw(2) << cur->item << ' ';
cur = cur->next;
}

return out;
}
**/

friend ostream& operator<<(ostream& out, List<T>& l)
{
return List<T>::recOstream(out, l.front); // error
}

ostream& recOstream(ostream& o, Node<T>* n)
{
if (n == NULL)
{
return o;
}
else
{
o << n->item << " ";
return recOstream(o, n->next);
}
}
};

#endif