Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

▼Nnano
▼Ndetail
Caccumulate	Like std::accumulate, where the start and end indices, and the accumulation functor can be specified
Caccumulate< list< Head, Tail...>, Iteration, StartIndex, EndIndex, Value, Operation >
Caccumulate< list< Tail...>, Iteration, StartIndex, EndIndex, Value, Operation >
Carray_convert	Converts an element to a std type, like nano::int_t to inr or a nano::list into a std::array with N elements
Carray_convert< list< First, Rest...> >
Cbuild_range	Builds a range of nano::int_t types
Cbuild_range< Current, Step, Iteration, false, list< nano::int_t< Values >...> >
Cbuild_range< Current, Step, Iteration, true, list< nano::int_t< Values >...> >
Cget	Meta function to get an element from a list
Cget< nano::size_t< 0 >, list< Head, Tail...> >
Cget< nano::size_t< Index >, list< Head, Tail...> >
Csearch_lists	For each element in the first list, the index of the element in the second list is searched for, if found it's added to a new list, otherwise -1 is added
Csearch_lists< list< Head1, Tail1...>, list< Head2, Tail2...> >
Cvector_convert	Same as convert, but uses vector's instead of arrays, so the performance is worse
Cvector_convert< list< First, Rest...> >
Cadd	Addss two nano numeric types
Cargs_list	A list of arguments
Cboth_found	Checks if both types are found (have values != -1), in which case result is true, otherwise result is false
Cequal_value	Check if two types (which have value components) have the same value
Ceval	Evaluates an expression with arguments
Ceval< Expression, no_args >
Ceval< Function< Args...>, no_args >
Cexpand	Expands a list into its types
Cexpand< Expression, Arg, false >
Cexpand< Expression, Arg, true >
Cfilter	Takes a list and an evaluation function, which itself takes the list and a parameter to evaluate if each element of the list must be filtered
Cfilter< Evaluator, empty_list, list< Tail2...>, list< Passed...> >
Cfilter< Evaluator, list< Head1, Tail1...>, list< Head2, Tail2...>, list< Passed...> >
Cfind_common	Finds all common elements in 2 lists and returns a zipped list of the result, where each zipped element is a index of the common element in the lists. The zips are sorted by the index of the element in the first list. For example, if there are 2 lists: [ 0, 4, 2, 1 ] and [ 12, 1, 4, 2 ] the returned list will be: [ [1, 2], [2 ,3], [1, 2] ]
Cfind_common< list< Head1, Tail1...>, list< Head2, Tail2...> >
Cfind_type	Find the index of a specific type in the list (the index of the first occurrence). If the type is not found then the value 'parameter' will be -1
Cfind_type< Type, list< Head, Tail...> >
Cfind_type< Type, list< Type, Tail...> >
Cfind_type< Type, list<> >
Cfind_uncommon	Finds all elements of the first list which are not present in the second list, and returns a new list without the common elements. For example, if there are 2 lists: [ 2, 3, 1, 4 ] and [ 4, 5, 2 ] the returned list will be: [ 3, 1 ]
Cfind_uncommon< list< Head1, Tail1...>, list< Head2, Tail2...> >
Cfind_uncommon_indices	Finds the indices of the elements in the first list which are not present in the second list and returns a list of the index values. For example, if there are 2 lists: [ 2, 3, 1, 4 ] and [ 4, 5, 2 ] the returned list will be: [ 1, 3 ]
Cfind_uncommon_indices< list< Head1, Tail1...>, list< Head2, Tail2...> >
Cfirst_not_present	Just check if the first element of the list was found (searching should be done beforehand)
Cfirst_not_present< Type, list< Head, Tail...> >
Cidentify	Simply an identifier to identify meta types and meta functions
Cint_t	Wrapper around int for static int types used by metaclass and metafunctions in nano
Cis_found	Ths function is supposed to be used with the find functions on lists when searching through the list to find common or uncommon elements. It should be called by the zip HOF to determine if Type1 and Type2 should be zipped and added to the list of elements to return. Please see the implementation of the find_common and zip functions for clarificaiton
Cjoin	Joins two lists
Cjoin< list< Ts...>, list< Us...> >
Clist	Meta class that holds types, and allows functions to be applied to the elements of the list using the internal apply struct. Usage: using nano::dim; \ To get dimension types using test_list = list<i, j, k, l>; \ A list of dimensions using shifted_list = list::apply<shift>; Where shift is some function which operates on a type in the list
Cmultiplies	Same as std::multiplies, but for a nano:list which can be computed at compile time - computes the product of the list elelents from the starting value
Cmultiplies< empty_list, Current >
Cmultiplies< list< Head, Tail...>, Current >
Cmultiply	Multiplies two nano numeric types
Cnot_found	Function to determine if and element is not found (has a value of -1)
Cpair	Holds two elements
Crange	Constructs a range of nano::int_t t types, which is essentially just a list of nano::int_t types
Cruntime_converter	Wrapper class to provide the conversion functions for converting to runtime containers
Cruntime_converter< list< Head, Tail...> >
Csize_of	Gets the number of types in a container
Csize_of< Container< Types...> >
Csize_t	Wrapper around size_t for static size_t types used by metaclass and metafunctions in nano
Ctype_not_present	To check if a type in a list is not found. Where the find_type tries to find a type and get its index to return, this function simply returns true of the type is not found, and false if the tpe is found
Ctype_not_present< Type, list< Head, Tail...> >
Ctype_not_present< Type, list< Type, Tail...> >
Ctype_not_present< Type, list<> >
Czip	Takes two lists, and zips the corresponding elements into a list of 2 elements if the function to determine if the elements should be zips succeeds, otherwise the elements are not zipped
Czip< Evaluator, empty_list, empty_list, list< Passed...> >
Czip< Evaluator, list< Head1, Tail1...>, list< Head2, Tail2...>, list< Passed...> >