
constexpr auto  always 
 Return a constant function returning x regardless of the argument(s) it is invoked with. More...


constexpr auto  apply 
 Invokes a Callable with the given arguments. More...


template<std::size_t n> 
constexpr auto  arg 
 Return the n th passed argument. More...


constexpr auto  capture 
 Create a function capturing the given variables. More...


constexpr auto  compose 
 Return the composition of two functions or more. More...


template<std::size_t n> 
constexpr auto  curry 
 Curry a function up to the given number of arguments. More...


constexpr auto  demux 
 Invoke a function with the results of invoking other functions on its arguments. More...


constexpr auto  fix 
 Return a function computing the fixed point of a function. More...


constexpr auto  flip 
 Invoke a function with its two first arguments reversed. More...


constexpr auto  id 
 The identity function – returns its argument unchanged. More...


constexpr auto  infix 
 Return an equivalent function that can also be applied in infix notation. More...


template<std::size_t n> 
constexpr auto  iterate 
 Applies another function n times to its argument. More...


constexpr auto  lockstep 
 Invoke a function with the result of invoking other functions on its arguments, in lockstep. More...


constexpr auto  on 
 Invoke a function with the result of invoking another function on each argument. More...


constexpr auto  overload 
 Pick one of several functions to call based on overload resolution. More...


constexpr auto  overload_linearly 
 Call the first function that produces a valid call expression. More...


constexpr auto  partial 
 Partially apply a function to some arguments. More...


constexpr unspecified  _ {} 
 Create simple functions representing C++ operators inline. More...


constexpr auto  reverse_partial 
 Partially apply a function to some arguments. More...


template<typename S > 
constexpr auto  accessors 
 Returns a Sequence of pairs representing the accessors of the data structure.Given a Struct S , accessors<S>() is a Sequence of Product s where the first element of each pair is the "name" of a member of the Struct , and the second element of each pair is a function that can be used to access that member when given an object of the proper data type. As described in the global documentation for Struct , the accessor functions in this sequence must be moveindependent. More...


constexpr auto  adjust 
 Apply a function on all the elements of a structure that compare equal to some value. More...


constexpr auto  adjust_if 
 Apply a function on all the elements of a structure satisfying a predicate.Given a Functor, a predicate pred and a function f , adjust_if will adjust the elements of the Functor that satisfy the predicate with the function f . In other words, adjust_if will return a new Functor equal to the original one, except that the elements satisfying the predicate will be transformed with the given function. Elements for which the predicate is not satisfied are left untouched, and they are kept asis in the resulting Functor. More...


constexpr auto  all 
 Returns whether all the keys of the structure are truevalued.The keys of the structure must be Logical s. If the structure is not finite, a falsevalued key must appear at a finite "index" in order for this method to finish. More...


constexpr auto  all_of 
 Returns whether all the keys of the structure satisfy the predicate .If the structure is not finite, predicate has to return a false valued Logical after looking at a finite number of keys for this method to finish. More...


constexpr auto  and_ 
 Return whether all the arguments are truevalued.and_ can be called with one argument or more. When called with two arguments, and_ uses tagdispatching to find the right implementation. Otherwise,. More...


constexpr auto  any 
 Returns whether any key of the structure is truevalued.The keys of the structure must be Logical s. If the structure is not finite, a truevalued key must appear at a finite "index" in order for this method to finish. More...


constexpr auto  any_of 
 Returns whether any key of the structure satisfies the predicate .If the structure is not finite, predicate has to be satisfied after looking at a finite number of keys for this method to finish. More...


constexpr auto  ap 
 Lifted application.Specifically, ap applies a structure containing functions to a structure containing values, and returns a new structure containing values. The exact way in which the functions are applied to the values depends on the Applicative . More...


constexpr auto  append 
 Append an element to a monadic structure.Given an element x and a monadic structure xs , append returns a new monadic structure which is the result of lifting x into the monadic structure and then combining that (to the right) with xs . In other words,. More...


constexpr auto  at 
 Returns the n th element of an iterable.Given an Iterable and an IntegralConstant index, at returns the element located at the index in the linearization of the iterable. Specifically, given an iterable xs with a linearization of [x1, ..., xN] , at(xs, k) is equivalent to xk . More...


template<std::size_t n> 
constexpr auto  at_c 
 Equivalent to at ; provided for convenience. More...


