make_lazy.hpp

Go to the documentation of this file.

// Copyright (c) 2024--present, The Simons Foundation
// This file is part of TRIQS/nda and is licensed under the Apache License, Version 2.0.
// SPDX-License-Identifier: Apache-2.0
// See LICENSE in the root of this distribution for details.

 
#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