Boost.Hana: MonadPlus . Boost , ,

Boost.Hana 1.0.1

Your standard library for metaprogramming

Концепция MonadPlus представляет Монады с моноидальной структурой.

Intuitively, whereas a Monad can be seen as some kind of container or context, a MonadPlus can be seen as a container or a context that can be concatenated with other container or contexts. Также должен быть элемент идентификации для этой комбинированной операции. Например, тюль является MonadPlus, потому что толщины могут быть конкатенированы, и пустой тюпель будет действовать как личность для конкатации. Чем это отличается от Монада, который также является Моноидом? Ответ заключается в том, что моноидальная структура на MonadPlus должна не зависеть от содержания структуры; она не должна требовать, чтобы содержимое было Monoid для работы.

Хотя последовательности не являются единственной возможной моделью для MonadPlus, используемые здесь названия методов относятся к MonadPlus последовательностей под концентрацией. Несколько полезных функций, обобщающих операции по последовательностям, включены в эту концепцию, например, добавьте, prepend и filter.

Note: This documentation does not go into much details about the nature of the MonadPlus concept. However, there is a nice Haskell-oriented WikiBook going into further details.

Minimal complete definition

наконец и пустое

Laws

Во-первых, MonadPlus должен иметь моноидальную структуру. Поэтому неудивительно, что для любого MonadPlus M мы требуем, чтобы M(T) был действительным моноидом. Тем не менее, мы не утверждаем, что M(T) фактически моделирует концепцию Monoid, предоставленную Ханой. далее для всех объектов a, b, c типа данных M(T),

// identity
concat(empty<M(T)>(), a) == a
concat(a, empty<M(T)>()) == a
// associativity
concat(a, concat(b, c)) == concat(concat(a, b), c)

Во-вторых, MonadPlus также обязан соблюдать следующие законы, которые представляют собой тот факт, что empty() должен быть какой-то поглощающий элемент для операции chain. для всех объектов a типа данных M(T) и функций \( f : T \ to M(U) \),

chain(empty<M(T)>(), f) == empty<M(U)>()

chain(a, always(empty<M(T)>())) == empty<M(U)>()

Refined concepts

Функтор, Приложение и Монад

Concrete models

хана:: опционально, хана::tuple

Variables
constexpr auto	boost::hana::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	boost::hana::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	boost::hana::cycle
	Combine a monadic structure with itself `n` times.Given a monadic structure `xs` and a non-negative 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...

template<typename M >
constexpr auto	boost::hana::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	boost::hana::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	boost::hana::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	boost::hana::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	boost::hana::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	boost::hana::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...