constexpr auto  at_key 
 Returns the value associated to the given key in a structure, or fail.Given a key and a Searchable structure, at_key returns the first value whose key is equal to the given key , and fails at compiletime if no such key exists. This requires the key to be compiletime Comparable , exactly like for find . at_key satisfies the following: More...


constexpr auto  back 
 Returns the last element of a nonempty and finite iterable.Given a nonempty and finite iterable xs with a linearization of [x1, ..., xN] , back(xs) is equal to xN . Equivalently, back(xs) must be equivalent to at_c<N1>(xs) , and that regardless of the value category of xs (back must respect the reference semantics of at ). More...


constexpr auto  cartesian_product 
 Computes the cartesian product of a sequence of sequences.Given a sequence of sequences, cartesian_product returns a new sequence of sequences containing the cartesian product of the original sequences. For this method to finish, a finite number of finite sequences must be provided. More...


constexpr auto  chain 
 Feed a monadic value into a monadic computation.Given a monadic value and a monadic function, chain feeds the monadic value into the function, thus performing some Monadspecific effects, and returns the result. An implementation of chain must satisfy. More...


constexpr auto  comparing 
 Returns a function performing equal after applying a transformation to both arguments.comparing creates an equivalence relation based on the result of applying a function to some objects, which is especially useful in conjunction with algorithms that accept a custom predicate that must represent an equivalence relation. More...


constexpr auto  concat 
 Combine two monadic structures together.Given two monadic structures, concat combines them together and returns a new monadic structure. The exact definition of concat will depend on the exact model of MonadPlus at hand, but for sequences it corresponds intuitively to simple concatenation. More...


constexpr auto  contains 
 Returns whether the key occurs in the structure.Given a Searchable structure xs and a key , contains returns whether any of the keys of the structure is equal to the given key . If the structure is not finite, an equal key has to appear at a finite position in the structure for this method to finish. For convenience, contains can also be applied in infix notation. More...


constexpr auto  in = hana::infix(hana::flip(hana::contains)) 
 Return whether the key occurs in the structure.Specifically, this is equivalent to contains , except in takes its arguments in reverse order. Like contains , in can also be applied in infix notation for increased expressiveness. This function is not a method that can be overriden; it is just a convenience function provided with the concept. More...


template<typename Tag , typename optional_T > 
constexpr auto  is_a = seedocumentation 
 Returns whether the tag of an object matches a given tag. More...


template<typename Tag , typename... T> 
constexpr auto  is_an = is_a<Tag, T...> 
 Equivalent to is_a ; provided for consistency with the rules of the English language.


template<typename Tag > 
constexpr auto  make 
 Create an object of the given tag with the given arguments. More...


template<typename To > 
constexpr auto  to 
 Converts an object from one data type to another. More...


constexpr auto  count 
 Return the number of elements in the structure that compare equal to a given value.Given a Foldable structure xs and a value value , count returns an unsigned integral, or a Constant thereof, representing the number of elements of xs that compare equal to value . For this method to be welldefined, all the elements of the structure must be Comparable with the given value. More...


constexpr auto  count_if 
 Return the number of elements in the structure for which the predicate is satisfied.Specifically, returns an object of an unsigned integral type, or a Constant holding such an object, which represents the number of elements in the structure satisfying the given predicate . More...


constexpr auto  cycle 
 Combine a monadic structure with itself n times.Given a monadic structure xs and a nonnegative number n , cycle returns a new monadic structure which is the result of combining xs with itself n times using the concat operation. In other words,. More...


constexpr auto  div 
 Generalized integer division. More...


constexpr auto  drop_back 
 Drop the last n elements of a finite sequence, and return the rest.Given a finite Sequence xs with a linearization of [x1, ..., xm] and a nonnegative IntegralConstant n , drop_back(xs, n) is a sequence with the same tag as xs whose linearization is [x1, ..., xmn] . If n is not given, it defaults to an IntegralConstant with a value equal to 1 . More...


constexpr auto  drop_front 
 Drop the first n elements of an iterable, and return the rest.Given an Iterable xs with a linearization of [x1, x2, ...] and a nonnegative IntegralConstant n , drop_front(xs, n) is an iterable with the same tag as xs whose linearization is [xn+1, xn+2, ...] . In particular, note that this function does not mutate the original iterable in any way. If n is not given, it defaults to an IntegralConstant with a value equal to 1 . More...


constexpr auto  drop_front_exactly 
 Drop the first n elements of an iterable, and return the rest.Given an Iterable xs with a linearization of [x1, x2, ...] and a nonnegative IntegralConstant n , drop_front_exactly(xs, n) is an iterable with the same tag as xs whose linearization is [xn+1, xn+2, ...] . In particular, note that this function does not mutate the original iterable in any way. If n is not given, it defaults to an IntegralConstant with a value equal to 1 . More...


