make_lazy.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2023 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Olivier Parcollet, Nils Wentzell
 
#pragma once
 
#include "./expression.hpp"
#include "./utils.hpp"
 
#include <utility>
 
namespace nda::clef {
 
  template <typename T>
  auto make_expr(T &&t) {
    return expr<tags::terminal, expr_storage_t<T>>{tags::terminal(), std::forward<T>(t)};
  }
 
  template <typename T>
  auto make_expr_from_clone(T &&t) {
    return expr<tags::terminal, std::decay_t<T>>{tags::terminal(), std::forward<T>(t)};
  }
 
  template <typename F, typename... Args>
  auto make_expr_call(F &&f, Args &&...args)
    requires(is_any_lazy<Args...>)
  {
    return expr<tags::function, expr_storage_t<F>, expr_storage_t<Args>...>{tags::function{}, std::forward<F>(f), std::forward<Args>(args)...};
  }
 
  template <typename T, typename... Args>
  auto make_expr_subscript(T &&t, Args &&...args)
    requires(is_any_lazy<Args...>)
  {
    return expr<tags::subscript, expr_storage_t<T>, expr_storage_t<Args>...>{tags::subscript{}, std::forward<T>(t), std::forward<Args>(args)...};
  }
 
#define CLEF_MAKE_FNT_LAZY(name)                                                                                                                     \
  template <typename... A>                                                                                                                           \
  auto name(A &&...__a)                                                                                                                              \
    requires(nda::clef::is_any_lazy<A...>)                                                                                                           \
  {                                                                                                                                                  \
    return make_expr_call([](auto &&...__b) -> decltype(auto) { return name(std::forward<decltype(__b)>(__b)...); }, std::forward<A>(__a)...);       \
  }
 
#define CLEF_IMPLEMENT_LAZY_METHOD(TY, name)                                                                                                         \
  template <typename... A>                                                                                                                           \
  auto name(A &&...__a)                                                                                                                              \
    requires(nda::clef::is_any_lazy<A...>)                                                                                                           \
  {                                                                                                                                                  \
    return make_expr_call(                                                                                                                           \
       [](auto &&__obj, auto &&...__b) -> decltype(auto) { return std::forward<decltype(__obj)>(__obj).name(std::forward<decltype(__b)>(__b)...); }, \
       *this, std::forward<A>(__a)...);                                                                                                              \
  }
 
#define CLEF_IMPLEMENT_LAZY_CALL(...)                                                                                                                \
  template <typename... Args>                                                                                                                        \
  auto operator()(Args &&...args) const &                                                                                                            \
    requires(nda::clef::is_any_lazy<Args...>)                                                                                                        \
  {                                                                                                                                                  \
    return make_expr_call(*this, std::forward<Args>(args)...);                                                                                       \
  }                                                                                                                                                  \
                                                                                                                                                     \
  template <typename... Args>                                                                                                                        \
  auto operator()(Args &&...args) &                                                                                                                  \
    requires(nda::clef::is_any_lazy<Args...>)                                                                                                        \
  {                                                                                                                                                  \
    return make_expr_call(*this, std::forward<Args>(args)...);                                                                                       \
  }                                                                                                                                                  \
                                                                                                                                                     \
  template <typename... Args>                                                                                                                        \
  auto operator()(Args &&...args) &&                                                                                                                 \
    requires(nda::clef::is_any_lazy<Args...>)                                                                                                        \
  {                                                                                                                                                  \
    return make_expr_call(std::move(*this), std::forward<Args>(args)...);                                                                            \
  }
 
} // namespace nda::clef