ContainerOut justs(const ContainerIn& xs)
{
typedef typename ContainerIn::value_type::type T;
auto justsInMaybes = keep_if(is_just<T>, xs);
ContainerOut ys;
internal::prepare_container(ys, fplus::size_of_cont(justsInMaybes));
auto itOut = internal::get_back_inserter<ContainerOut>(ys);
std::transform(std::begin(justsInMaybes), std::end(justsInMaybes),
itOut, unsafe_get_just<T>);
return ys;
}
ContainerOut errors(const ContainerIn& xs)
{
typedef typename ContainerIn::value_type::ok_t Ok;
typedef typename ContainerIn::value_type::error_t Error;
auto errorsInResults = keep_if(is_error<Ok, Error>, xs);
ContainerOut ys;
internal::prepare_container(ys, fplus::size_of_cont(errorsInResults));
auto itOut = internal::get_back_inserter<ContainerOut>(ys);
std::transform(std::begin(errorsInResults), std::end(errorsInResults),
itOut, unsafe_get_error<Ok, Error>);
return ys;
}
ContainerOut combinations(std::size_t power, const ContainerIn& xs_in)
{
if (power == 0)
return ContainerOut(1);
std::vector<T> xs = convert_container<std::vector<T>>(xs_in);
auto idxs = all_idxs(xs);
typedef std::vector<std::size_t> idx_vec;
auto result_idxss = keep_if(is_strictly_sorted<idx_vec>,
internal::helper_carthesian_product_n_idxs(power, idxs));
typedef typename ContainerOut::value_type ContainerOutInner;
auto to_result_cont = [&](const std::vector<std::size_t>& indices)
{
return convert_container_and_elems<ContainerOutInner>(
elems_at_idxs(indices, xs));
};
return transform(to_result_cont, result_idxss);
}
ContainerOut drop_if(Pred pred, Container&& xs)
{
return keep_if(logical_not(pred), std::forward<Container>(xs));
}