constexpr auto  drop_while 
 Drop elements from an iterable up to, but excluding, the first element for which the predicate is not satisfied.Specifically, drop_while returns an iterable containing all the elements of the original iterable except for those in the range delimited by [head , e ), where head is the first element and e is the first element for which the predicate is not satisfied. If the iterable is not finite, the predicate has to return a false valued Logical at a finite index for this method to return. More...


constexpr auto  duplicate 
 Add an extra layer of comonadic context to a comonadic value.Given a value already in a comonadic context, duplicate wraps this value with an additional layer of comonadic context. This can be seen as the dual operation to flatten from the Monad concept. More...


template<typename M > 
constexpr auto  empty 
 Identity of the monadic combination concat .Signature
Given a MonadPlus M , the signature is \( \mathtt{empty}_M : \emptyset \to M(T) \). More...


constexpr auto  equal 
 Returns a Logical representing whether x is equal to y .The equal function can be called in two different ways. First, it can be called like a normal function: More...


constexpr auto  eval_if 
 Conditionally execute one of two branches based on a condition.Given a condition and two branches in the form of lambdas or hana::lazy s, eval_if will evaluate the branch selected by the condition with eval and return the result. The exact requirements for what the branches may be are the same requirements as those for the eval function. More...


constexpr auto  extend 
 Comonadic application of a function to a comonadic value.Given a comonadic value and a function accepting a comonadic input, extend returns the result of applying the function to that input inside the comonadic context. More...


constexpr auto  extract 
 Extract a value in a given comonadic context.Given a value inside a comonadic context, extract it from that context, performing whatever effects are mandated by that context. This can be seen as the dual operation to the lift method of the Applicative concept. More...


constexpr auto  fill 
 Replace all the elements of a structure with a fixed value. More...


constexpr auto  filter 
 Filter a monadic structure using a custom predicate.Given a monadic structure and a predicate, filter returns a new monadic structure containing only those elements that satisfy the predicate. This is a generalization of the usual filter function for sequences; it works for any MonadPlus. Intuitively, filter is somewhat equivalent to: More...


constexpr auto  find 
 Finds the value associated to the given key in a structure.Given a key and a Searchable structure, find returns the just the first value whose key is equal to the given key , or nothing if there is no such key. Comparison is done with equal . find satisfies the following: More...


constexpr auto  find_if 
 Finds the value associated to the first key satisfying a predicate.Given a Searchable structure xs and a predicate pred , find_if(xs, pred) returns just the first element whose key satisfies the predicate, or nothing if there is no such element. More...


constexpr auto  first 
 Returns the first element of a pair.Note that if the Product actually stores the elements it contains, hana::first is required to return a lvalue reference, a lvalue reference to const or a rvalue reference to the first element, where the type of reference must match that of the pair passed to first . If the Product does not store the elements it contains (i.e. it generates them on demand), this requirement is dropped. More...


constexpr auto  flatten 
 Collapse two levels of monadic structure into a single level.Given a monadic value wrapped into two levels of monad, flatten removes one such level. An implementation of flatten must satisfy. More...


constexpr auto  fold = fold_left 
 Equivalent to fold_left ; provided for convenience.fold is equivalent to fold_left . However, it is not tagdispatched on its own because it is just an alias to fold_left . Also note that fold can be called with or without an initial state, just like fold_left : More...


constexpr auto  fold_left 
 Leftfold of a structure using a binary operation and an optional initial reduction state.fold_left is a leftassociative fold using a binary operation. Given a structure containing x1, ..., xn , a function f and an optional initial state, fold_left applies f as follows. More...


constexpr auto  fold_right 
 Rightfold of a structure using a binary operation and an optional initial reduction state.fold_right is a rightassociative fold using a binary operation. Given a structure containing x1, ..., xn , a function f and an optional initial state, fold_right applies f as follows. More...


constexpr auto  for_each 
 Perform an action on each element of a foldable, discarding the result each time.Iteration is done from left to right, i.e. in the same order as when using fold_left . If the structure is not finite, this method will not terminate. More...


constexpr auto  front 
 Returns the first element of a nonempty iterable.Given a nonempty Iterable xs with a linearization of [x1, ..., xN] , front(xs) is equal to x1 . If xs is empty, it is an error to use this function. Equivalently, front(xs) must be equivalent to at_c<0>(xs) , and that regardless of the value category of xs (front must respect the reference semantics of at ). More...


