function-closure.hpp

Go to the documentation of this file.

/*
  FUNCTION-CLOSURE.hpp  -  metaprogramming tools for closing a function over given arguments
 
   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_META_FUNCTION_CLOSURE_H
#define LIB_META_FUNCTION_CLOSURE_H
 
#include "lib/meta/function.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/util.hpp"
 
#include <functional>
#include <utility>
#include <tuple>
 
 
 
namespace lib {
namespace meta{
namespace func{
  
  using std::tuple;
  using std::function;
  using std::forward;
  using std::move;
  
  
  
  
  namespace { // helpers for binding and applying a function to an argument tuple
    
    using std::_Placeholder;
    
    
    template<typename TYPES, size_t i=1>
    struct PlaceholderTuple
      : PlaceholderTuple<typename TYPES::List>
      { };
    
    template<typename X, typename TAIL, size_t i>
    struct PlaceholderTuple<Node<X,TAIL>, i>
      {
        using TailPlaceholders = PlaceholderTuple<TAIL,i+1>::List;
        
        using List = Node<_Placeholder<i>, TailPlaceholders>;
      };
    
    template<size_t i>
    struct PlaceholderTuple<Nil, i>
      {
        using List = Nil;
      };
    
    
    
    using std::tuple_element;
    using std::tuple_size;
    using std::get;
    
    
    template<typename SRC, typename TAR, size_t start>
    struct PartiallyInitTuple
      {
        template<size_t i>
        using DestType = std::tuple_element_t<i, TAR>;
        
        
        static constexpr bool
        useArg (size_t idx)
          {
            return (start <= idx)
               and (idx < start + std::tuple_size<SRC>());
          }
        
        
        
        template<size_t idx,   bool doPick = PartiallyInitTuple::useArg(idx)>
        struct IndexMapper
          {
            SRC&& initArgs;
            
            operator DestType<idx>()
              {                             // std::get passes-through reference kind
                return std::get<idx-start> (forward<SRC>(initArgs));
              }
          };
        
        template<size_t idx>
        struct IndexMapper<idx, false>
          {
            SRC&& initArgs;
            
            operator DestType<idx>()
              {
                return DestType<idx>();
              }
          };
      };
    
    
    template<typename...ARGS>
    struct AdaptInvokable
      {
        template<class FUN>
        static auto
        buildWrapper (FUN&& fun)
          {
                  struct Wrap
                    {
                      FUN fun_;
                      
                      auto
                      operator() (ARGS... args)
                        {
                          return fun_(forward<ARGS>(args)...);
                        }
                    };
            
            return Wrap{forward<FUN>(fun)};
          }
      };
 
  } // (END) impl-namespace
  
  
  
  
  
  /* ======= core operations: closures and partial application ========= */
  
  template<class FUN, class TUP>        requires(tuple_like<remove_reference_t<TUP>>)
  auto
  bindArgTuple (FUN&& fun, TUP&& tuple)
  {
    return lib::meta::apply ([functor = forward<FUN>(fun)]
                             (auto&&... args)
                                  {
                                    return std::bind (move(functor)
                                                     ,forward<decltype(args)> (args) ...);
                                  }
                            ,std::forward<TUP> (tuple));
  }
  
  template<class TYPES, class FUN>
  auto
  buildInvokableWrapper (FUN&& fun)
    {
      static_assert (is_Typelist<TYPES>::value);
      using ArgTypes = TYPES::Seq;
      using Builder  = lib::meta::RebindVariadic<AdaptInvokable, ArgTypes>::Type;
      
      return Builder::buildWrapper (forward<FUN> (fun));
    }
 
  
  
  template<typename SIG, typename VAL>
  class PApply
    {
      using Args     = _Fun<SIG>::Args;
      using Ret      = _Fun<SIG>::Ret;
      using ArgsList = Args::List;
      using ValList  = VAL::List;
      using ValTypes = Types<ValList>::Seq;  // reconstruct a type-seq from a type-list
      
      enum { ARG_CNT = count<ArgsList>()
           , VAL_CNT = count<ValList>()
           , ROFFSET = (VAL_CNT < ARG_CNT)? ARG_CNT-VAL_CNT : 0
           };
      
      
      // create list of the *remaining* arguments, after applying the ValList
      using LeftReduced = Splice<ArgsList, ValList>::Back;
      using RightReduced = Splice<ArgsList, ValList, ROFFSET>::Front;
      
      using ArgsL = Types<LeftReduced>::Seq;
      using ArgsR = Types<RightReduced>::Seq;
      
      
      // build a list, where each of the *remaining* arguments is replaced by a placeholder marker
      using TrailingPlaceholders = func::PlaceholderTuple<LeftReduced>::List;
      using LeadingPlaceholders  = func::PlaceholderTuple<RightReduced>::List;
      
      // ... and splice these placeholders on top of the original argument type list,
      // thus retaining the types to be closed, but setting a placeholder for each remaining argument
      using LeftReplaced  = Splice<ArgsList, TrailingPlaceholders, VAL_CNT>::List;
      using RightReplaced = Splice<ArgsList, LeadingPlaceholders,  0      >::List;
      
      using LeftReplacedTypes = Types<LeftReplaced>::Seq;
      using RightReplacedTypes = Types<RightReplaced>::Seq;
      
      // create a "builder" helper, which accepts exactly the value tuple elements
      // and puts them at the right location, while default-constructing the remaining
      // (=placeholder)-arguments. Using this builder helper, we can finally set up
      // the argument tuples (Left/RightReplacedArgs) used for the std::bind call
      template<class SRC, class TAR, size_t i>
      using IdxSelectorL = PartiallyInitTuple<SRC, TAR, 0>::template IndexMapper<i>;
      
      template<class SRC, class TAR, size_t i>
      using IdxSelectorR = PartiallyInitTuple<SRC, TAR, ROFFSET>::template IndexMapper<i>;
      
      using BuildL = TupleConstructor<LeftReplacedTypes, IdxSelectorL>;
      using BuildR = TupleConstructor<RightReplacedTypes, IdxSelectorR>;
      
      
      using LeftReplacedArgs  = Tuple<LeftReplacedTypes>;
      
      using RightReplacedArgs = Tuple<RightReplacedTypes>;
      
      
    public:
      using LeftReducedFunc  = function<typename BuildFunType<Ret,ArgsL>::Sig>;
      using RightReducedFunc = function<typename BuildFunType<Ret,ArgsR>::Sig>;
      
      
      static LeftReducedFunc
      bindFront (SIG const& f, Tuple<ValTypes> arg)
        {
          LeftReplacedArgs params {BuildL(std::move(arg))};
          return bindArgTuple (f, params);
        }
      
      static RightReducedFunc
      bindBack (SIG const& f, Tuple<ValTypes> arg)
        {
          RightReplacedArgs params {BuildR(std::move(arg))};
          return bindArgTuple (f, params);
        }
    };
  
  
  
  template<typename SIG, typename X, uint pos>
  class BindToArgument
    {
      using Args     = _Fun<SIG>::Args;
      using Ret      = _Fun<SIG>::Ret;
      using ArgsList =     Args::List;
      using ValList  = Types<X>::List;
      
      enum { ARG_CNT = count<ArgsList>() };
 
      using RemainingFront     = Splice<ArgsList, ValList, pos>::Front;
      using RemainingBack      = Splice<ArgsList, ValList, pos>::Back;
      using PlaceholdersBefore = func::PlaceholderTuple<RemainingFront>::List;
      using PlaceholdersBehind = func::PlaceholderTuple<RemainingBack,pos+1>::List;
      
      using PreparedArgsRaw    = typename Append<typename Append<PlaceholdersBefore    // arguments before the splice: passed-through
                                                                ,ValList >::List       // splice in the value tuple
                                                ,PlaceholdersBehind                    // arguments behind the splice: passed-through
                                                >::List;
      using PreparedArgs     = Prefix<PreparedArgsRaw, ARG_CNT>;
      using ReducedArgs      = Append<RemainingFront, RemainingBack>::List;
      
      using PreparedArgTypes = Types<PreparedArgs>::Seq;
      using RemainingArgs    = Types<ReducedArgs>::Seq;
      
      
      template<class SRC, class TAR, size_t i>
      using IdxSelector = PartiallyInitTuple<SRC, TAR, pos>::template IndexMapper<i>;
      
      using BuildPreparedArgs = TupleConstructor<PreparedArgTypes, IdxSelector>;
      
      
      
    public:
      template<class FUN, class VAL>
      static auto
      reduced (FUN&& f, VAL&& val)
        {
          Tuple<PreparedArgTypes> bindingTuple {
            BuildPreparedArgs{
              std::forward_as_tuple (
                  forward<VAL>(val))}};
          
          return buildInvokableWrapper<RemainingArgs>(
                  bindArgTuple (forward<FUN>(f)
                              , move(bindingTuple)));
        }
    };
  
  
  
  namespace { // ...helpers for specifying types in function declarations....
    
    using std::get;
    using util::unConst;
    
    
    template<typename FUN1, typename FUN2>
    struct _Chain
      {
        using Ret  = _Fun<FUN2>::Ret;
        using Args = _Fun<FUN1>::Args;
        
        using FunType = BuildFunType<Ret,Args>::Fun;
        static auto adaptedFunType() { return FunType{}; }
        
        
        template<typename F1, typename F2
                ,typename RET, typename... ARGS>
        static auto
        composedFunctions (F1&& f1, F2&& f2, _Fun<RET(ARGS...)>)
          {
            tuple<F1,F2> binding{forward<F1> (f1)
                                ,forward<F2> (f2)
                                };
            return [binding = move(binding)]
                   (ARGS ...args) -> RET
                      {
                        auto& functor1 = get<0>(binding);
                        auto& functor2 = get<1>(binding);
                        //
                        return functor2 (functor1 (forward<ARGS> (args)...));
                      };
          }
      };
    
  } // (End) argument type shortcuts
  
  
  
  
  /*  ========== function-style interface =============  */
  
  template<typename FUN, typename TERM>
  inline auto
  bindFirst (FUN&& f, TERM&& arg)
  {
    return BindToArgument<FUN,TERM, 0>::reduced (std::forward<FUN> (f)
                                                ,std::forward<TERM> (arg));
  }
  
  template<typename FUN, typename TERM>
  inline auto
  bindLast (FUN&& f, TERM&& arg)
  {
    enum { LAST_POS = -1 + count<typename _Fun<FUN>::Args>() };
    return BindToArgument<FUN,TERM,LAST_POS>::reduced (std::forward<FUN> (f)
                                                      ,std::forward<TERM> (arg));
  }
  
  
  template<typename FUN1, typename FUN2>
  inline auto
  chained (FUN1&& f1, FUN2&& f2)
  {
    static_assert (_Fun<FUN1>(), "expect something function-like for function-1");
    static_assert (_Fun<FUN2>(), "expect something function-like for function-2");
    using Chain = _Chain<FUN1,FUN2>;
    return Chain::composedFunctions (forward<FUN1> (f1)
                                    ,forward<FUN2> (f2)
                                    ,Chain::adaptedFunType());
  }
  
  
  
}}} // namespace lib::meta::func
#endif