tuple-closure.hpp

Go to the documentation of this file.

/*
  TUPLE-CLOSURE.hpp  -  metaprogramming tools for tuple-likes with partial closure
 
   Copyright (C)
     2025,            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_TUPLE_CLOSURE_H
#define LIB_META_TUPLE_CLOSURE_H
 
#include "lib/meta/function-closure.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/util.hpp"
 
#include <utility>
#include <tuple>
#include <array>
 
 
 
namespace lib {
namespace meta{
  
  using std::move;
  using util::unConst;
  
  template<class PAR>
  struct TupleClosureBuilder
    {
      static_assert (!sizeof(PAR),
                    "attempt to partially close something not tuple-like");
    };
  
  template<template<typename...> class TUP, typename...PARS>
  struct TupleClosureBuilder<TUP<PARS...>>
    {
      static_assert (sizeof...(PARS)
                    ,"attempt to partially close empty record");
      
      using Tuple = TUP<PARS...>;
      using TupleBuilderSig = Tuple(PARS...);
      
      static Tuple
      buildRecord (PARS ...params)
        {
          return {std::move(params)...};
        }
      
      template<typename...VALS>
      static auto
      closeFront (VALS&& ...vs)
        {
          using ClosedTypes = Types<std::decay_t<VALS>...>;
          auto  boundArgs = std::make_tuple (std::forward<VALS> (vs)...);                      // Note: must be passed by-val here
          return wrapBuilder (func::PApply<TupleBuilderSig, ClosedTypes>::bindFront (buildRecord, move(boundArgs)));
        }
      
      template<typename...VALS>
      static auto
      closeBack (VALS&& ...vs)
        {
          using ClosedTypes = Types<std::decay_t<VALS>...>;
          auto  boundArgs = std::make_tuple (std::forward<VALS> (vs)...);
          return wrapBuilder (func::PApply<TupleBuilderSig, ClosedTypes>::bindBack  (buildRecord, move(boundArgs)));
        }
      
      template<size_t idx, typename VAL>
      static auto
      close (VAL&& val)
        {
          using BoundVal = std::decay_t<VAL>;
          return wrapBuilder (func::BindToArgument<TupleBuilderSig,BoundVal,idx>::reduced (buildRecord, std::forward<VAL>(val)));
        }
      
      template<size_t idx, typename VAL>
      static auto
      closett (VAL&& val)
        {
          using BoundVal = std::decay_t<VAL>;
          return wrapBuilder (func::BindToArgument<TupleBuilderSig,BoundVal,idx>::refused (buildRecord, std::forward<VAL>(val)));
        }
      
    private:
      template<class CLO>
      static auto
      wrapBuilder (CLO closureFun)   
        {
          using RemainingArgs = _Fun<CLO>::Args;
          using RemainingParams = lib::meta::RebindVariadic<TUP, RemainingArgs>::Type;
 
                struct Wrap
                  {
                    auto
                    operator() (RemainingParams remPar)  const
                      {
                        return lib::meta::apply (unConst(this)->partialClosure_, remPar);
                      };
 
                    CLO partialClosure_;
                  };                   //  Note: need a single operator() which works also for const
                                      //         can not do this with a λ
          return Wrap{move(closureFun)};
        }
    };
  
  
  
  /* ===== adapt array for tuple-like signature ===== */
  
  template<typename...TTT>
  struct ArrayAdapt
    {
      static_assert(sizeof...(TTT)
                   ,"empty list ... attempting total (not partial) closure?");
    };
  
  
  template<typename...TTT>
  struct AllSame
    : std::true_type // trivially true for empty conjunction and single element
    { };
  
  template<typename T1, typename T2, typename...TS>
  struct AllSame<T1,T2,TS...>
    : __and_<is_same<T1,T2>
            ,AllSame<T2,TS...>
            >
    { };
  
  
  namespace {
    template<typename T, size_t N>
    struct _Adapt
      {
        using NFold = Repeat<T,N>::Seq;
        using Array = RebindVariadic<ArrayAdapt, NFold>::Type;
        static_assert(N,"attempt to partially close empty array");
      };
    
    template<typename T, size_t N>
    using _AdaptArray_t = _Adapt<T,N>::Array;
  }
  
  template<typename T, typename...TT>
  struct ArrayAdapt<T,TT...>
    : std::array<T, 1+sizeof...(TT)>
    {
      static_assert (AllSame<T,TT...>()
                    ,"Array can only hold elements of uniform type");
      using Array = std::array<T, 1+sizeof...(TT)>;
      
      
      ArrayAdapt (Array const& o) : Array{o}       { }
      ArrayAdapt (Array     && r) : Array{move(r)} { }
      
      template<typename...XS>
      ArrayAdapt (XS&& ...inits)
        : Array{std::forward<XS> (inits)...}
        { }
    };
  
  template<typename...TTT>
  ArrayAdapt(TTT...) -> ArrayAdapt<std::decay_t<TTT>...>;
  
  
  
  template<typename T, size_t N>
  struct TupleClosureBuilder<std::array<T,N>>
    : TupleClosureBuilder<_AdaptArray_t<T,N>>
    {
    };
  
  
}} // namespace lib::meta
 
 
namespace std { // Specialisation to support C++ »Tuple Protocol« and structured bindings.
  
  template<typename...TTT>
  struct tuple_size<lib::meta::ArrayAdapt<TTT...> >
    : integral_constant<size_t, sizeof...(TTT)>
    { };
  
  template<size_t I, typename...TTT>
  struct tuple_element<I, lib::meta::ArrayAdapt<TTT...> >
    : tuple_element<I, typename lib::meta::ArrayAdapt<TTT...>::Array>
    { };
  
  // Note: the std::get<i> function will pick the baseclass anyway
}
#endif /*LIB_META_TUPLE_CLOSURE_H*/