constexpr auto  fuse 
 Transform a function taking multiple arguments into a function that can be called with a compiletime Foldable . More...


constexpr auto  greater 
 Returns a Logical representing whether x is greater than y . More...


constexpr auto  greater_equal 
 Returns a Logical representing whether x is greater than or equal to y . More...


constexpr auto  group 
 Group adjacent elements of a sequence that all respect a binary predicate, by default equality.Given a finite Sequence and an optional predicate (by default equal ), group returns a sequence of subsequences representing groups of adjacent elements that are "equal" with respect to the predicate. In other words, the groups are such that the predicate is satisfied when it is applied to any two adjacent elements in that group. The sequence returned by group is such that the concatenation of its elements is equal to the original sequence, which is equivalent to saying that the order of the elements is not changed. More...


constexpr auto  hash 
 Returns a hana::type representing the compiletime hash of an object.Given an arbitrary object x , hana::hash returns a hana::type representing the hash of x . In normal programming, hashes are usually numerical values that can be used e.g. as indices in an array as part of the implementation of a hash table. In the context of metaprogramming, we are interested in typelevel hashes instead. Thus, hana::hash must return a hana::type object instead of an integer. This hana::type must somehow summarize the object being hashed, but that summary may of course lose some information. More...


constexpr auto  if_ 
 Conditionally return one of two values based on a condition.Specifically, then is returned iff cond is truevalued, and else_ is returned otherwise. Note that some Logical models may allow then and else_ to have different types, while others may require both values to have the same type. More...


constexpr auto  index_if 
 Finds the value associated to the first key satisfying a predicate.Given an Iterable structure xs and a predicate pred , index_if(xs, pred) returns a hana::optional containing an IntegralConstant of the index of the first element that satisfies the predicate or nothing if no element satisfies the predicate. More...


constexpr insert_t  insert {} 
 Insert a value at a given index in a sequence.Given a sequence, an index and an element to insert, insert inserts the element at the given index. More...


constexpr auto  insert_range 
 Insert several values at a given index in a sequence.Given a sequence, an index and any Foldable containing elements to insert, insert_range inserts the elements in the Foldable at the given index of the sequence. More...


constexpr auto  intersperse 
 Insert a value between each pair of elements in a finite sequence.Given a finite Sequence xs with a linearization of [x1, x2, ..., xn] , intersperse(xs, z) is a new sequence with a linearization of [x1, z, x2, z, x3, ..., xn1, z, xn] . In other words, it inserts the z element between every pair of elements of the original sequence. If the sequence is empty or has a single element, intersperse returns the sequence asis. In all cases, the sequence must be finite. More...


constexpr auto  is_disjoint 
 Returns whether two Searchable s are disjoint.Given two Searchable s xs and ys , is_disjoint returns a Logical representing whether the keys in xs are disjoint from the keys in ys , i.e. whether both structures have no keys in common. More...


constexpr auto  is_empty 
 Returns whether the iterable is empty.Given an Iterable xs , is_empty returns whether xs contains no more elements. In other words, it returns whether trying to extract the tail of xs would be an error. In the current version of the library, is_empty must return an IntegralConstant holding a value convertible to bool . This is because only compiletime Iterable s are supported right now. More...


constexpr auto  is_subset 
 Returns whether a structure contains a subset of the keys of another structure.Given two Searchable s xs and ys , is_subset returns a Logical representing whether xs is a subset of ys . In other words, it returns whether all the keys of xs are also present in ys . This method does not return whether xs is a strict subset of ys ; if xs and ys are equal, all the keys of xs are also present in ys , and is_subset returns true. More...


constexpr keys_t  keys {} 
 Returns a Sequence containing the name of the members of the data structure.Given a Struct object, keys returns a Sequence containing the name of all the members of the Struct , in the same order as they appear in the accessors sequence. More...


constexpr auto  length 
 Return the number of elements in a foldable structure.Given a Foldable xs , length(xs) must return an object of an unsigned integral type, or an IntegralConstant holding such an object, which represents the number of elements in the structure. More...


constexpr auto  less 
 Returns a Logical representing whether x is less than y . More...


constexpr auto  less_equal 
 Returns a Logical representing whether x is less than or equal to y . More...