template<typename M >
constexpr auto	boost::hana::replicate
	Create a monadic structure by combining a lifted value with itself `n` times.Given a value `x`, a non-negative `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	boost::hana::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...

Variable Documentation

constexpr auto boost::hana::append

#include <boost/hana/fwd/append.hpp>

Initial value:

= [](auto&& xs, auto&& x) {
        return tag-dispatched;
    }

Приложите элемент к монадической структуре. Учитывая элемент x и монадичную структуру xs, добавьте возвращает новую монадичную структуру, которая является результатом подъема x в монадическую структуру, а затем объединения ее (справа) с xs. Другими словами.

append(xs, x) == concat(xs, lift<Xs>(x))

где Xs является тегом xs. Для последовательностей это имеет интуитивное поведение, просто добавляя элемент к концу последовательности, отсюда и название.

Rationale for not calling this push_back

См. обоснование использования prepend вместо push_front.

Signature

Учитывая MonadPlus M, подпись является \(\mathtt{append} : M(T) \times T \to M(T) \.

Parameters

xs	Монадическая структура, которая будет объединена слева от элемента.
x	Элемент, соединяющий с правом монадической структуры.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/append.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::append(hana::make_tuple(), 1) == hana::make_tuple(1), "");
static_assert(hana::append(hana::make_tuple(1, '2'), 3.3) == hana::make_tuple(1, '2', 3.3), "");
static_assert(hana::append(hana::append(hana::append(hana::make_tuple(), 1), '2'), 3.3) == hana::make_tuple(1, '2', 3.3), "");
int main() { }

constexpr auto boost::hana::concat

#include <boost/hana/fwd/concat.hpp>

Initial value:

= [](auto&& xs, auto&& ys) {
        return tag-dispatched;
    }

Объедините два монадичных сооружения вместе. Учитывая две монадические структуры, concat объединяет их вместе и возвращает новую монадичную структуру. Точное определение concat будет зависеть от точной модели MonadPlus под рукой, но для последовательностей оно интуитивно соответствует простой концентрации.

Также обратите внимание, что сочетание не обязательно должно быть коммутативным. Иными словами, не требуется, чтобы

concat(xs, ys) == concat(ys, xs)

и не в целом.

Signature

Учитывая MonadPlus M, подпись concat является \( \mathtt{concat} : M(T) \times M(T) \ to M(T) \.

Parameters

xs,ys Две монадические структуры, чтобы объединиться.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/concat.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
using namespace hana::literals;
static_assert(
    hana::concat(hana::make_tuple(1, '2'), hana::make_tuple(3.3, 4_c))
        ==
    hana::make_tuple(1, '2', 3.3, 4_c)
, "");
int main() { }

constexpr auto boost::hana::cycle

#include <boost/hana/fwd/cycle.hpp>

Initial value:

= [](auto&& xs, auto const& n) {
        return tag-dispatched;
    }

Объедините монадичную структуру с собой n раз. Учитывая монадичную структуру xs и неотрицательный номер n, цикл возвращает новую монадичную структуру, которая является результатом объединения xs с собой n раз с помощью операции concat. Другими словами.

cycle(xs, n) == concat(xs, concat(xs, ... concat(xs, xs)))

// ^^^^^ n times total

Также обратите внимание, что поскольку concat требуется быть ассоциативными, мы также могли бы написать

cycle(xs, n) == concat(concat(... concat(xs, xs), xs), xs)

// ^^^^^ n times total

Если n равен нулю, то возвращается идентификация concat, пустая. В случае последовательностей это сводится к возврату последовательности, содержащей n копии себя; для других моделей это может отличаться.

Signature

Учитывая IntegralConstant C и MonadPlus M, подпись \(\mathrm{cycle}} : M(T) \times C \to M(T) \.

Parameters

xs	Монадическая структура, чтобы объединить с собой определенное количество раз.
n	Неотрицательный `IntegralConstant` представляет количество раз, чтобы объединить монадичную структуру с собой. Если `n` равен нулю, `цикл` возвращает `пустое`.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/cycle.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::cycle(hana::make_tuple('x', 'y'), hana::size_c<2>) == hana::make_tuple('x', 'y', 'x', 'y'), "");
int main() { }

template<typename M >

constexpr auto boost::hana::empty

#include <boost/hana/fwd/empty.hpp>

Initial value:

= []() {
        return tag-dispatched;
    }

Идентификация монадической комбинации concat.

Сигнатура

Учитывая MonadPlus M, подпись является \( \mathtt{empty}_M : \emptyset \to M(T)\).

Template Parameters

M	Тег монадической структуры, чтобы вернуться. Это должно быть моделью концепции MonadPlus.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/empty.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::empty<hana::tuple_tag>() == hana::make_tuple());
BOOST_HANA_CONSTANT_CHECK(hana::empty<hana::optional_tag>() == hana::nothing);
int main() { }

constexpr auto boost::hana::filter

#include <boost/hana/fwd/filter.hpp>

Initial value:

= [](auto&& xs, auto&& pred) {
        return tag-dispatched;
    }

Фильтрировать монадическую структуру с помощью пользовательского предика. Учитывая монадическую структуру и предикат, фильтр возвращает новую монадическую структуру, содержащую только те элементы, которые удовлетворяют предикату. Это обобщение обычной функции фильтр для последовательностей; она работает для любого MonadPlus. Интуитивно, фильтр несколько эквивалентен:

filter(xs, pred) == flatten(transform(xs, [](auto x) {
    return pred(x) ? lift<Xs>(x) : empty<Xs>();
})

Другими словами, мы в основном превращаем монадичную структуру, содержащую [x1, ..., xn] в монадическую структуру, содержащую

[
    pred(x1) ? [x1] : [],
    pred(x2) ? [x2] : [],
    ...
    pred(xn) ? [xn] : []
]

и мы затем раздуваем это.


Signature 
Учитывая MonadPlus M и IntegralConstant Bool, владеющий значением типа bool, подпись \(\mathtt{filter}: M(T) \times (T \to \mathtt{Bool}) \ to M(T) \.
Parameters

  
    xs Монадическая структура для фильтрации.
    pred Функция называется pred(x) для каждого элемента x в монадической структуре и возвращает, должен ли этот элемент быть kept в соответствующей структуре. В текущей версии библиотеки предикат должен вернуть IntegralConstant, удерживающее значение конвертируемое в bool.
  
  

Example 
// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/filter.hpp>
#include <boost/hana/functional/compose.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <type_traits>
namespace hana = boost::hana;
// First take the type of an object, and then tell whether it's integral
constexpr auto is_integral = hana::compose(hana::trait<std::is_integral>, hana::typeid_);
static_assert(hana::filter(hana::make_tuple(1, 2.0, 3, 4.0), is_integral) == hana::make_tuple(1, 3), "");
static_assert(hana::filter(hana::just(3), is_integral) == hana::just(3), "");
BOOST_HANA_CONSTANT_CHECK(hana::filter(hana::just(3.0), is_integral) == hana::nothing);
int main() { }





      
        
          constexpr auto boost::hana::prefix
        
      

#include <boost/hana/fwd/prefix.hpp>
Initial value:= [](auto&& xs, auto&& pref) {
        return tag-dispatched;
    }

Вставляет значение перед каждым элементом монадической структуры. Учитывая монадичную структуру xs и значение z, называемое префиксом, префикс возвращает новую монадическую структуру. префикс удовлетворяет.
prefix(xs, z) == flatten(transform(xs, [](auto x) {
    return concat(lift<M>(z), lift<M>(x));
}))
Для последовательностей это просто соответствует вставке префикса перед каждым элементом последовательности. Например, при наличии последовательности [x1, ..., xn], префикс вернется
[z, x1, z, x2, ..., z, xn]
Как объяснялось выше, это может быть обобщено для других моделей MonadPlus с различными уровнями интереса.
Signature 
Учитывая MonadPlus M, подпись является \(\mathrm{prefix}: M(T) \times T \to M(T) \.
Parameters

  
    xs Монадическая структура.
    pref Значение (префикс) для вставки перед каждым элементом монадической структуры.
  
  

Example 
// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/prefix.hpp>
#include <boost/hana/tuple.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
    BOOST_HANA_RUNTIME_CHECK(
        hana::prefix(hana::make_tuple("dog"s, "car"s, "house"s), "my"s)
            ==
        hana::make_tuple("my", "dog", "my", "car", "my", "house")
    );
}
 





      
        
          constexpr auto boost::hana::prepend
        
      

#include <boost/hana/fwd/prepend.hpp>
Initial value:= [](auto&& xs, auto&& x) {
        return tag-dispatched;
    }

Предохраняйте элемент к монадической структуре. Учитывая монадичную структуру xs и элемент x, prepend возвращает новую монадичную структуру, которая является результатом подъема x в монадическую структуру, а затем объединения ее (налево) с xs. Другими словами.
prepend(xs, x) == concat(lift<Xs>(x), xs)
Для последовательностей это имеет интуитивное поведение, просто предваряя элемент к началу последовательности, отсюда и название.

Rationale for not calling this push_front
В то время как push_front является де-факто именем, используемым в стандартной библиотеке, он также настоятельно предлагает мутацию основной последовательности, что здесь не так. Автор также считает, что push_front слишком сильно предлагает единственную интерпретацию размещения элемента в передней части последовательности, в то время как prepend немного больше нюансов и носит его название лучше для, например, hana::Option.

Signature 
Учитывая MonadPlus M, подпись является \( \mathtt{prepend} : M(T) \times T \to M(T)\).
Parameters

  
    xs Монадическая структура, которая будет объединена справа от элемента.
    x Элемент для объединения слева от монадической структуры.
  
  

Example 
// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/equal.hpp>
#include <boost/hana/prepend.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::prepend(hana::make_tuple(), 1) == hana::make_tuple(1), "");
static_assert(hana::prepend(hana::make_tuple('2', 3.3), 1) == hana::make_tuple(1, '2', 3.3), "");
int main() { }
 





      
        
          constexpr auto boost::hana::remove
        
      

#include <boost/hana/fwd/remove.hpp>
Initial value:= [](auto&& xs, auto&& value) {
        return tag-dispatched;
    }
boost::hana::value
constexpr auto value
Return the compile-time value associated to a constant.This function returns the value associated to ...
Definition: value.hpp:54

Удалить все элементы монадической структуры, которые равны некоторому значению. Учитывая монадичную структуру xs и значение , remove возвращает новую монадичную структуру, равную xs без всех его элементов, равных данным значение. remove эквивалентно remove_if с equal.to( value) predicate, i.e.
remove(xs, value) == remove_if(xs, equal.to(value))
Signature 
Учитывая MonadPlus M и значение типа T, подпись \( \mathrm{remove} : M(T) \times T \to M(T) \
Parameters

  
    xs Монадическая структура для удаления некоторых элементов.
    value Значение, которое сравнивается с каждым элементом x структуры. Элементы структуры, равные этому значению, удаляются из структуры. Это требует, чтобы каждый элемент был сопоставим с значением . Кроме того, в текущей версии библиотеки сравнение  value с любым элементом структуры должно привести к логическому времени компиляции.
  
  

Example 
// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/remove.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
namespace hana = boost::hana;
BOOST_HANA_CONSTANT_CHECK(hana::remove(hana::tuple_t<int, char, float>, hana::type_c<char>) == hana::tuple_t<int, float>);
BOOST_HANA_CONSTANT_CHECK(hana::remove(hana::just(hana::type_c<int>), hana::type_c<char>) == hana::just(hana::type_c<int>));
BOOST_HANA_CONSTANT_CHECK(hana::remove(hana::just(hana::type_c<int>), hana::type_c<int>) == hana::nothing);
int main() { }
 





      
        
          constexpr auto boost::hana::remove_if
        
      

#include <boost/hana/fwd/remove_if.hpp>
Initial value:= [](auto&& xs, auto&& predicate) {
        return tag-dispatched;
    }

Удалить все элементы монадической структуры, которые удовлетворяют некоторым предикатам. При наличии монадической структуры xs и неарочного предика remove_if возвращает новую монадичную структуру, равную xs, без всех ее элементов, удовлетворяющих предикату. Это эквивалентно фильтру с отложенным предикатом, т.е.
remove_if(xs, predicate) == filter(xs, negated predicated)
Signature 
Учитывая MonadPlus M и предикат типа \( T \to Bool \) для некоторого компиляционного времени Logical Bool, подпись \( \mathrm{remove\_if} : M(T) \time (T \to Bool) \to M(T) \
Parameters

  
    xs Монадическая структура для удаления некоторых элементов.
    predicate Неарочный предикат, называемый predicate(x), где x является элементом структуры, и возвращается ли x должно быть удалено из структуры. В текущей версии библиотеки predicate должен вернуть логическое время компиляции.
  
  

Example 
// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/ext/std/integral_constant.hpp>
#include <boost/hana/functional/compose.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/remove_if.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <type_traits>
namespace hana = boost::hana;
// First get the type of the object, and then call the trait on it.
constexpr auto is_integral = hana::compose(hana::trait<std::is_integral>, hana::typeid_);
static_assert(hana::remove_if(hana::make_tuple(1, 2.0, 3, 4.0), is_integral) == hana::make_tuple(2.0, 4.0), "");
static_assert(hana::remove_if(hana::just(3.0), is_integral) == hana::just(3.0), "");
BOOST_HANA_CONSTANT_CHECK(hana::remove_if(hana::just(3), is_integral) == hana::nothing);
int main() { }
 






template<typename M > 
      
        
          constexpr auto boost::hana::replicate
        
      

#include <boost/hana/fwd/replicate.hpp>
Initial value:= [](auto&& x, auto const& n) {
        return tag-dispatched;
    }

Создайте монадичную структуру, сочетая поднятое значение с собой n раз. Учитывая значение x, неотрицательное IntegralConstant n и тег монадической структуры M, replicate создает новую монадичную структуру, которая является результатом объединения x с собой n раз внутри монадической структуры. Другими словами, replicate просто lifts x в монадическую структуру, а затем сочетает это с собой n раз:
replicate<M>(x, n) == cycle(lift<M>(x), n)
Если n равен нулю, то возвращается идентификация операции concat. В случае последовательностей это соответствует созданию новой последовательности, удерживающей n копии x.
Signature 
Учитывая IntegralConstant C и MonadPlus M, подпись \(\mathtt{replicate}_M: T \times C \to M(T) \).
Template Parameters

  
    M Тег возвращенной монадической структуры. Это должна быть модель концепции MonadPlus.
  
  

Parameters

  
    x Значение, чтобы поднять в монадичную структуру, а затем объединить с собой.
    n Неотрицательный IntegralConstant представляет количество раз, чтобы объединить lift(x) с собой. Если n == 0, replicate возвращает empty().
  
  

Example 
// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/equal.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/optional.hpp>
#include <boost/hana/replicate.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(hana::replicate<hana::tuple_tag>('x', hana::size_c<2>) == hana::make_tuple('x', 'x'), "");
// Of course, there can't be more than one element in an `optional`.
static_assert(hana::replicate<hana::optional_tag>('x', hana::size_c<2>) == hana::just('x'), "");
int main() { }
 





      
        
          constexpr auto boost::hana::suffix
        
      

#include <boost/hana/fwd/suffix.hpp>
Initial value:= [](auto&& xs, auto&& sfx) {
        return tag-dispatched;
    }

Вставляет значение после каждого элемента монадической структуры. Учитывая монадичную структуру xs и значение z (называемый суффиксом), suffix возвращает новую монадичную структуру, такую, что.
suffix(xs, z) == flatten(transform(xs, [](auto x) {
    return concat(lift<M>(x), lift<M>(z));
}))
Для последовательностей это просто соответствует вставке суффикса после каждого элемента последовательности. Например, при наличии последовательности [x1, ..., xn], suffix вернется
[x1, z, x2, z, ..., xn, z]
Как объяснялось выше, это может быть обобщено для других моделей MonadPlus с различными уровнями интереса.
Signature 
Учитывая MonadPlus M, подпись является \( \mathtt{suffix} : M(T) \times T \to M(T)\).
Parameters

  
    xs Монадическая структура.
    sfx Значение (суффикс) для вставки после каждого элемента монадической структуры.
  
  

Example 
// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/equal.hpp>
#include <boost/hana/suffix.hpp>
#include <boost/hana/tuple.hpp>
namespace hana = boost::hana;
static_assert(
    hana::suffix(hana::make_tuple(1, 2, 3, 4), 0) == hana::make_tuple(1, 0, 2, 0, 3, 0, 4, 0)
, "");
int main() { }
 









  
  

Статья Boost.Hana: MonadPlus раздела   может быть полезна для разработчиков на c++ и boost.



Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.


:: Главная ::  :: 
реклама

Время компиляции файла: 2024-08-30 11:47:00
2025-05-20 00:40:49/0.010111093521118/1

Boost.Hana: MonadPlus

Boost , ,

Minimal complete definition

Laws

Refined concepts

Concrete models

Variables

Signature

Variable Documentation

Rationale for not calling this `push_back`

Signature

Example

Signature

Example

Signature

Example

Сигнатура

Example

Signature

Example

Signature

Example

Rationale for not calling this `push_front`

Signature

Example

Signature

Example

Signature

Example

Signature

Example

Signature

Example

Boost.Hana: MonadPlus

Boost , ,

Minimal complete definition

Laws

Refined concepts

Concrete models

Variables

Signature

Variable Documentation

Rationale for not calling this push_back

Signature

Example

Signature

Example

Signature

Example

Сигнатура

Example

Signature

Example

Signature

Example

Rationale for not calling this push_front

Signature

Example

Signature

Example

Signature

Example

Signature

Example

Signature

Example

Rationale for not calling this `push_back`

Rationale for not calling this `push_front`