2004-11-28 03:35:12 +00:00
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
< html xmlns = "http://www.w3.org/1999/xhtml" xml:lang = "en" lang = "en" >
2007-11-03 03:25:13 +00:00
<!-- Copyright Aleksey Gurtovoy 2006. Distributed under the Boost -->
<!-- Software License, Version 1.0. (See accompanying -->
<!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
2004-11-28 03:35:12 +00:00
< head >
< meta http-equiv = "Content-Type" content = "text/html; charset=utf-8" />
< meta name = "generator" content = "Docutils 0.3.6: http://docutils.sourceforge.net/" />
< title > THE BOOST MPL LIBRARY: Higher-Order Metafunctions</ title >
< link rel = "stylesheet" href = "../style.css" type = "text/css" />
</ head >
< body class = "docframe" >
< table class = "header" >< tr class = "header" >< td class = "header-group navigation-bar" >< span class = "navigation-group" >< a href = "./implementing-division.html" class = "navigation-link" > Prev</ a > < a href = "./handling-placeholders.html" class = "navigation-link" > Next</ a ></ span >< span class = "navigation-group-separator" > | </ span >< span class = "navigation-group" >< a href = "./dimensional-analysis.html" class = "navigation-link" > Back</ a > < a href = "./handling-placeholders.html" class = "navigation-link" > Along</ a ></ span >< span class = "navigation-group-separator" > | </ span >< span class = "navigation-group" >< a href = "./tutorial-metafunctions.html" class = "navigation-link" > Up</ a > < a href = "../index.html" class = "navigation-link" > Home</ a ></ span >< span class = "navigation-group-separator" > | </ span >< span class = "navigation-group" >< a href = "./tutorial_toc.html" class = "navigation-link" > Full TOC</ a ></ span ></ td >
< td class = "header-group page-location" >< a href = "../index.html" class = "navigation-link" > Front Page</ a > / < a href = "./tutorial-metafunctions.html" class = "navigation-link" > Tutorial: Metafunctions and Higher-Order Metaprogramming</ a > / < a href = "./higher-order.html" class = "navigation-link" > Higher-Order Metafunctions</ a ></ td >
</ tr ></ table >< div class = "header-separator" ></ div >
< div class = "section" id = "higher-order" >
< h1 >< a class = "toc-backref" href = "./tutorial-metafunctions.html#id47" name = "higher-order" > Higher-Order Metafunctions</ a ></ h1 >
< p > In the previous section we used two different forms —
metafunction classes and placeholder expressions —
to pass and return metafunctions just like any other metadata.
Bundling metafunctions into " first class metadata" allows
< tt class = "literal" >< span class = "pre" > transform</ span ></ tt > to perform an infinite variety of different
operations: in our case, multiplication and division of dimensions.
Though the idea of using functions to manipulate other functions
may seem simple, its great power and flexibility < a class = "citation-reference" href = "#hudak89" id = "id9" name = "id9" > [Hudak89]</ a > has
earned it a fancy title: < strong > higher-order functional programming</ strong > .
A function that operates on another function is known as a
< strong > higher-order function</ strong > . It follows that < tt class = "literal" >< span class = "pre" > transform</ span ></ tt > is a
higher-order
metafunction: a metafunction that operates on another metafunction.</ p >
< table class = "citation" frame = "void" id = "hudak89" rules = "none" >
< colgroup >< col class = "label" />< col /></ colgroup >
< tbody valign = "top" >
< tr >< td class = "label" >< a class = "fn-backref" href = "#id9" name = "hudak89" > [Hudak89]</ a ></ td >< td > Paul Hudak. " Conception, Evolution, and Application of
Functional Programming Languages," ACM Computing Surveys 21,
no. 3 Pages: 359 - 411. New York: ACM Press. 1989.
ISSN:0360-0300. http://doi.acm.org/10.1145/72551.72554.</ td ></ tr >
</ tbody >
</ table >
< p > Now that we've seen the power of higher-order metafunctions at
work, it would be good to be able to create new ones. In order to
explore the basic mechanisms, let's try a simple example. Our task
is to write a metafunction called < tt class = "literal" >< span class = "pre" > twice</ span ></ tt > , which — given a unary
metafunction < em > f</ em > and arbitrary metadata < em > x</ em > — computes:</ p >
< blockquote >
< em > twice</ em > (< em > f</ em > , < em > x</ em > ) := < em > f</ em > (< em > f</ em > (< em > x</ em > ))</ blockquote >
< p > This might seem like a trivial example, and in fact it is. You
won't find much use for < tt class = "literal" >< span class = "pre" > twice</ span ></ tt > in real code. We hope you'll
bear with us anyway: Because it doesn't do much more than accept
and invoke a metafunction, < tt class = "literal" >< span class = "pre" > twice</ span ></ tt > captures all the essential
elements of " higher-orderness" without any distracting details.</ p >
< p > If < em > f</ em > is a metafunction class, the definition of < tt class = "literal" >< span class = "pre" > twice</ span ></ tt > is
straightforward:</ p >
< pre class = "literal-block" >
template < class F, class X>
struct twice
{
typedef typename F::template apply< X> ::type once; // f(x)
typedef typename F::template apply< once> ::type type; // f(f(x))
};
</ pre >
<!-- @ prefix.append(
'''#include <boost/type_traits/add_pointer.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>''')
twice_test = '''
#include <boost/mpl/assert.hpp>
struct add_pointer_f
{
template <class T> struct apply : boost::add_pointer<T>
{};
};
BOOST_MPL_ASSERT((boost::is_same<twice<add_pointer_f,int>::type,int**>));
'''
example.append(twice_test)
compile() -->
<!-- @litre_translator.line_offset -= 7 -->
< p > Or, applying metafunction forwarding:</ p >
< pre class = "literal-block" >
template < class F, class X>
struct twice
: F::template apply<
typename F::template apply< X> ::type
>
{};
</ pre >
<!-- @ example.append(twice_test)
compile() -->
< div class = "admonition-c-language-note admonition" >
< p class = "admonition-title first" > C++ Language Note</ p >
< p > The C++ standard requires the < tt class = "literal" >< span class = "pre" > template</ span ></ tt > keyword when we use a
< strong > dependent name</ strong > that refers to a member template.
< tt class = "literal" >< span class = "pre" > F::apply</ span ></ tt > may or may not name a template, < em > depending</ em > on the
particular < tt class = "literal" >< span class = "pre" > F</ span ></ tt > that is passed. See < a class = "reference" href = "./resources.html" > the book's</ a > Appendix B for more
information about < tt class = "literal" >< span class = "pre" > template</ span ></ tt > .</ p >
</ div >
< p > Given the need to sprinkle our code with the < tt class = "literal" >< span class = "pre" > template</ span ></ tt > keyword,
it would be nice to reduce the syntactic burden of invoking
metafunction classes. As usual, the solution is to factor the
pattern into a metafunction:</ p >
< pre class = "literal-block" >
template < class UnaryMetaFunctionClass, class Arg>
struct apply1
: UnaryMetaFunctionClass::template apply< Arg>
{};
</ pre >
< p > Now < tt class = "literal" >< span class = "pre" > twice</ span ></ tt > is just:</ p >
< pre class = "literal-block" >
template < class F, class X>
struct twice
: apply1< F, typename apply1< F,X> ::type>
{};
</ pre >
< p > To see < tt class = "literal" >< span class = "pre" > twice</ span ></ tt > at work, we can apply it to a little metafunction
class built around the < tt class = "literal" >< span class = "pre" > add_pointer</ span ></ tt > metafunction:</ p >
< pre class = "literal-block" >
struct add_pointer_f
{
template < class T>
struct apply : boost::add_pointer< T> {};
};
</ pre >
<!-- @litre_translator.line_offset -= 7 -->
< p > Now we can use < tt class = "literal" >< span class = "pre" > twice</ span ></ tt > with < tt class = "literal" >< span class = "pre" > add_pointer_f</ span ></ tt > to build
pointers-to-pointers:</ p >
< pre class = "literal-block" >
BOOST_STATIC_ASSERT((
boost::is_same<
twice< add_pointer_f, int> ::type
, int**
> ::value
));
</ pre >
<!-- @ apply1 = stack[-4]
add_pointer_f = stack[-2]
compile('all', pop = 0) -->
</ div >
< div class = "footer-separator" ></ div >
< table class = "footer" >< tr class = "footer" >< td class = "header-group navigation-bar" >< span class = "navigation-group" >< a href = "./implementing-division.html" class = "navigation-link" > Prev</ a > < a href = "./handling-placeholders.html" class = "navigation-link" > Next</ a ></ span >< span class = "navigation-group-separator" > | </ span >< span class = "navigation-group" >< a href = "./dimensional-analysis.html" class = "navigation-link" > Back</ a > < a href = "./handling-placeholders.html" class = "navigation-link" > Along</ a ></ span >< span class = "navigation-group-separator" > | </ span >< span class = "navigation-group" >< a href = "./tutorial-metafunctions.html" class = "navigation-link" > Up</ a > < a href = "../index.html" class = "navigation-link" > Home</ a ></ span >< span class = "navigation-group-separator" > | </ span >< span class = "navigation-group" >< a href = "./tutorial_toc.html" class = "navigation-link" > Full TOC</ a ></ span ></ td >
</ tr ></ table ></ body >
</ html >