constexpr auto  lexicographical_compare 
 Shortcircuiting lexicographical comparison of two Iterable s with an optional custom predicate, by default hana::less .Given two Iterable s xs and ys and a binary predicate pred , lexicographical_compare returns whether xs is to be considered less than ys in a lexicographical ordering. Specifically, let's denote the linearizations of xs and ys by [x1, x2, ...] and [y1, y2, ...] , respectively. If the first couple satisfying the predicate is of the form xi, yi , lexicographical_compare returns true. Otherwise, if the first couple to satisfy the predicate is of the form yi, xi , lexicographical_compare returns false. If no such couple can be found, lexicographical_compare returns whether xs has fewer elements than ys . More...


template<typename A > 
constexpr auto  lift 
 Lift a value into an Applicative structure.lift<A> takes a normal value and embeds it into a structure whose shape is represented by the A Applicative . Note that the value may be a function, in which case the created structure may be ap plied to another Applicative structure containing values. More...


constexpr auto  max 
 Returns the greatest of its arguments according to the less ordering. More...


constexpr auto  maximum 
 Return the greatest element of a nonempty structure with respect to a predicate , by default less .Given a nonempty structure and an optional binary predicate (less by default), maximum returns the greatest element of the structure, i.e. an element which is greater than or equal to every other element in the structure, according to the predicate. More...


constexpr auto  members 
 Returns a Sequence containing the members of a Struct .Given a Struct object, members returns a Sequence containing all the members of the Struct , in the same order as their respective accessor appears in the accessors sequence. More...


constexpr auto  min 
 Returns the smallest of its arguments according to the less ordering. More...


constexpr auto  minimum 
 Return the least element of a nonempty structure with respect to a predicate , by default less .Given a nonempty structure and an optional binary predicate (less by default), minimum returns the least element of the structure, i.e. an element which is less than or equal to every other element in the structure, according to the predicate. More...


constexpr auto  minus 
 Subtract two elements of a group.Specifically, this performs the Monoid operation on the first argument and on the inverse of the second argument, thus being equivalent to: More...


constexpr auto  mod 
 Generalized integer modulus.Given two elements of an EuclideanRing x and y , with y nonzero, mod returns the modulus of the division of x by y . In other words, mod can be seen as an equivalent to % . More...


constexpr auto  monadic_compose 
 Composition of monadic functions.Given two monadic functions f and g , monadic_compose returns a new function equivalent to the composition of f with g , except the result of g is chain ed into f instead of simply passed to it, as with normal composition. monadic_compose satisfies. More...


template<typename M > 
constexpr auto  monadic_fold_left 
 Monadic leftfold of a structure with a binary operation and an optional initial reduction state. More...


template<typename M > 
constexpr auto  monadic_fold_right 
 Monadic rightfold of a structure with a binary operation and an optional initial reduction state. More...


constexpr auto  mult 
 Associative operation of a Ring . More...


constexpr auto  negate 
 Return the inverse of an element of a group. More...


constexpr auto  none 
 Returns whether all of the keys of the structure are falsevalued.The keys of the structure must be Logical s. If the structure is not finite, a truevalued key must appear at a finite "index" in order for this method to finish. More...


constexpr auto  none_of 
 Returns whether none of the keys of the structure satisfy the predicate .If the structure is not finite, predicate has to return a true valued Logical after looking at a finite number of keys for this method to finish. More...


constexpr auto  not_ 
 Negates a Logical .This method returns a Logical with the same tag, but whose truthvalue is negated. Specifically, not_(x) returns a falsevalued Logical if x is a truevalued Logical , and a truevalued one otherwise. More...


constexpr auto  not_equal 
 Returns a Logical representing whether x is not equal to y .The not_equal function can be called in two different ways. First, it can be called like a normal function: More...


template<typename R > 
constexpr auto  one 
 Identity of the Ring multiplication. More...


constexpr auto  or_ 
 Return whether any of the arguments is truevalued.or_ can be called with one argument or more. When called with two arguments, or_ uses tagdispatching to find the right implementation. Otherwise,. More...


constexpr auto  ordering 
 Returns a function performing less after applying a transformation to both arguments.ordering creates a total order based on the result of applying a function to some objects, which is especially useful in conjunction with algorithms that accept a custom predicate that must represent a total order. More...


constexpr auto  partition 
 Partition a sequence based on a predicate .Specifically, returns an unspecified Product whose first element is a sequence of the elements satisfying the predicate, and whose second element is a sequence of the elements that do not satisfy the predicate. More...


