wibble 1.1
Classes | Functions
wibble::list Namespace Reference

Classes

struct  Append
 
struct  Empty
 
struct  Filtered
 
struct  ListIterator
 
struct  Map
 
struct  Singular
 
struct  Sorted
 
struct  Take
 
struct  Unique
 

Functions

template<typename X >
Singular< Xsingular (const X &x)
 
template<typename X , typename Y >
Append< X, Yappend (const X &x, const Y &y)
 
template<typename List >
size_t count (List l)
 
template<typename List , typename F >
void foreach (List l, F f)
 
template<typename List , template< typename > class F>
void foreach (List l, F< typename List::Type > f)
 
template<typename List , typename Pred >
Filtered< List, Predfilter (List l, Pred p)
 
template<typename List , template< typename > class Pred>
Filtered< List, Pred< List > > filter (List l, Pred< List > p)
 
template<typename List , typename F >
Map< List, Fmap (const List &l, const F &f)
 
template<typename List >
Sorted< Listsort (List l)
 
template<typename List >
Unique< Listunique (List l)
 
template<typename List >
Take< Listtake (int t, List l)
 
template<typename List >
List drop (int t, List l)
 
template<typename List , typename Out >
void output (List l, Out it)
 
template<typename List >
ListIterator< Listbegin (List l)
 
template<typename List >
ListIterator< Listend (List)
 

Function Documentation

◆ append()

template<typename X , typename Y >
Append< X, Y > wibble::list::append ( const X x,
const Y y 
)

◆ begin()

template<typename List >
ListIterator< List > wibble::list::begin ( List  l)

Referenced by TestList::stl().

◆ count()

template<typename List >
size_t wibble::list::count ( List  l)

◆ drop()

template<typename List >
List wibble::list::drop ( int  t,
List  l 
)

◆ end()

template<typename List >
ListIterator< List > wibble::list::end ( List  )

Referenced by TestList::stl().

◆ filter() [1/2]

template<typename List , typename Pred >
Filtered< List, Pred > wibble::list::filter ( List  l,
Pred  p 
)

Referenced by TestList::filtered().

◆ filter() [2/2]

template<typename List , template< typename > class Pred>
Filtered< List, Pred< List > > wibble::list::filter ( List  l,
Pred< List p 
)

◆ foreach() [1/2]

template<typename List , typename F >
void wibble::list::foreach ( List  l,
F  f 
)

◆ foreach() [2/2]

template<typename List , template< typename > class F>
void wibble::list::foreach ( List  l,
F< typename List::Type >  f 
)

◆ map()

template<typename List , typename F >
Map< List, F > wibble::list::map ( const List l,
const F f 
)

◆ output()

template<typename List , typename Out >
void wibble::list::output ( List  l,
Out  it 
)

◆ singular()

template<typename X >
Singular< X > wibble::list::singular ( const X x)

◆ sort()

template<typename List >
Sorted< List > wibble::list::sort ( List  l)

Referenced by TestList::sorted().

◆ take()

template<typename List >
Take< List > wibble::list::take ( int  t,
List  l 
)

◆ unique()

template<typename List >
Unique< List > wibble::list::unique ( List  l)

Referenced by TestList::unique().