constexpr auto  permutations 
 Return a sequence of all the permutations of the given sequence.Specifically, permutations(xs) is a sequence whose elements are permutations of the original sequence xs . The permutations are not guaranteed to be in any specific order. Also note that the number of permutations grows very rapidly as the length of the original sequence increases. The growth rate is O(length(xs)!) ; with a sequence xs of length only 8, permutations(xs) contains over 40 000 elements! More...


constexpr auto  plus 
 Associative binary operation on a Monoid . More...


constexpr auto  power 
 Elevate a ring element to its n th power.Specifically, power(x, n) , is equivalent to multiplying x with itself n times using the Ring's multiplication. If the power is equal to zero , the Ring's identity (one ) is returned. More...


constexpr auto  prefix 
 Inserts a value before each element of a monadic structure.Given a monadic structure xs and a value z called the prefix, prefix returns a new monadic structure. prefix satisfies. More...


constexpr auto  prepend 
 Prepend an element to a monadic structure.Given a monadic structure xs and an element x , prepend returns a new monadic structure which is the result of lifting x into the monadic structure and then combining that (to the left) with xs . In other words,. More...


constexpr auto  product = see documentation 
 Compute the product of the numbers of a structure.More generally, product will take any foldable structure containing objects forming a Ring and reduce them using the Ring's binary operation. The initial state for folding is the identity of the Ring's operation. It is sometimes necessary to specify the Ring to use; this is possible by using product<R> . If no Ring is specified, the structure will use the Ring formed by the elements it contains (if it knows it), or integral_constant_tag<int> otherwise. Hence,. More...


constexpr auto  remove 
 Remove all the elements of a monadic structure that are equal to some value.Given a monadic structure xs and a value , remove returns a new monadic structure equal to xs without all its elements that are equal to the given value . remove is equivalent to remove_if with the equal.to(value) predicate, i.e. More...


constexpr auto  remove_at 
 Remove the element at a given index from a sequence.remove_at returns a new sequence identical to the original, except that the element at the given index is removed. Specifically, remove_at([x0, ..., xn1, xn, xn+1, ..., xm], n) is a new sequence equivalent to [x0, ..., xn1, xn+1, ..., xm] . More...


template<std::size_t n> 
constexpr auto  remove_at_c 
 Equivalent to remove_at ; provided for convenience. More...


constexpr auto  remove_if 
 Remove all the elements of a monadic structure that satisfy some predicate.Given a monadic structure xs and a unary predicate, remove_if returns a new monadic structure equal to xs without all its elements that satisfy the predicate. This is equivalent to filter with a negated predicate, i.e. More...


constexpr auto  remove_range 
 Remove the elements inside a given range of indices from a sequence.remove_range returns a new sequence identical to the original, except that elements at indices in the provided range are removed. Specifically, remove_range([x0, ..., xn], from, to) is a new sequence equivalent to [x0, ..., x_from1, x_to, ..., xn] . More...


template<std::size_t from, std::size_t to> 
constexpr auto  remove_range_c 
 Equivalent to remove_range ; provided for convenience. More...


constexpr auto  repeat 
 Invokes a nullary function n times.Given an IntegralConstant n and a nullary function f , repeat(n, f) will call f n times. In particular, any decent compiler should expand repeat(n, f) to. More...


constexpr auto  replace 
 Replace all the elements of a structure that compare equal to some value with some new fixed value. More...


constexpr auto  replace_if 
 Replace all the elements of a structure satisfying a predicate with a fixed value. More...


template<typename M > 
constexpr auto  replicate 
 Create a monadic structure by combining a lifted value with itself n times.Given a value x , a nonnegative IntegralConstant n and the tag of a monadic structure M , replicate creates a new monadic structure which is the result of combining x with itself n times inside the monadic structure. In other words, replicate simply lift s x into the monadic structure, and then combines that with itself n times: More...


constexpr auto  reverse 
 Reverse a sequence.Specifically, reverse(xs) is a new sequence containing the same elements as xs , except in reverse order. More...


constexpr auto  reverse_fold 
 Equivalent to reverse_fold in Boost.Fusion and Boost.MPL.This method has the same semantics as reverse_fold in Boost.Fusion and Boost.MPL, with the extension that an initial state is not required. This method is equivalent to fold_right , except that the accumulating function must take its arguments in reverse order, to match the order used in Fusion. In other words,. More...


constexpr auto  scan_left 
 Fold a Sequence to the left and return a list containing the successive reduction states.Like fold_left , scan_left reduces a sequence to a single value using a binary operation. However, unlike fold_left , it builds up a sequence of the intermediary results computed along the way and returns that instead of only the final reduction state. Like fold_left , scan_left can be used with or without an initial reduction state. More...


constexpr auto  scan_right 
 Fold a Sequence to the right and return a list containing the successive reduction states.Like fold_right , scan_right reduces a sequence to a single value using a binary operation. However, unlike fold_right , it builds up a sequence of the intermediary results computed along the way and returns that instead of only the final reduction state. Like fold_right , scan_right can be used with or without an initial reduction state. More...


constexpr auto  second 
 Returns the second element of a pair.Note that if the Product actually stores the elements it contains, hana::second is required to return a lvalue reference, a lvalue reference to const or a rvalue reference to the second element, where the type of reference must match that of the pair passed to second . If the Product does not store the elements it contains (i.e. it generates them on demand), this requirement is dropped. More...


constexpr auto  size = hana::length 
 Equivalent to length ; provided for consistency with the standard library.This method is an alias to length provided for convenience and consistency with the standard library. As an alias, size is not tagdispatched on its own and length should be customized instead. More...


constexpr auto  slice 
 Extract the elements of a Sequence at the given indices.Given an arbitrary sequence of indices , slice returns a new sequence of the elements of the original sequence that appear at those indices. In other words,. More...


template<std::size_t from, std::size_t to> 
constexpr auto  slice_c 
 Shorthand to slice a contiguous range of elements.slice_c is simply a shorthand to slice a contiguous range of elements. In particular, slice_c<from, to>(xs) is equivalent to slice(xs, range_c<std::size_t, from, to>) , which simply slices all the elements of xs contained in the halfopen interval delimited by [from, to) . Like for slice , the indices used with slice_c are 0based and they must be in the bounds of the sequence being sliced. More...


constexpr auto  sort 
 Sort a sequence, optionally based on a custom predicate .Given a Sequence and an optional predicate (by default less ), sort returns a new sequence containing the same elements as the original, except they are ordered in such a way that if x comes before y in the sequence, then either predicate(x, y) is true, or both predicate(x, y) and predicate(y, x) are false. More...


constexpr auto  span 
 Returns a Product containing the longest prefix of a sequence satisfying a predicate, and the rest of the sequence.The first component of the returned Product is a sequence for which all elements satisfy the given predicate. The second component of the returned Product is a sequence containing the remainder of the argument. Both or either sequences may be empty, depending on the input argument. More specifically,. More...


constexpr auto  suffix 
 Inserts a value after each element of a monadic structure.Given a monadic structure xs and a value z (called the suffix), suffix returns a new monadic structure such that. More...


constexpr auto  sum = see documentation 
 Compute the sum of the numbers of a structure.More generally, sum will take any foldable structure containing objects forming a Monoid and reduce them using the Monoid's binary operation. The initial state for folding is the identity of the Monoid. It is sometimes necessary to specify the Monoid to use; this is possible by using sum<M> . If no Monoid is specified, the structure will use the Monoid formed by the elements it contains (if it knows it), or integral_constant_tag<int> otherwise. Hence,. More...


constexpr auto  take_back 
 Returns the last n elements of a sequence, or the whole sequence if the sequence has less than n elements.Given a Sequence xs and an IntegralConstant n , take_back(xs, n) is a new sequence containing the last n elements of xs , in the same order. If length(xs) <= n , the whole sequence is returned and no error is triggered. More...


constexpr auto  take_front 
 Returns the first n elements of a sequence, or the whole sequence if the sequence has less than n elements.Given a Sequence xs and an IntegralConstant n , take_front(xs, n) is a new sequence containing the first n elements of xs , in the same order. If length(xs) <= n , the whole sequence is returned and no error is triggered. More...


template<std::size_t n> 
constexpr auto  take_front_c 
 Equivalent to take_front ; provided for convenience. More...


constexpr auto  take_while 
 Take elements from a sequence while the predicate is satisfied.Specifically, take_while returns a new sequence containing the longest prefix of xs in which all the elements satisfy the given predicate. More...


template<typename M > 
constexpr auto  tap 
 Tap inside a monadic chain.Given a function f , tap<M> returns a new function which performs f on its argument and then returns the argument lifted in the M Monad . Combined with the property that chain(m, lift<M>) == m , this provides a way of executing an action inside a monadic chain without influencing its overall result. This is useful to e.g. insert debug statements or perform actions that are not tied to the chain but that need to be executed inside of it. More...


constexpr auto  then 
 Sequentially compose two monadic actions, discarding any value produced by the first but not its effects. More...


constexpr auto  transform 
 Map a function over a Functor . More...


template<template< typename... > class F> 
constexpr auto  template_ 
 Lift a template to a Metafunction.Given a template class or template alias f , template_<f> is a Metafunction satisfying. More...


template<template< typename... > class F> 
constexpr auto  metafunction 
 Lift a MPLstyle metafunction to a Metafunction.Given a MPLstyle metafunction, metafunction<f> is a Metafunction satisfying. More...


template<typename F > 
constexpr auto  metafunction_class 
 Lift a MPLstyle metafunction class to a Metafunction.Given a MPLstyle metafunction class, metafunction_class<f> is a Metafunction satisfying. More...


constexpr auto  integral 
 Turn a Metafunction into a function taking type s and returning a defaultconstructed object.Given a Metafunction f , integral returns a new Metafunction that defaultconstructs an object of the type returned by f . More specifically, the following holds: More...


template<template< typename... > class F> 
constexpr auto  trait = hana::integral(hana::metafunction<F>) 
 Alias to integral(metafunction<F>) , provided for convenience. More...


template<typename S > 
constexpr auto  unfold_left 
 Dual operation to fold_left for sequences.While fold_left reduces a structure to a summary value from the left, unfold_left builds a sequence from a seed value and a function, starting from the left. More...


template<typename S > 
constexpr auto  unfold_right 
 Dual operation to fold_right for sequences.While fold_right reduces a structure to a summary value from the right, unfold_right builds a sequence from a seed value and a function, starting from the right. More...


constexpr auto  unique 
 Removes all consecutive duplicate elements from a Sequence.Given a Sequence and an optional binary predicate, unique returns a new sequence containing only the first element of every subrange of the original sequence whose elements are all equal. In other words, it turns a sequence of the form [a, a, b, c, c, c, d, d, d, a] into a sequence [a, b, c, d, a] . The equality of two elements is determined by the provided predicate , or by equal if no predicate is provided. More...


constexpr auto  unpack 
 Invoke a function with the elements of a Foldable as arguments.Given a function and a foldable structure whose length can be known at compiletime, unpack invokes the function with the contents of that structure. In other words, unpack(xs, f) is equivalent to f(x...) , where x... are the elements of the structure. The length of the structure must be known at compiletime, because the version of f 's operator() that will be compiled depends on the number of arguments it is called with, which has to be known at compiletime. More...


template<typename T > 
constexpr auto  value 
 Return the compiletime value associated to a constant.This function returns the value associated to a Constant . That value is always a constant expression. The normal way of using value on an object c is. More...


constexpr auto  value_of 
 Equivalent to value , but can be passed to higherorder algorithms.This function object is equivalent to value , except it can be passed to higher order algorithms because it is a function object. value can't be passed to higherorder algorithms because it is implemented as an overloaded function. More...


constexpr auto  while_ 
 Apply a function to an initial state while some predicate is satisfied.This method is a natural extension of the while language construct to manipulate a state whose type may change from one iteration to another. However, note that having a state whose type changes from one iteration to the other is only possible as long as the predicate returns a Logical whose truth value is known at compiletime. More...


template<typename M > 
constexpr auto  zero 
 Identity of plus . More...


constexpr auto  zip 
 Zip one sequence or more.Given n sequences s1, ..., sn , zip produces a sequence whose i th element is a tuple of (s1[i], ..., sn[i]) , where sk[i] denotes the i th element of the k th sequence. In other words, zip produces a sequence of the form. More...


constexpr auto  zip_shortest 
 Zip one sequence or more.Given n sequences s1, ..., sn , zip_shortest produces a sequence whose i th element is a tuple of (s1[i], ..., sn[i]) , where sk[i] denotes the i th element of the k th sequence. In other words, zip_shortest produces a sequence of the form. More...


constexpr auto  zip_shortest_with 
 Zip one sequence or more with a given function.Given a n ary function f and n sequences s1, ..., sn , zip_shortest_with produces a sequence whose i th element is f(s1[i], ..., sn[i]) , where sk[i] denotes the i th element of the k th sequence. In other words, zip_shortest_with produces a sequence of the form. More...


constexpr auto  zip_with 
 Zip one sequence or more with a given function.Given a n ary function f and n sequences s1, ..., sn , zip_with produces a sequence whose i th element is f(s1[i], ..., sn[i]) , where sk[i] denotes the i th element of the k th sequence. In other words, zip_with produces a sequence of the form. More...

