From a759ea53ae7bd9f708b5fd3cd0bc303236ace870 Mon Sep 17 00:00:00 2001
From: Fahri Ali Rahman <ali.rahman.fahri@gmail.com>
Date: Sat, 29 Jun 2024 18:03:56 +0700
Subject: [PATCH] new aliasing logic using compile-time hashing

---
 include/nmtools/array/array/atleast_nd.hpp    |  34 ++++
 include/nmtools/array/eval.hpp                |   4 +-
 include/nmtools/array/functional.hpp          |   3 +-
 .../nmtools/array/functional/batch_norm.hpp   |  15 +-
 include/nmtools/array/functional/softmax.hpp  |   5 +
 include/nmtools/array/functional/softmin.hpp  |   2 +
 include/nmtools/array/functional/var.hpp      |   2 +
 include/nmtools/array/impl/utl.hpp            |  14 ++
 include/nmtools/array/index/alias.hpp         | 173 ++++++++++++++++++
 include/nmtools/array/index/append.hpp        | 104 +++++++++++
 include/nmtools/array/index/argsort.hpp       |   2 +-
 include/nmtools/array/index/as_tuple.hpp      |   2 +-
 include/nmtools/array/index/atleast_nd.hpp    |  12 +-
 include/nmtools/array/index/choose.hpp        |   2 +-
 include/nmtools/array/index/concatenate.hpp   |   4 +-
 include/nmtools/array/index/filter.hpp        |   2 +-
 include/nmtools/array/index/gather.hpp        |   2 +-
 include/nmtools/array/index/logical_not.hpp   |   2 +-
 include/nmtools/array/index/matmul.hpp        |  12 +-
 include/nmtools/array/index/moveaxis.hpp      |   2 +-
 include/nmtools/array/index/ndenumerate.hpp   |   2 +-
 .../nmtools/array/index/normalize_axis.hpp    |   4 +-
 include/nmtools/array/index/outer.hpp         |   2 +-
 include/nmtools/array/index/pack.hpp          |   2 +-
 include/nmtools/array/index/pad.hpp           |   2 +-
 .../array/index/remove_single_dims.hpp        |   2 +-
 include/nmtools/array/index/repeat.hpp        |   2 +-
 include/nmtools/array/index/reshape.hpp       |  18 +-
 include/nmtools/array/index/reverse.hpp       |   2 +-
 include/nmtools/array/index/scatter.hpp       |   2 +-
 include/nmtools/array/index/slice.hpp         |   8 +-
 include/nmtools/array/index/take.hpp          |   2 +-
 include/nmtools/array/ndarray/dynamic.hpp     |   6 +-
 include/nmtools/array/ndarray/fixed.hpp       |   4 +-
 include/nmtools/array/ndarray/hybrid.hpp      |   4 +-
 include/nmtools/array/shape.hpp               |   4 +-
 include/nmtools/array/view/alias.hpp          | 149 +++++++++++++--
 include/nmtools/array/view/batch_norm.hpp     |  19 +-
 .../nmtools/array/view/broadcast_arrays.hpp   |  29 +--
 include/nmtools/array/view/decorator.hpp      | 102 +++++++++--
 include/nmtools/array/view/mean.hpp           |   3 +-
 include/nmtools/array/view/moveaxis.hpp       |   7 +-
 include/nmtools/array/view/ref.hpp            |   2 +-
 .../array/view/ref/initializer_list.hpp       |   2 +-
 include/nmtools/array/view/softmax.hpp        |  25 +--
 include/nmtools/array/view/transpose.hpp      |  36 +++-
 include/nmtools/array/view/ufunc.hpp          |   3 +-
 include/nmtools/array/view/ufunc/detail.hpp   |   4 +-
 include/nmtools/array/view/ufunc/ufunc.hpp    |   2 +-
 include/nmtools/array/view/ufuncs/power.hpp   |  44 ++++-
 include/nmtools/array/view/var.hpp            |  21 +--
 include/nmtools/utility/ct_digraph.hpp        |  49 +++--
 include/nmtools/utility/fwd.hpp               |   2 +-
 include/nmtools/utility/unwrap.hpp            |   2 +-
 54 files changed, 810 insertions(+), 155 deletions(-)
 create mode 100644 include/nmtools/array/array/atleast_nd.hpp
 create mode 100644 include/nmtools/array/index/alias.hpp
 create mode 100644 include/nmtools/array/index/append.hpp

diff --git a/include/nmtools/array/array/atleast_nd.hpp b/include/nmtools/array/array/atleast_nd.hpp
new file mode 100644
index 000000000..e874c237d
--- /dev/null
+++ b/include/nmtools/array/array/atleast_nd.hpp
@@ -0,0 +1,34 @@
+#ifndef NMTOOLS_ARRAY_ARRAY_ATLEAST_ND_HPP
+#define NMTOOLS_ARRAY_ARRAY_ATLEAST_ND_HPP
+
+#include "nmtools/array/view/atleast_nd.hpp"
+#include "nmtools/array/eval.hpp"
+
+namespace nmtools::array
+{
+    /**
+     * @brief Eagerly compute atleast_nd.
+     * 
+     * @tparam output_t 
+     * @tparam context_t 
+     * @tparam array_t 
+     * @param array   Input array
+     * @param context Evaluation context
+     * @param output 
+     * @return constexpr auto 
+     */
+    template <typename output_t=none_t, typename context_t=none_t, typename resolver_t=eval_result_t<>,
+        typename array_t, typename nd_t>
+    constexpr auto atleast_nd(const array_t& array, nd_t nd
+        , context_t&& context=context_t{}, output_t&& output=output_t{},meta::as_value<resolver_t> resolver=meta::as_value_v<resolver_t>)
+    {
+        auto viewed = view::atleast_nd(array,nd);
+        return eval(viewed
+            ,nmtools::forward<context_t>(context)
+            ,nmtools::forward<output_t>(output)
+            ,resolver
+        );
+    } // atleast_nd
+} // namespace nmtools::array
+
+#endif // NMTOOLS_ARRAY_ARRAY_ATLEAST_ND_HPP
\ No newline at end of file
diff --git a/include/nmtools/array/eval.hpp b/include/nmtools/array/eval.hpp
index d2619d68a..9205ae631 100644
--- a/include/nmtools/array/eval.hpp
+++ b/include/nmtools/array/eval.hpp
@@ -452,7 +452,7 @@ namespace nmtools::meta
                 // default impl of make_fixed_ndarray only support integral constant for now
                 using stype = ct<s>;
                 if constexpr (is_void_v<type>) {
-                    using type = make_tuple_type_t<stype>;
+                    using type = nmtools_tuple<stype>;
                     return as_value_v<type>;
                 } else {
                     using type = append_type_t<type,stype>;
@@ -496,7 +496,7 @@ namespace nmtools::meta
                 // default impl of make_fixed_ndarray only support integral constant for now
                 using stype = ct<s>;
                 if constexpr (is_void_v<type>) {
-                    using type = make_tuple_type_t<stype>;
+                    using type = nmtools_tuple<stype>;
                     return as_value_v<type>;
                 } else {
                     using type = append_type_t<type,stype>;
diff --git a/include/nmtools/array/functional.hpp b/include/nmtools/array/functional.hpp
index 1e5610377..7a1785152 100644
--- a/include/nmtools/array/functional.hpp
+++ b/include/nmtools/array/functional.hpp
@@ -1,6 +1,8 @@
 #ifndef NMTOOLS_ARRAY_FUNCTIONAL_HPP
 #define NMTOOLS_ARRAY_FUNCTIONAL_HPP
 
+#include "nmtools/array/functional/indexing.hpp"
+
 #include "nmtools/array/functional/activations/celu.hpp"
 #include "nmtools/array/functional/activations/elu.hpp"
 #include "nmtools/array/functional/activations/hardshrink.hpp"
@@ -78,6 +80,5 @@
 #include "nmtools/array/functional/squeeze.hpp"
 #include "nmtools/array/functional/where.hpp"
 #include "nmtools/array/functional/zeros.hpp"
-#include "nmtools/array/functional/indexing.hpp"
 
 #endif // NMTOOLS_ARRAY_FUNCTIONAL_HPP
\ No newline at end of file
diff --git a/include/nmtools/array/functional/batch_norm.hpp b/include/nmtools/array/functional/batch_norm.hpp
index 192874e98..759ba44f1 100644
--- a/include/nmtools/array/functional/batch_norm.hpp
+++ b/include/nmtools/array/functional/batch_norm.hpp
@@ -2,14 +2,21 @@
 #define NMTOOLS_ARRAY_FUNCTIONAL_BATCH_NORM_HPP
 
 #include "nmtools/array/functional/functor.hpp"
+#include "nmtools/array/functional/moveaxis.hpp"
+#include "nmtools/array/functional/ufuncs/add.hpp"
+#include "nmtools/array/functional/ufuncs/multiply.hpp"
+#include "nmtools/array/functional/ufuncs/subtract.hpp"
+#include "nmtools/array/functional/ufuncs/divide.hpp"
+#include "nmtools/array/functional/ufuncs/sqrt.hpp"
 #include "nmtools/array/view/batch_norm.hpp"
 
 namespace nmtools::functional
 {
-    constexpr inline auto batch_norm = functor_t{quinary_fmap_t{
-        [](const auto&...args){
-            return view::batch_norm(args...);
-    }}};
+    constexpr inline auto batch_norm_fun = [](const auto&...args){
+        return view::batch_norm(args...);
+    };
+
+    constexpr inline auto batch_norm = functor_t{quinary_fmap_t<decltype(batch_norm_fun)>{batch_norm_fun}};
 } // namespace nmtools::functional
 
 #endif // NMTOOLS_ARRAY_FUNCTIONAL_BATCH_NORM_HPP
\ No newline at end of file
diff --git a/include/nmtools/array/functional/softmax.hpp b/include/nmtools/array/functional/softmax.hpp
index 5f1a3d2ff..27286aa39 100644
--- a/include/nmtools/array/functional/softmax.hpp
+++ b/include/nmtools/array/functional/softmax.hpp
@@ -2,6 +2,11 @@
 #define NMTOOLS_ARRAY_FUNCTIONAL_SOFTMAX_HPP
 
 #include "nmtools/array/functional/functor.hpp"
+#include "nmtools/array/functional/ufuncs/maximum.hpp"
+#include "nmtools/array/functional/ufuncs/subtract.hpp"
+#include "nmtools/array/functional/ufuncs/exp.hpp"
+#include "nmtools/array/functional/ufuncs/add.hpp"
+#include "nmtools/array/functional/ufuncs/divide.hpp"
 #include "nmtools/array/view/softmax.hpp"
 
 namespace nmtools::functional
diff --git a/include/nmtools/array/functional/softmin.hpp b/include/nmtools/array/functional/softmin.hpp
index 13e6568eb..796c3c0ba 100644
--- a/include/nmtools/array/functional/softmin.hpp
+++ b/include/nmtools/array/functional/softmin.hpp
@@ -2,6 +2,8 @@
 #define NMTOOLS_ARRAY_FUNCTIONAL_SOFTMIN_HPP
 
 #include "nmtools/array/functional/functor.hpp"
+#include "nmtools/array/functional/ufuncs/negative.hpp"
+#include "nmtools/array/functional/softmax.hpp"
 #include "nmtools/array/view/softmin.hpp"
 
 namespace nmtools::functional
diff --git a/include/nmtools/array/functional/var.hpp b/include/nmtools/array/functional/var.hpp
index e62074574..d2cd44b78 100644
--- a/include/nmtools/array/functional/var.hpp
+++ b/include/nmtools/array/functional/var.hpp
@@ -2,6 +2,8 @@
 #define NMTOOLS_ARRAY_FUNCTIONAL_VAR_HPP
 
 #include "nmtools/array/functional/functor.hpp"
+#include "nmtools/array/functional/ufuncs/add.hpp"
+#include "nmtools/array/functional/ufuncs/divide.hpp"
 #include "nmtools/array/view/var.hpp"
 
 namespace nmtools::functional
diff --git a/include/nmtools/array/impl/utl.hpp b/include/nmtools/array/impl/utl.hpp
index 33aaf8671..622c1927b 100644
--- a/include/nmtools/array/impl/utl.hpp
+++ b/include/nmtools/array/impl/utl.hpp
@@ -21,6 +21,7 @@ namespace nmtools::impl
         }
     };
 
+    // TODO: remove this specialization
     template <typename...Ts>
     struct len_t<utl::tuple<Ts...>>
     {
@@ -33,6 +34,19 @@ namespace nmtools::impl
         }
     };
 
+    // TODO: remove this specialization
+    template <typename...Ts>
+    struct len_t<utl::tuplev2<Ts...>>
+    {
+        using tuple = const utl::tuplev2<Ts...>&;
+        using type  = size_t;
+
+        constexpr auto operator()(tuple) const noexcept
+        {
+            return sizeof...(Ts);
+        }
+    };
+
     template <typename T, typename allocator>
     struct len_t<utl::vector<T,allocator>>
     {
diff --git a/include/nmtools/array/index/alias.hpp b/include/nmtools/array/index/alias.hpp
new file mode 100644
index 000000000..c5d7a1aba
--- /dev/null
+++ b/include/nmtools/array/index/alias.hpp
@@ -0,0 +1,173 @@
+#ifndef NMTOOLS_ARRAY_INDEX_ALIAS_HPP
+#define NMTOOLS_ARRAY_INDEX_ALIAS_HPP
+
+#include "nmtools/meta.hpp"
+#include "nmtools/array/at.hpp"
+#include "nmtools/array/shape.hpp"
+#include "nmtools/array/index/max.hpp"
+
+namespace nmtools::index
+{
+    struct alias_t {};
+
+    template <typename operands_ids_t, typename reserved_ids_t>
+    constexpr auto alias(const operands_ids_t& operands_ids, const reserved_ids_t& reserved_ids)
+    {
+        using result_t = meta::resolve_optype_t<alias_t,operands_ids_t,reserved_ids_t>;
+
+        auto result = result_t{};
+
+        if constexpr (!meta::is_constant_index_array_v<result_t>
+            && !meta::is_fail_v<result_t>
+        ) {
+            auto size = len(operands_ids);
+            if constexpr (meta::is_resizable_v<result_t>) {
+                result.resize(size);
+            }
+            nm_index_t max_reserved_id = [&]{
+                if constexpr (is_none_v<reserved_ids_t>) {
+                    return -1;
+                } else {
+                    return max(reserved_ids);
+                }
+            }();
+            nm_index_t max_operands_id = [&]{
+                if constexpr (meta::is_constant_index_array_v<operands_ids_t>) {
+                    return max(operands_ids);
+                } else {
+                    return -1;
+                }
+            }();
+            nm_index_t max_id = max_reserved_id > max_operands_id ? max_reserved_id : max_operands_id;
+            nm_size_t tracked_id = max_id + 1;
+            for (nm_size_t i=0; i<(nm_size_t)size; i++) {
+                auto id = at(operands_ids,i);
+                if (id < 0) {
+                    at(result,i) = tracked_id;
+                    tracked_id++;
+                } else {
+                    at(result,i) = id;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    struct generate_alias_t {};
+
+    #ifndef NMTOOLS_ALIAS_DEFAULT_BASE
+    #define NMTOOLS_ALIAS_DEFAULT_BASE 512
+    #endif
+
+    #ifndef NMTOOLS_ALIAS_DEFAULT_PRIME
+    #define NMTOOLS_ALIAS_DEFAULT_PRIME 1033
+    #endif
+
+    // polynomial rolling hash
+    template <typename aliases_t, typename base_t=meta::ct<NMTOOLS_ALIAS_DEFAULT_BASE>, typename prime_t=meta::ct<NMTOOLS_ALIAS_DEFAULT_PRIME>>
+    constexpr auto generate_alias(const aliases_t& aliases, base_t base=base_t{}, prime_t prime=prime_t{})
+    {
+        using result_t = meta::resolve_optype_t<generate_alias_t,aliases_t,base_t,prime_t>;
+
+        auto result = result_t {};
+
+        if constexpr (!meta::is_constant_index_v<result_t>
+            && !meta::is_fail_v<result_t>
+        ) {
+            result = 0;
+            auto N = len(aliases);
+            for (nm_size_t i=0; i<(nm_size_t)N; i++) {
+                result = (result * base + at(aliases,i)) % prime;
+            }
+        }
+
+        return result;
+    }
+} // namespace nmtools::index
+
+namespace nmtools::meta
+{
+    namespace error
+    {
+        template <typename...>
+        struct ALIAS_UNSUPPORTED : detail::fail_t {};
+
+        template <typename...>
+        struct GENERATE_ALIAS_UNSUPPORTED : detail::fail_t {};
+    }
+
+    template <typename operands_ids_t, typename reserved_ids_t>
+    struct resolve_optype<
+        void, index::alias_t, operands_ids_t, reserved_ids_t
+    > {
+        static constexpr auto vtype = [](){
+            [[maybe_unused]] constexpr auto SIZE   = len_v<operands_ids_t>;
+            [[maybe_unused]] constexpr auto B_SIZE = bounded_size_v<operands_ids_t>;
+            if constexpr (
+                !is_index_array_v<operands_ids_t>
+                || !(is_index_array_v<reserved_ids_t> || is_none_v<reserved_ids_t>)
+            ) {
+                using type = error::ALIAS_UNSUPPORTED<operands_ids_t,reserved_ids_t>;
+                return as_value_v<type>;
+            } else if constexpr (
+                is_constant_index_array_v<operands_ids_t>
+                && (is_constant_index_array_v<reserved_ids_t> || is_none_v<reserved_ids_t>)
+            ) {
+                constexpr auto operands_ids = to_value_v<operands_ids_t>;
+                constexpr auto reserved_ids = to_value_v<reserved_ids_t>;
+                constexpr auto result = index::alias(operands_ids,reserved_ids);
+                using nmtools::at, nmtools::len;
+                return template_reduce<len(result)>([&](auto init, auto index){
+                    using init_type   = type_t<decltype(init)>;
+                    using result_type = append_type_t<init_type,ct<at(result,index)>>;
+                    return as_value_v<result_type>;
+                },as_value_v<nmtools_tuple<>>);
+            } else if constexpr (SIZE > 0) {
+                using type = nmtools_array<nm_size_t,SIZE>;
+                return as_value_v<type>;
+            } else if constexpr (!is_fail_v<decltype(B_SIZE)>) {
+                using type = nmtools_static_vector<nm_size_t,B_SIZE>;
+                return as_value_v<type>;
+            } else {
+                // TODO: support small_vector
+                using type = nmtools_list<nm_size_t>;
+                return as_value_v<type>;
+            }
+        }();
+        using type = type_t<decltype(vtype)>;
+    };
+
+    template <typename aliases_t, typename base_t, typename prime_t>
+    struct resolve_optype<
+        void, index::generate_alias_t, aliases_t, base_t, prime_t
+    > {
+        static constexpr auto vtype = [](){
+            if constexpr (
+                !is_index_array_v<aliases_t>
+                || !is_index_v<base_t>
+                || !is_index_v<prime_t>
+            ) {
+                using type = error::GENERATE_ALIAS_UNSUPPORTED<aliases_t,base_t,prime_t>;
+                return as_value_v<type>;
+            } else if constexpr (
+                is_constant_index_array_v<aliases_t>
+                && is_constant_index_v<base_t>
+                && is_constant_index_v<prime_t>
+            ) {
+                constexpr auto aliases = to_value_v<aliases_t>;
+                constexpr auto base    = to_value_v<base_t>;
+                constexpr auto prime   = to_value_v<prime_t>;
+                constexpr auto result  = index::generate_alias(aliases,base,prime);
+                using type = meta::ct<(nm_index_t)result>;
+                return as_value_v<type>;
+            } else {
+                using type = nm_index_t;
+                return as_value_v<type>;
+            }
+        }();
+        using type = type_t<decltype(vtype)>;
+    };
+} // namespace nmtools::meta
+
+#endif // NMTOOLS_ARRAY_INDEX_ALIAS_HPP
\ No newline at end of file
diff --git a/include/nmtools/array/index/append.hpp b/include/nmtools/array/index/append.hpp
new file mode 100644
index 000000000..e79a9307f
--- /dev/null
+++ b/include/nmtools/array/index/append.hpp
@@ -0,0 +1,104 @@
+#ifndef NMTOOLS_ARRAY_INDEX_APPEND_HPP
+#define NMTOOLS_ARRAY_INDEX_APPEND_HPP
+
+#include "nmtools/meta.hpp"
+
+namespace nmtools::index
+{
+    struct append_t {};
+
+    template <typename indices_t, typename index_t>
+    constexpr auto append(const indices_t& indices, index_t index)
+    {
+        using result_t = meta::resolve_optype_t<append_t,indices_t,index_t>;
+
+        auto result = result_t {};
+
+        if constexpr (!meta::is_constant_index_array_v<result_t>
+            && !meta::is_fail_v<result_t>
+        ) {
+            auto n = len(indices);
+            if constexpr (meta::is_resizable_v<result_t>) {
+                result.resize(n+1);
+            }
+            [[maybe_unused]]
+            auto f = [&](const auto& indices){
+                auto n = len(indices);
+                for (nm_size_t i=0; i<(nm_size_t)n; i++) {
+                    at(result,i) = at(indices,i);
+                }
+            };
+            constexpr auto B_SIZE = meta::bounded_size_v<indices_t>;
+            // avoid calling at(indices,i) when indices is tuple<>
+            if constexpr (meta::is_fail_v<decltype(B_SIZE)>) {
+                f(indices);
+            } else if constexpr (B_SIZE > 0) {
+                f(indices);
+            }
+            at(result,n) = index;
+        }
+
+        return result;
+    }
+} // namespace nmtools::index
+
+namespace nmtools::meta
+{
+    namespace error
+    {
+        template <typename...>
+        struct APPEND_UNSUPPORTED : detail::fail_t {};
+    }
+
+    template <typename indices_t, typename index_t>
+    struct resolve_optype<
+        void, index::append_t, indices_t, index_t
+    > {
+        static constexpr auto vtype = [](){
+            [[maybe_unused]]
+            constexpr auto DIM = len_v<indices_t>;
+            [[maybe_unused]]
+            constexpr auto B_DIM = bounded_size_v<indices_t>;
+            if constexpr (!is_index_array_v<indices_t>
+                || !is_index_v<index_t>
+            ) {
+                using type = error::APPEND_UNSUPPORTED<indices_t,index_t>;
+                return as_value_v<type>;
+            } else if constexpr (
+                is_constant_index_array_v<indices_t>
+                && is_constant_index_v<index_t>
+            ) {
+                constexpr auto indices = to_value_v<indices_t>;
+                constexpr auto idx     = to_value_v<index_t>;
+                constexpr auto result  = index::append(indices,idx);
+                using nmtools::at, nmtools::len;
+                return template_reduce<len(result)>([&](auto init, auto index){
+                    using init_type   = type_t<decltype(init)>;
+                    using result_type = append_type_t<init_type,ct<at(result,index)>>;
+                    return as_value_v<result_type>;
+                }, as_value_v<nmtools_tuple<>>);
+            } else if constexpr (DIM > 0) {
+                using element_t = get_index_element_type_t<indices_t>;
+                using type = nmtools_array<element_t,DIM+1>;
+                return as_value_v<type>;
+            } else if constexpr (!is_fail_v<decltype(B_DIM)>) {
+                if constexpr (B_DIM == 0) {
+                    using type = nmtools_array<nm_index_t,1>;
+                    return as_value_v<type>;
+                } else {
+                    using element_t = get_index_element_type_t<indices_t>;
+                    using type = nmtools_static_vector<element_t,B_DIM>;
+                    return as_value_v<type>;
+                }
+            } else {
+                using element_t = get_index_element_type_t<indices_t>;
+                // TODO: support small_vector
+                using type = nmtools_list<element_t>;
+                return as_value_v<type>;
+            }
+        }();
+        using type = type_t<decltype(vtype)>;
+    };
+} // namespace nmtools::meta
+
+#endif // NMTOOLS_ARRAY_INDEX_APPEND_HPP
\ No newline at end of file
diff --git a/include/nmtools/array/index/argsort.hpp b/include/nmtools/array/index/argsort.hpp
index 603651ede..9a62e33a9 100644
--- a/include/nmtools/array/index/argsort.hpp
+++ b/include/nmtools/array/index/argsort.hpp
@@ -98,7 +98,7 @@ namespace nmtools::meta
                 constexpr auto array = to_value_v<array_t>;
                 constexpr auto args  = index::argsort(array);
                 // transform back to type
-                using init_type = make_tuple_type_t<ct<at(args,0)>>;
+                using init_type = nmtools_tuple<ct<at(args,0)>>;
                 return template_reduce<nmtools::len(args)-1>([&](auto init, auto index){
                     using init_t = type_t<decltype(init)>;
                     using init_i = ct<at(args,index+1)>;
diff --git a/include/nmtools/array/index/as_tuple.hpp b/include/nmtools/array/index/as_tuple.hpp
index 6bf49373f..e7a9facfb 100644
--- a/include/nmtools/array/index/as_tuple.hpp
+++ b/include/nmtools/array/index/as_tuple.hpp
@@ -22,7 +22,7 @@ namespace nmtools::index
     template <template<auto...>typename index_sequence, typename array_t, size_t...Is>
     constexpr decltype(auto) as_tuple(const array_t& array, index_sequence<Is...>)
     {
-        using tuple_t = meta::make_tuple_type_t<meta::remove_cvref_t<decltype(nmtools::get<Is>(array))>...>;
+        using tuple_t = nmtools_tuple<meta::remove_cvref_t<decltype(nmtools::get<Is>(array))>...>;
         return tuple_t{nmtools::get<Is>(array)...};
     } // as_tuple
 
diff --git a/include/nmtools/array/index/atleast_nd.hpp b/include/nmtools/array/index/atleast_nd.hpp
index 0a659597b..3a318fe17 100644
--- a/include/nmtools/array/index/atleast_nd.hpp
+++ b/include/nmtools/array/index/atleast_nd.hpp
@@ -17,9 +17,17 @@ namespace nmtools::index
     template <typename shape_t, typename nd_t>
     constexpr auto shape_atleast_nd(const shape_t& shape, [[maybe_unused]] nd_t nd)
     {
-        using result_t = meta::resolve_optype_t<shape_atleast_nd_t,shape_t,nd_t>;
+        using result_t [[maybe_unused]] = meta::resolve_optype_t<shape_atleast_nd_t,shape_t,nd_t>;
 
-        if constexpr (meta::is_constant_index_array_v<result_t>) {
+        if constexpr (meta::is_maybe_v<shape_t>) {
+            using shape_type = meta::get_maybe_type_t<shape_t>;
+            using result_t   = meta::resolve_optype_t<shape_atleast_nd_t,shape_type,nd_t>;
+            using return_t   = meta::conditional_t<meta::is_maybe_v<result_t>,result_t,nmtools_maybe<result_t>>;
+            return (static_cast<bool>(shape)
+                ? return_t{shape_atleast_nd(*shape,nd)}
+                : return_t{meta::Nothing}
+            );
+        } else if constexpr (meta::is_constant_index_array_v<result_t>) {
             return result_t {};
         } else {
             auto result = result_t {};
diff --git a/include/nmtools/array/index/choose.hpp b/include/nmtools/array/index/choose.hpp
index 8a557d42a..fd6a3e6d2 100644
--- a/include/nmtools/array/index/choose.hpp
+++ b/include/nmtools/array/index/choose.hpp
@@ -133,7 +133,7 @@ namespace nmtools::meta
             ) {
                 // TODO: compute at compile-time here, then maps back to type
                 constexpr auto N = fixed_index_array_size_v<indices_t>;
-                using type = make_fixed_ndarray_t<element_t,make_tuple_type_t<ct<N>>>;
+                using type = make_fixed_ndarray_t<element_t,nmtools_tuple<ct<N>>>;
                 return as_value_v<type>;
             } else if constexpr (
                    is_hybrid_index_array_v<indices_t>
diff --git a/include/nmtools/array/index/concatenate.hpp b/include/nmtools/array/index/concatenate.hpp
index 4f73eab90..e3e8a77ed 100644
--- a/include/nmtools/array/index/concatenate.hpp
+++ b/include/nmtools/array/index/concatenate.hpp
@@ -129,7 +129,7 @@ namespace nmtools::meta
             if constexpr (is_fixed_index_array_v<shape_t>) {
                 constexpr auto N = len_v<shape_t>;
                 using elem_t = remove_cvref_t<get_index_element_type_t<shape_t>>;
-                return as_value_v<make_array_type_t<elem_t,N>>;
+                return as_value_v<nmtools_array<elem_t,N>>;
             } else if constexpr (is_index_array_v<shape_t>) {
                 return as_value_v<shape_t>;
             } else {
@@ -223,7 +223,7 @@ namespace nmtools::index
             else success = false;
             
             // TODO: use optional instead
-            using return_t = meta::make_tuple_type_t<bool,result_t>;
+            using return_t = nmtools_tuple<bool,result_t>;
             return return_t{success,ret};
         }
     } // shape_concatenate
diff --git a/include/nmtools/array/index/filter.hpp b/include/nmtools/array/index/filter.hpp
index ee1203fcf..d200ac514 100644
--- a/include/nmtools/array/index/filter.hpp
+++ b/include/nmtools/array/index/filter.hpp
@@ -25,7 +25,7 @@ namespace nmtools::index
         auto chosen  = choose(indices,array);
         using indices_t = meta::remove_cvref_t<decltype(indices)>;
         using chosen_t  = meta::remove_cvref_t<decltype(chosen)>;
-        using return_t  = meta::make_tuple_type_t<indices_t,chosen_t>;
+        using return_t  = nmtools_tuple<indices_t,chosen_t>;
         return return_t{indices, chosen};
     } // filter
 } // namespace nmtools::index
diff --git a/include/nmtools/array/index/gather.hpp b/include/nmtools/array/index/gather.hpp
index 9585632fd..9ea823f4e 100644
--- a/include/nmtools/array/index/gather.hpp
+++ b/include/nmtools/array/index/gather.hpp
@@ -103,7 +103,7 @@ namespace nmtools::meta
                 constexpr auto result  = index::gather(vector,indices);
                 // assuming len(result) > 0
                 // transform back to type
-                using init_type = make_tuple_type_t<ct<at(result,0)>>;
+                using init_type = nmtools_tuple<ct<at(result,0)>>;
                 return template_reduce<nmtools::len(result)-1>([&](auto init, auto index){
                     using init_t   = type_t<decltype(init)>;
                     using result_i = ct<at(result,index+1)>;
diff --git a/include/nmtools/array/index/logical_not.hpp b/include/nmtools/array/index/logical_not.hpp
index dcd5f71f8..865627918 100644
--- a/include/nmtools/array/index/logical_not.hpp
+++ b/include/nmtools/array/index/logical_not.hpp
@@ -72,7 +72,7 @@ namespace nmtools::meta
                 constexpr auto result = index::logical_not(array);
                 // assuming len(result) > 0
                 // transform back to type
-                using init_type = make_tuple_type_t<ct<at(result,0)>>;
+                using init_type = nmtools_tuple<ct<at(result,0)>>;
                 return template_reduce<::nmtools::len(result)-1>([&](auto init, auto index){
                     using init_t   = type_t<decltype(init)>;
                     using result_i = ct<at(result,index+1)>;
diff --git a/include/nmtools/array/index/matmul.hpp b/include/nmtools/array/index/matmul.hpp
index 43767ee95..5bcc35d24 100644
--- a/include/nmtools/array/index/matmul.hpp
+++ b/include/nmtools/array/index/matmul.hpp
@@ -97,7 +97,7 @@ namespace nmtools::meta
                 using element_t = get_index_element_type_t<shape_t>;
                 // NOTE: use make_hybrid_ndarray instead of make_hybrid_ndarray_t to avoid including ndarray.hpp
                 using hybrid_t  = typename make_hybrid_ndarray<element_t,max_elements,1>::type;
-                using type = make_tuple_type_t<hybrid_t,hybrid_t>;
+                using type = nmtools_tuple<hybrid_t,hybrid_t>;
                 return as_value_v<type>;
             } else if constexpr (is_fixed_index_array_v<shape_t> && is_constant_index_v<split_t>) {
                 // number of dimension of the array
@@ -113,14 +113,14 @@ namespace nmtools::meta
                 }();
                 using element_t = get_index_element_type_t<shape_t>;
 
-                using left_size_t  = make_tuple_type_t<ct<i>>;
-                using right_size_t = make_tuple_type_t<ct<N-i>>;
+                using left_size_t  = nmtools_tuple<ct<i>>;
+                using right_size_t = nmtools_tuple<ct<N-i>>;
                 using left_t  = typename make_fixed_ndarray<element_t,left_size_t>::type;
                 using right_t = typename make_fixed_ndarray<element_t,right_size_t>::type;
-                using type    = make_tuple_type_t<left_t,right_t>;
+                using type    = nmtools_tuple<left_t,right_t>;
                 return as_value_v<type>;
             } else if constexpr (is_index_array_v<shape_t>) {
-                using type = make_tuple_type_t<shape_t,shape_t>;
+                using type = nmtools_tuple<shape_t,shape_t>;
                 return as_value_v<type>;
             } else {
                 // unhandled type
@@ -150,7 +150,7 @@ namespace nmtools::index
     constexpr auto shape_matmul(const lhs_shape_t& ashape, const rhs_shape_t& bshape)
     {
         using result_t = meta::resolve_optype_t<shape_matmul_t,lhs_shape_t,rhs_shape_t>;
-        using return_t = meta::make_maybe_type_t<result_t>;
+        using return_t = nmtools_maybe<result_t>;
 
         if constexpr (meta::is_constant_index_array_v<result_t>) {
             // still use maybe for simplicity at caller site
diff --git a/include/nmtools/array/index/moveaxis.hpp b/include/nmtools/array/index/moveaxis.hpp
index a81d62334..0e6ba2a66 100644
--- a/include/nmtools/array/index/moveaxis.hpp
+++ b/include/nmtools/array/index/moveaxis.hpp
@@ -158,7 +158,7 @@ namespace nmtools::index
             // return ret;
         } else {
             // NOTE: quick hack so no need to modify caller to handle non maybe type
-            using return_t = meta::make_maybe_type_t<result_t>;
+            using return_t = nmtools_maybe<result_t>;
             static_assert( !meta::is_fail_v<result_t>
                 , "unsupported moveaxis_to_transpose"
             );
diff --git a/include/nmtools/array/index/ndenumerate.hpp b/include/nmtools/array/index/ndenumerate.hpp
index 97b58f627..9012c2267 100644
--- a/include/nmtools/array/index/ndenumerate.hpp
+++ b/include/nmtools/array/index/ndenumerate.hpp
@@ -56,7 +56,7 @@ namespace nmtools::index
         } // size
 
         constexpr inline auto operator[](size_t i) const
-            -> meta::make_tuple_type_t<index_type,const element_type&>
+            -> nmtools_tuple<index_type,const element_type&>
         {
             auto idx = ndindex_[i];
             const auto& val = apply_at(array,idx);
diff --git a/include/nmtools/array/index/normalize_axis.hpp b/include/nmtools/array/index/normalize_axis.hpp
index b21245237..eecea5006 100644
--- a/include/nmtools/array/index/normalize_axis.hpp
+++ b/include/nmtools/array/index/normalize_axis.hpp
@@ -35,7 +35,7 @@ namespace nmtools::index
         using ndim_t [[maybe_unused]] = decltype(ndim);
 
         if constexpr (! (meta::is_constant_index_v<result_t> || meta::is_constant_index_array_v<result_t>)) {
-            using return_t = meta::make_maybe_type_t<result_t>;
+            using return_t = nmtools_maybe<result_t>;
             // using return_t = utl::maybe<result_t>;
 
             // auto ret = return_t {};
@@ -98,7 +98,7 @@ namespace nmtools::index
         } else {
             // NOTE: quick-hack
             // TODO: no need to return maybe type
-            using return_t = meta::make_maybe_type_t<result_t>;
+            using return_t = nmtools_maybe<result_t>;
 
             auto valid = [&](){
                 const auto result = result_t {};
diff --git a/include/nmtools/array/index/outer.hpp b/include/nmtools/array/index/outer.hpp
index ad559d8dc..ced7b4dcd 100644
--- a/include/nmtools/array/index/outer.hpp
+++ b/include/nmtools/array/index/outer.hpp
@@ -99,7 +99,7 @@ namespace nmtools::index
         for (size_t i=0; i<bdim; i++)
             at(bidx,i) = at(indices,i+adim);
         
-        using return_t = meta::make_tuple_type_t<aidx_t,bidx_t>;
+        using return_t = nmtools_tuple<aidx_t,bidx_t>;
         return return_t{aidx,bidx};
     }
 } // namespace nmtools::index
diff --git a/include/nmtools/array/index/pack.hpp b/include/nmtools/array/index/pack.hpp
index b9ab004a8..cad83c88f 100644
--- a/include/nmtools/array/index/pack.hpp
+++ b/include/nmtools/array/index/pack.hpp
@@ -21,7 +21,7 @@ namespace nmtools::index
         // using common_t = meta::promote_index_t<size_types...>;
         using common_t = meta::type_t<meta::promote_index<size_type,size_types...>>;
         if constexpr (meta::is_integral_v<common_t>) {
-            using array_t = meta::make_array_type_t<common_t,1+sizeof...(indices)>;
+            using array_t = nmtools_array<common_t,1+sizeof...(indices)>;
             return array_t{index_,indices...};
         } else /* if constexpr (meta::is_index_array_v<size_type>) */ {
             static_assert (sizeof...(indices)==0
diff --git a/include/nmtools/array/index/pad.hpp b/include/nmtools/array/index/pad.hpp
index 6459fd70a..acf8360f4 100644
--- a/include/nmtools/array/index/pad.hpp
+++ b/include/nmtools/array/index/pad.hpp
@@ -102,7 +102,7 @@ namespace nmtools::index
     {
         using result_t = meta::resolve_optype_t<pad_t,index_t,src_shape_t,dst_shape_t,pad_width_t>;
         // use maybe type to indicate out of bound index (of src shape)
-        using return_t = meta::make_maybe_type_t<result_t>;
+        using return_t = nmtools_maybe<result_t>;
         using idx_t    = meta::get_index_element_type_t<result_t>;
         using s_idx_t  = meta::make_signed_t<idx_t>;
 
diff --git a/include/nmtools/array/index/remove_single_dims.hpp b/include/nmtools/array/index/remove_single_dims.hpp
index 5615db9ab..146ae8c25 100644
--- a/include/nmtools/array/index/remove_single_dims.hpp
+++ b/include/nmtools/array/index/remove_single_dims.hpp
@@ -66,7 +66,7 @@ namespace nmtools::meta
                 constexpr auto result = index::remove_single_dims(shape);
                 // assuming len(result) > 0
                 // transform back to type
-                using init_type = make_tuple_type_t<ct<at(result,0)>>;
+                using init_type = nmtools_tuple<ct<at(result,0)>>;
                 return template_reduce<::nmtools::len(result)-1>([&](auto init, auto index){
                     using init_t   = type_t<decltype(init)>;
                     using result_i = ct<at(result,index+1)>;
diff --git a/include/nmtools/array/index/repeat.hpp b/include/nmtools/array/index/repeat.hpp
index bc7c10949..d4e2a5f4a 100644
--- a/include/nmtools/array/index/repeat.hpp
+++ b/include/nmtools/array/index/repeat.hpp
@@ -141,7 +141,7 @@ namespace nmtools::meta
                     }
                 }, as_value_v<nmtools_tuple<>>);
             } else if constexpr (is_none_v<axis_t>) {
-                using type = make_array_type_t<size_t,1>;
+                using type = nmtools_array<size_t,1>;
                 return as_value_v<type>;
             } else if constexpr (
                 is_index_array_v<shape_t>
diff --git a/include/nmtools/array/index/reshape.hpp b/include/nmtools/array/index/reshape.hpp
index 80c7356be..1215d49b7 100644
--- a/include/nmtools/array/index/reshape.hpp
+++ b/include/nmtools/array/index/reshape.hpp
@@ -45,7 +45,7 @@ namespace nmtools::index
     template <typename src_shape_t, typename dst_shape_t>
     constexpr auto shape_reshape(const src_shape_t& src_shape, const dst_shape_t& dst_shape)
     {
-        using result_t = meta::resolve_optype_t<shape_reshape_t,src_shape_t,dst_shape_t>;
+        using result_t [[maybe_unused]] = meta::resolve_optype_t<shape_reshape_t,src_shape_t,dst_shape_t>;
         using m_result_t [[maybe_unused]] = meta::get_maybe_type_t<result_t>;
 
         // TODO: try to provide common function-lifting utility
@@ -53,6 +53,7 @@ namespace nmtools::index
             // when src_shape is maybe, then assume the result_t is maybe
             if (static_cast<bool>(src_shape)) {
                 auto result = shape_reshape(*src_shape,dst_shape);
+                #if 0
                 // even if we unwrap the src_shape, the result may be maybe type
                 // since dst_shape may be different shape with src
                 // because std::optional<std::optional<int>> is actually allowed
@@ -67,9 +68,24 @@ namespace nmtools::index
                 } else {
                     return result_t{result};
                 }
+                #else
+                using return_t = result_t;
+                return (has_value(result)
+                    ? return_t{unwrap(result)}
+                    : return_t{meta::Nothing}
+                );
+                #endif
             } else {
                 return result_t{meta::Nothing};
             }
+        } else if constexpr (meta::is_maybe_v<dst_shape_t>) {
+            using dst_shape_type = meta::get_maybe_type_t<dst_shape_t>;
+            using result_t = meta::resolve_optype_t<shape_reshape_t,src_shape_t,dst_shape_type>;
+            using return_t = meta::conditional_t<meta::is_maybe_v<result_t>,result_t,nmtools_maybe<result_t>>;
+            return (static_cast<bool>(dst_shape)
+                ? return_t{shape_reshape(src_shape,*dst_shape)}
+                : return_t{meta::Nothing}
+            );
         } else if constexpr (meta::is_fail_v<result_t>) {
             // let the caller decides what to do
             return result_t {};
diff --git a/include/nmtools/array/index/reverse.hpp b/include/nmtools/array/index/reverse.hpp
index 27400db84..f3c005e88 100644
--- a/include/nmtools/array/index/reverse.hpp
+++ b/include/nmtools/array/index/reverse.hpp
@@ -62,7 +62,7 @@ namespace nmtools::meta
             if constexpr (is_constant_index_array_v<indices_t>) {
                 constexpr auto indices = to_value_v<indices_t>;
                 constexpr auto reversed = index::reverse(indices);
-                using init_type = make_tuple_type_t<ct<at(reversed,0)>>;
+                using init_type = nmtools_tuple<ct<at(reversed,0)>>;
                 // convert back to type
                 return template_reduce<::nmtools::len(reversed)-1>([&](auto init, auto index){
                     using init_t = type_t<decltype(init)>;
diff --git a/include/nmtools/array/index/scatter.hpp b/include/nmtools/array/index/scatter.hpp
index 5014e6f58..de6f491db 100644
--- a/include/nmtools/array/index/scatter.hpp
+++ b/include/nmtools/array/index/scatter.hpp
@@ -88,7 +88,7 @@ namespace nmtools::meta
                 constexpr auto ind = to_value_v<indices_t>;
                 constexpr auto res = index::scatter(vec, ind);
                 // convert back to type
-                using init_type = make_tuple_type_t<ct<at(res,0)>>;
+                using init_type = nmtools_tuple<ct<at(res,0)>>;
                 return template_reduce<::nmtools::len(res)-1>([&](auto init, auto index){
                     using init_t = type_t<decltype(init)>;
                     using result_t = append_type_t<init_t,ct<at(res,index+1)>>;
diff --git a/include/nmtools/array/index/slice.hpp b/include/nmtools/array/index/slice.hpp
index 037d13fdd..77b5e5c74 100644
--- a/include/nmtools/array/index/slice.hpp
+++ b/include/nmtools/array/index/slice.hpp
@@ -683,7 +683,7 @@ namespace nmtools::index
                     constexpr auto NS = meta::len_v<decltype(slice)>;
                     if constexpr (NS==2) {
                         const auto [start, stop] = slice;
-                        using mresult_t = meta::make_tuple_type_t<decltype(start),decltype(stop),none_t>;
+                        using mresult_t = nmtools_tuple<decltype(start),decltype(stop),none_t>;
                         return mresult_t{start,stop,None};
                     }
                     // return as it is to keep dtype
@@ -883,7 +883,7 @@ namespace nmtools::index
         // TODO error handling
         // make sure sizeof...(slices) <= len(shape)
 
-        auto slices_pack = meta::make_tuple_type_t<const slices_t&...>{slices...};
+        auto slices_pack = nmtools_tuple<const slices_t&...>{slices...};
 
         // since res and shape may have different dim,
         // this var is to keep track of the active result index
@@ -1039,7 +1039,7 @@ namespace nmtools::index
         if constexpr (meta::is_resizable_v<return_t>)
             res.resize(dim);
         
-        auto slices_pack = meta::make_tuple_type_t<const slices_t&...>{slices...};
+        auto slices_pack = nmtools_tuple<const slices_t&...>{slices...};
 
         // since res and shape may have different dim,
         // also indices and shape may have different dim,
@@ -1093,7 +1093,7 @@ namespace nmtools::index
                     constexpr auto NS = meta::len_v<decltype(slice)>;
                     if constexpr (NS==2) {
                         const auto [start, stop] = slice;
-                        using mresult_t = meta::make_tuple_type_t<decltype(start),decltype(stop),none_t>;
+                        using mresult_t = nmtools_tuple<decltype(start),decltype(stop),none_t>;
                         return mresult_t{start,stop,None};
                     }
                     // return as it is to keep dtype
diff --git a/include/nmtools/array/index/take.hpp b/include/nmtools/array/index/take.hpp
index 940e75bc4..fc31ec80a 100644
--- a/include/nmtools/array/index/take.hpp
+++ b/include/nmtools/array/index/take.hpp
@@ -111,7 +111,7 @@ namespace nmtools::meta
     >
     {
         // when slicing flattened array, the shape should be single element 1D array
-        using type = make_array_type_t<size_t,1>;
+        using type = nmtools_array<size_t,1>;
     }; // shape_take_t
 
     namespace error
diff --git a/include/nmtools/array/ndarray/dynamic.hpp b/include/nmtools/array/ndarray/dynamic.hpp
index e3c256baf..89a85cc54 100644
--- a/include/nmtools/array/ndarray/dynamic.hpp
+++ b/include/nmtools/array/ndarray/dynamic.hpp
@@ -181,7 +181,7 @@ namespace nmtools::array
             shape_.resize(sizeof...(shape));
             meta::template_for<sizeof...(shape)>([&](auto index){
                 constexpr auto i = decltype(index)::value;
-                using tuple_t = meta::make_tuple_type_t<decltype(shape)...>;
+                using tuple_t = nmtools_tuple<decltype(shape)...>;
                 shape_.at(i) = nmtools::get<i>(tuple_t{shape...});
             });
             strides_ = strides();
@@ -223,7 +223,7 @@ namespace nmtools::array
         constexpr decltype(auto) operator()(size_type n, size_types...ns)
         {
             using common_size_t = meta::promote_index_t<size_type,size_types...>;
-            auto indices = meta::make_array_type_t<common_size_t,sizeof...(ns)+1>{
+            auto indices = nmtools_array<common_size_t,sizeof...(ns)+1>{
                 static_cast<common_size_t>(n), static_cast<common_size_t>(ns)...
             };
             assert (dim()==indices.size());
@@ -244,7 +244,7 @@ namespace nmtools::array
         constexpr decltype(auto) operator()(size_type n, size_types...ns) const
         {
             using common_size_t = meta::promote_index_t<size_type,size_types...>;
-            auto indices = meta::make_array_type_t<common_size_t,sizeof...(ns)+1>{
+            auto indices = nmtools_array<common_size_t,sizeof...(ns)+1>{
                 static_cast<common_size_t>(n), static_cast<common_size_t>(ns)...
             };
             assert (dim()==indices.size());
diff --git a/include/nmtools/array/ndarray/fixed.hpp b/include/nmtools/array/ndarray/fixed.hpp
index 0b978775a..09425cb3b 100644
--- a/include/nmtools/array/ndarray/fixed.hpp
+++ b/include/nmtools/array/ndarray/fixed.hpp
@@ -80,7 +80,7 @@ namespace nmtools::array {
          */
         static constexpr auto strides()
         {
-            auto stride = meta::make_array_type_t<size_t,dim()>{};
+            auto stride = nmtools_array<size_t,dim()>{};
             for (size_t i=0; i<dim(); i++)
                 stride[i] = ::nmtools::index::stride(shape_,i);
             return stride;
@@ -269,7 +269,7 @@ namespace nmtools
         : fixed_shape<array::fixed_ndarray<T,Shape1,ShapeN...>> {};
     #if 0
     {
-        static inline constexpr auto value = meta::make_array_type_t<size_t,sizeof...(ShapeN)+1>{Shape1,ShapeN...};
+        static inline constexpr auto value = nmtools_array<size_t,sizeof...(ShapeN)+1>{Shape1,ShapeN...};
         using value_type = decltype(value);
     };
     #endif
diff --git a/include/nmtools/array/ndarray/hybrid.hpp b/include/nmtools/array/ndarray/hybrid.hpp
index 223f6ede6..b9e9189db 100644
--- a/include/nmtools/array/ndarray/hybrid.hpp
+++ b/include/nmtools/array/ndarray/hybrid.hpp
@@ -231,7 +231,7 @@ namespace nmtools::array
             // using common_size_t = meta::promote_index_t<size_types...>;
             using promoted_t = meta::promote_index<size_types...>;
             using common_size_t = meta::type_t<promoted_t>;
-            auto indices = meta::make_array_type_t<common_size_t,sizeof...(ns)>{
+            auto indices = nmtools_array<common_size_t,sizeof...(ns)>{
                 static_cast<common_size_t>(ns)...
             };
             static_assert ( dimension == sizeof...(ns)
@@ -252,7 +252,7 @@ namespace nmtools::array
             // using common_size_t = meta::promote_index_t<size_types...>;
             using promoted_t = meta::promote_index<size_types...>;
             using common_size_t = meta::type_t<promoted_t>;
-            auto indices = meta::make_array_type_t<common_size_t,sizeof...(ns)>{
+            auto indices = nmtools_array<common_size_t,sizeof...(ns)>{
                 static_cast<common_size_t>(ns)...
             };
             static_assert ( dimension == sizeof...(ns)
diff --git a/include/nmtools/array/shape.hpp b/include/nmtools/array/shape.hpp
index b5274940f..cd6258929 100644
--- a/include/nmtools/array/shape.hpp
+++ b/include/nmtools/array/shape.hpp
@@ -89,7 +89,7 @@ namespace nmtools::impl
         template <size_t N, typename T>
         constexpr auto repeat(const T& t)
         {
-            auto res = meta::make_array_type_t<T,N>{};
+            auto res = nmtools_array<T,N>{};
             meta::template_for<N>([&](auto index){
                 constexpr auto i = decltype(index)::value;
                 get<i>(res) = t;
@@ -140,7 +140,7 @@ namespace nmtools::impl
             // check for dynamic-shape array but fixed-dimension array
             else if constexpr (meta::nested_array_dim_v<array_t> > 0) {
                 constexpr auto N = meta::nested_array_dim_v<array_t>;
-                auto shape_ = meta::make_array_type_t<size_t,N>{};
+                auto shape_ = nmtools_array<size_t,N>{};
                 meta::template_for<N>([&](auto index){
                     constexpr auto i = decltype(index)::value;
                     // example for 3dim nested dynamic array
diff --git a/include/nmtools/array/view/alias.hpp b/include/nmtools/array/view/alias.hpp
index f44a56b9a..e41a94fc9 100644
--- a/include/nmtools/array/view/alias.hpp
+++ b/include/nmtools/array/view/alias.hpp
@@ -3,6 +3,9 @@
 
 #include "nmtools/meta.hpp"
 #include "nmtools/array/utility/at.hpp"
+#include "nmtools/utility/fwd.hpp"
+#include "nmtools/utility/unwrap.hpp"
+#include "nmtools/array/index/max.hpp"
 #include "nmtools/array/shape.hpp"
 #include "nmtools/array/view/decorator.hpp"
 
@@ -17,6 +20,8 @@ namespace nmtools::view
         using const_reference = const value_type&;
         // array type as required by decorator
         using array_type = resolve_array_type_t<array_t>;
+
+        // TODO: assert id is constant index (or none)
         using id_type = id_t;
 
         static constexpr auto operands_ids = nmtools_tuple{id_type{}};
@@ -39,6 +44,38 @@ namespace nmtools::view
             return nmtools_tuple{id};
         }
 
+        constexpr auto shape() const
+        {
+            if constexpr (meta::is_pointer_v<meta::remove_cvref_t<array_type>>) {
+                return nmtools::shape<true>(*array);
+            } else {
+                return nmtools::shape<true>(array);
+            }
+        }
+
+        constexpr auto dim() const
+        {
+            if constexpr (meta::is_pointer_v<meta::remove_cvref_t<array_type>>) {
+                return nmtools::dim<true>(*array);
+            } else {
+                return nmtools::dim<true>(array);
+            }
+        }
+
+        constexpr auto size() const
+        {
+            if constexpr (meta::is_pointer_v<meta::remove_cvref_t<array_type>>) {
+                return nmtools::size<true>(*array);
+            } else {
+                return nmtools::size<true>(array);
+            }
+        }
+
+        constexpr auto operands() const noexcept
+        {
+            return nmtools_tuple<array_type>{array};
+        } // operands
+
         template <typename...size_types>
         constexpr auto index(size_types...indices) const
         {
@@ -46,6 +83,41 @@ namespace nmtools::view
         } // index
     }; // alias_t
 
+    template <typename array_t, typename id_t>
+    struct alias_t<array_t,id_t,meta::enable_if_t<meta::is_num_v<array_t>>>
+    {
+        using value_type = meta::get_element_type_t<array_t>;
+        using const_reference = const value_type&;
+        // array type as required by decorator
+        using array_type = resolve_array_type_t<array_t>;
+        using id_type = id_t;
+
+        static constexpr auto operands_ids = nmtools_tuple{id_type{}};
+
+        array_type array;
+        id_type id;
+
+        constexpr alias_t(const array_t& array, id_t id)
+            : array(array)
+            , id(id)
+        {}
+
+        constexpr operator value_type() const
+        {
+            return array;
+        }
+
+        constexpr auto attribute() const noexcept
+        {
+            return nmtools_tuple{id};
+        }
+
+        constexpr auto operands() const noexcept
+        {
+            return nmtools_tuple<array_type>{array};
+        } // operands
+    }; // alias
+
     template <typename T, typename id_t>
     struct alias_t<T*, id_t, meta::enable_if_t<meta::is_num_v<T>>>
     {
@@ -95,23 +167,68 @@ namespace nmtools::view
         }
     };
 
+    // TODO: drop none default, make id mandatory
     template <typename array_t, typename id_t=none_t>
     constexpr auto alias(const array_t& array, id_t id=id_t{})
     {
+        // TODO: handle either type
         if constexpr (meta::is_maybe_v<array_t>) {
             using array_type  = meta::get_maybe_type_t<array_t>;
-            using result_type = decorator_t<alias_t,array_type,id_t>;
+            using result_type = decltype(alias(meta::declval<array_type>(),id));
             using return_type = nmtools_maybe<result_type>;
-            if (static_cast<bool>(array)) {
-                return return_type{decorator_t<alias_t,array_type,id_t>{{*array,id}}};
+            return (static_cast<bool>(array)
+                ? return_type{alias(*array,id)}
+                : return_type{meta::Nothing}
+            );
+        } else if constexpr (meta::is_same_view_v<alias_t,array_t> && !is_none_v<id_t>) {
+            // Quick-hack: aliasing an alias will rename
+            const auto& m_array = array.array;
+            if constexpr (meta::is_pointer_v<meta::remove_cvref_t<decltype(m_array)>>) {
+                return alias(*array.array,id);
             } else {
-                return return_type{meta::Nothing};
+                return alias(array.array,id);
             }
+        } else if constexpr (meta::is_view_v<array_t>) {
+            // view is already aliased
+            static_assert( array_t::id_type::value == id_t::value );
+            return array;
         } else {
             return decorator_t<alias_t,array_t,id_t>{{array,id}};
         }
     } // alias
 
+    template <typename...arrays_t>
+    constexpr auto aliased(const arrays_t&...arrays)
+    {
+        auto array_pack = pack_operands(arrays...);
+        constexpr auto N = sizeof...(arrays);
+        constexpr auto initial_ids = meta::template_reduce<N>([&](auto init, auto index){
+            using array_type = decltype(unwrap(at(array_pack,index)));
+            constexpr auto id = get_id_v<meta::remove_cvref_pointer_t<array_type>>;
+            return utility::tuple_append(init,meta::ct_v<(nm_index_t)id>);
+        },nmtools_tuple{});
+        constexpr auto max_id    = index::max(meta::to_value_v<decltype(initial_ids)>);
+        constexpr auto offset_id = max_id + 1; // if max_id: -1, then offset 0
+        constexpr auto final_ids = meta::template_reduce<N>([&](auto init, auto index){
+            constexpr auto id = at(initial_ids,index);
+            constexpr auto final_id = ((id < 0) ? (offset_id + index) : id);
+            return utility::tuple_append(init,meta::ct_v<final_id>);
+        },nmtools_tuple{});
+        auto aliased = meta::template_reduce<N>([&](auto init, auto index){
+            const auto& array = at(array_pack,index);
+            if constexpr (meta::is_pointer_v<meta::remove_cvref_pointer_t<decltype(array)>>) {
+                return append_operands(init,alias(*array,at(final_ids,index)));
+            } else {
+                return append_operands(init,alias(array,at(final_ids,index)));
+            }
+        },nmtools_tuple{});
+        if constexpr (N == 1) {
+            return nmtools::get<0>(aliased);
+        } else {
+            return aliased;
+        }
+    } // aliased
+
     template <typename T, typename id_t=none_t>
     constexpr auto alias(const T* ptr, size_t numel, id_t id=id_t{})
     {
@@ -121,28 +238,36 @@ namespace nmtools::view
 
 namespace nmtools::meta
 {
-    template <typename array_t, typename id_t>
-    struct is_ndarray< view::decorator_t<view::alias_t, array_t, id_t> >
+    template <typename array_t, typename...args_t>
+    struct is_ndarray< view::decorator_t<view::alias_t, array_t, args_t...> >
     {
         static constexpr auto value = is_ndarray_v<array_t>;
     };
 
-    template <typename array_t, typename id_t>
-    struct is_num< view::decorator_t<view::alias_t, array_t, id_t> >
+    template <typename array_t, typename...args_t>
+    struct is_num< view::decorator_t<view::alias_t, array_t, args_t...> >
     {
         static constexpr auto value = is_num_v<array_t>;
     };
 
     // specialization for ptr
-    template <typename array_t, typename id_t>
-    struct is_ndarray< view::decorator_t<view::alias_t, array_t*, id_t> >
+    template <typename array_t, typename...args_t>
+    struct is_ndarray< view::decorator_t<view::alias_t, array_t*, args_t...> >
     {
         static constexpr auto value = is_num_v<array_t>;
     };
 
-    template <typename T, typename id_t>
+    template <typename array_t, typename...args_t>
+    struct get_element_type<
+        view::decorator_t<view::alias_t, array_t, args_t...>
+    >
+    {
+        using type = get_element_type_t<array_t>;
+    };
+
+    template <typename T, typename...args_t>
     struct get_element_type<
-        view::decorator_t<view::alias_t,T*,id_t>
+        view::decorator_t<view::alias_t,T*,args_t...>
     >
     {
         using type = meta::remove_address_space_t<T>;
diff --git a/include/nmtools/array/view/batch_norm.hpp b/include/nmtools/array/view/batch_norm.hpp
index a804fc48d..cae2a5328 100644
--- a/include/nmtools/array/view/batch_norm.hpp
+++ b/include/nmtools/array/view/batch_norm.hpp
@@ -1,7 +1,7 @@
 #ifndef NMTOOLS_ARRAY_VIEW_BATCH_NORM_HPP
 #define NMTOOLS_ARRAY_VIEW_BATCH_NORM_HPP
 
-#include "nmtools/array/view/atleast_3d.hpp"
+#include "nmtools/array/view/atleast_nd.hpp"
 #include "nmtools/array/view/moveaxis.hpp"
 #include "nmtools/array/view/ufuncs/add.hpp"
 #include "nmtools/array/view/ufuncs/multiply.hpp"
@@ -43,13 +43,20 @@ namespace nmtools::view
         auto src_axis = meta::ct_v<-1>;
         auto dst_axis = meta::ct_v<-3>;
 
-        auto weight_ = view::moveaxis(view::atleast_3d(weight),src_axis,dst_axis);
-        auto bias_   = view::moveaxis(view::atleast_3d(bias),src_axis,dst_axis);
-        auto mean_   = view::moveaxis(view::atleast_3d(mean),src_axis,dst_axis);
-        auto var_    = view::moveaxis(view::atleast_3d(var),src_axis,dst_axis);
+        auto aliased  = view::aliased(input,mean,var,weight,bias);
+        auto a_input  = nmtools::get<0>(aliased);
+        auto a_mean   = nmtools::get<1>(aliased);
+        auto a_var    = nmtools::get<2>(aliased);
+        auto a_weight = nmtools::get<3>(aliased);
+        auto a_bias   = nmtools::get<4>(aliased);
+
+        auto weight_ = view::moveaxis(view::atleast_nd(a_weight,meta::ct_v<3>),src_axis,dst_axis);
+        auto bias_   = view::moveaxis(view::atleast_nd(a_bias,meta::ct_v<3>),src_axis,dst_axis);
+        auto mean_   = view::moveaxis(view::atleast_nd(a_mean,meta::ct_v<3>),src_axis,dst_axis);
+        auto var_    = view::moveaxis(view::atleast_nd(a_var,meta::ct_v<3>),src_axis,dst_axis);
         auto stddev_ = view::sqrt(view::add(var_,eps));
 
-        auto subtracted = view::subtract(input,mean_);
+        auto subtracted = view::subtract(a_input,mean_);
         auto divided    = view::divide(subtracted,stddev_);
         auto multiplied = view::multiply(divided,weight_);
         return view::add(multiplied,bias_);
diff --git a/include/nmtools/array/view/broadcast_arrays.hpp b/include/nmtools/array/view/broadcast_arrays.hpp
index 9ecbf9bd6..838bd85c3 100644
--- a/include/nmtools/array/view/broadcast_arrays.hpp
+++ b/include/nmtools/array/view/broadcast_arrays.hpp
@@ -6,6 +6,7 @@
 #include "nmtools/array/shape.hpp"
 #include "nmtools/meta.hpp"
 #include "nmtools/assert.hpp"
+#include "nmtools/array/view/alias.hpp"
 
 namespace nmtools::view
 {
@@ -16,30 +17,36 @@ namespace nmtools::view
      * @param arrays 
      * @return constexpr auto 
      */
-    template <typename...arrays_t>
-    constexpr auto broadcast_arrays(const arrays_t&...arrays)
+    template <template<typename...>typename tuple, typename...arrays_t, auto...Is>
+    constexpr auto aliased_broadcast_arrays(const tuple<arrays_t...>& arrays, meta::index_sequence<Is...>)
     {
         static_assert( sizeof...(arrays_t) >= 2
             , "please provide at least two arrays for broadcast_arrays");
 
-        auto bcast_shape = index::broadcast_shape(shape<true>(arrays)...);
-        auto bcast_size  = index::broadcast_size(bcast_shape,size<true>(arrays)...);
+        auto bcast_shape = index::broadcast_shape(shape<true>(nmtools::get<Is>(arrays))...);
+        auto bcast_size  = index::broadcast_size(bcast_shape,size<true>(nmtools::get<Is>(arrays))...);
         if constexpr (meta::is_maybe_v<decltype(bcast_shape)>) {
             // avoid tuple<maybe<...>...> because not usable in constexpr evaluation
             using bcast_shape_t = meta::get_maybe_type_t<decltype(bcast_shape)>;
             using bcast_size_t  = meta::get_maybe_type_t<decltype(bcast_size)>;
-            using result_t = nmtools_tuple<decltype(unwrap(view::broadcast_to(arrays,meta::declval<bcast_shape_t>(),meta::declval<bcast_size_t>())))...>;
+            using result_t = nmtools_tuple<decltype(unwrap(view::broadcast_to(nmtools::get<Is>(arrays),meta::declval<bcast_shape_t>(),meta::declval<bcast_size_t>())))...>;
             using return_t = nmtools_maybe<result_t>;
-            if (static_cast<bool>(bcast_shape)) {
-                return return_t{nmtools_tuple{unwrap(view::broadcast_to(arrays,*bcast_shape,*bcast_size))...}};
-            } else {
-                return return_t{meta::Nothing};
-            }
+            return (static_cast<bool>(bcast_shape)
+                ? return_t{nmtools_tuple{unwrap(view::broadcast_to(nmtools::get<Is>(arrays),*bcast_shape,*bcast_size))...}}
+                : return_t{meta::Nothing}
+            );
         } else {
             // unwrap to avoid construction of tuple<maybe<...>...> at compile-time
-            return nmtools_tuple{unwrap(view::broadcast_to(arrays,bcast_shape,bcast_size))...};
+            return nmtools_tuple{unwrap(view::broadcast_to(nmtools::get<Is>(arrays),bcast_shape,bcast_size))...};
         }
     } // broadcast_arrays
+
+    template <typename...arrays_t>
+    constexpr auto broadcast_arrays(const arrays_t&...arrays)
+    {
+        auto aliased_pack = view::aliased(arrays...);
+        return aliased_broadcast_arrays(aliased_pack,meta::make_index_sequence_v<sizeof...(arrays_t)>);
+    }
 } // namespace nmtools::view
 
 #endif // NMTOOLS_ARRAY_VIEW_BROADCAST_ARRAYS_HPP
\ No newline at end of file
diff --git a/include/nmtools/array/view/decorator.hpp b/include/nmtools/array/view/decorator.hpp
index 8ba0df6c2..c318c1378 100644
--- a/include/nmtools/array/view/decorator.hpp
+++ b/include/nmtools/array/view/decorator.hpp
@@ -10,6 +10,8 @@
 #include "nmtools/array/utility/apply_at.hpp"
 #include "nmtools/array/index/ref.hpp"
 #include "nmtools/array/index/product.hpp"
+#include "nmtools/array/index/alias.hpp"
+#include "nmtools/array/index/append.hpp"
 
 // TODO: move to shape.hpp
 #ifdef NMTOOLS_ENABLE_BOOST
@@ -24,6 +26,7 @@
 #define NMTOOLS_NO_BASE_ACCESS
 #endif
 
+// TODO: remove
 namespace nmtools::view::detail
 {
     using utility::tuple_append, utility::tuple_cat;
@@ -122,7 +125,35 @@ namespace nmtools::meta
 
     template <template<typename...>typename lhs_t, typename rhs_t>
     constexpr inline auto is_same_view_v = is_same_view<lhs_t,rhs_t>::value;
-}
+
+    template <typename T>
+    struct get_type_id
+    {
+        static constexpr auto value = index::generate_alias(meta::type_name_v<T>);
+    };
+
+    template <typename T>
+    constexpr inline auto get_type_id_v = get_type_id<T>::value;
+
+    template <typename operands_ids_t, typename view_type>
+    constexpr auto generate_view_id(const operands_ids_t&, as_value<view_type>)
+    {
+        // avoid calling to_value_v<tuple<>>
+        constexpr auto id_sequence  = [](){
+            constexpr auto type_id = get_type_id_v<view_type>;
+            constexpr auto B_SIZE  = bounded_size_v<operands_ids_t>;
+            static_assert( !is_fail_v<decltype(B_SIZE)> );
+            if constexpr (B_SIZE == 0) {
+                return nmtools_array{type_id};
+            } else {
+                constexpr auto operands_ids = to_value_v<operands_ids_t>;
+                return index::append(operands_ids,type_id);   
+            }
+        }();
+        constexpr auto node_id = index::generate_alias(id_sequence);
+        return meta::ct_v<node_id>;
+    }
+} // namespace nmtools::meta
 
 namespace nmtools::view
 {
@@ -254,6 +285,7 @@ namespace nmtools::view
      */
     template <template<typename...> typename view_t, typename...Ts>
     struct decorator_t
+        // TODO: remove conditional macro, c++ for opencl temporarily dropped
         #ifndef NMTOOLS_NO_BASE_ACCESS
         : view_t<Ts...>
         #endif // NMTOOLS_NO_BASE_ACCESS
@@ -282,6 +314,20 @@ namespace nmtools::view
 
         static constexpr auto arity = meta::ct_v<meta::len_v<operands_type>>;
 
+        static constexpr auto operands_ids = [](){
+            // TODO: check for unique-ness of operands ids
+            return meta::template_reduce<arity>([&](auto init, auto index){
+                constexpr auto I = decltype(index)::value;
+                using operand_type = meta::remove_cvref_t<meta::at_t<operands_type,I>>;
+                if constexpr (meta::has_id_type_v<operand_type>) {
+                    return utility::tuple_append(init,typename operand_type::id_type{});
+                } else {
+                    return utility::tuple_append(init,index);
+                }
+            }, nmtools_tuple{});
+        }();
+
+        #if 0
         // check for "free"/"unnamed" operands, which we can NOT assign the id freely
         static constexpr auto unnamed_operands = [](){
             return meta::template_reduce<arity>([&](auto init, auto index){
@@ -320,20 +366,24 @@ namespace nmtools::view
                 return meta::as_value_v<meta::ct<(int)arity>>;
             }
         }();
-        using id_type = meta::type_t<decltype(id_vtype)>;
 
-        static constexpr auto operands_ids = [](){
-            // TODO: check for unique-ness of operands ids
-            return meta::template_reduce<arity>([&](auto init, auto index){
-                constexpr auto I = decltype(index)::value;
-                using operand_type = meta::remove_cvref_t<meta::at_t<operands_type,I>>;
-                if constexpr (meta::has_id_type_v<operand_type>) {
-                    return utility::tuple_append(init,typename operand_type::id_type{});
-                } else {
-                    return utility::tuple_append(init,index);
-                }
-            }, nmtools_tuple{});
+        #else
+        static constexpr auto id_vtype = [](){
+            if constexpr (meta::has_id_type_v<view_type>) {
+                using type = typename view_type::id_type;
+                return meta::as_value_v<type>;
+            } else {
+                // constexpr auto type_id = meta::get_type_id_v<view_type>;
+                // constexpr auto id_sequence = index::append(operands_ids,type_id);
+                // constexpr auto id = index::generate_alias(id_sequence);
+                constexpr auto id = meta::generate_view_id(operands_ids,meta::as_value_v<view_type>);
+                using type = meta::ct<meta::remove_cvref_pointer_t<decltype(id)>::value>;
+                return meta::as_value_v<type>;
+            }
         }();
+        #endif
+
+        using id_type = meta::type_t<decltype(id_vtype)>;
 
         static_assert( meta::is_constant_index_v<id_type>
             , "invalid identifier for view type" );
@@ -551,6 +601,28 @@ namespace nmtools::view
 
     }; // decorator_t
 
+    template <typename T>
+    struct get_id
+    {
+        static constexpr auto value = -1;
+    };
+
+    template <template<typename...> typename view_t, typename...Ts>
+    struct get_id<
+        decorator_t<view_t,Ts...>
+    > {
+        static constexpr auto value = decorator_t<view_t,Ts...>::id_type::value;
+    };
+
+    template <typename T>
+    struct get_id<const T> : get_id<T> {};
+
+    template <typename T>
+    struct get_id<T&> : get_id<T> {};
+
+    template <typename T>
+    constexpr inline auto get_id_v = get_id<T>::value;
+
     // TODO: remove
     /**
      * @brief make view given parameters arrays
@@ -639,7 +711,7 @@ namespace nmtools::view
                     if constexpr (is_none_v<type_i> && !meta::is_tuple_v<array_t>) {
                         // init typelist, use tuple for now,
                         // TODO: deduce template template of nocv_array_t if possible
-                        using type = meta::make_tuple_type_t<array_t>;
+                        using type = nmtools_tuple<array_t>;
                         return meta::as_value_v<type>;
                     } else if constexpr (is_none_v<type_i> && meta::is_tuple_v<array_t>) {
                         return meta::as_value_v<array_t>;
@@ -805,7 +877,7 @@ namespace nmtools::view
                 // convert to array type that has value semantics
                 constexpr auto N = meta::len_v<attribute_t>;
                 using elem_t = meta::get_element_type_t<attribute_t>;
-                using type = meta::make_array_type_t<elem_t,N>;
+                using type = nmtools_array<elem_t,N>;
                 return meta::as_value_v<const type>;
             } else /* if constexpr (
                    is_none_v<attribute_t>
diff --git a/include/nmtools/array/view/mean.hpp b/include/nmtools/array/view/mean.hpp
index c860ab450..40f35b106 100644
--- a/include/nmtools/array/view/mean.hpp
+++ b/include/nmtools/array/view/mean.hpp
@@ -122,7 +122,8 @@ namespace nmtools::view
         // but by composing two view (add.reduce + divide) instead
 
         auto shape = ::nmtools::shape<true>(array);
-        auto divisor = detail::mean_divisor(shape,axis);
+        // TODO: error handling
+        auto divisor = detail::mean_divisor(unwrap(shape),axis);
         using divisor_t = decltype(divisor);
         using element_t = meta::get_element_type_t<array_t>;
         auto dtype_  = [&](){
diff --git a/include/nmtools/array/view/moveaxis.hpp b/include/nmtools/array/view/moveaxis.hpp
index 39901ccef..2225a9539 100644
--- a/include/nmtools/array/view/moveaxis.hpp
+++ b/include/nmtools/array/view/moveaxis.hpp
@@ -33,12 +33,7 @@ namespace nmtools::view
     {
         auto shape_ = shape<true>(array);
         auto order  = index::moveaxis_to_transpose(shape_,source,destination);
-        // order should be maybe type
-        using result_t = meta::remove_cvref_t<decltype(view::transpose(array,*order))>;
-        nmtools_assert_prepare_type( return_t, result_t );
-        nmtools_assert( order, "unsupported moveaxis arguments", return_t );
-
-        return return_t{view::transpose(array,*order)};
+        return view::transpose(array,order);
     } // moveaxis
 } // namespace nmtools::view
 
diff --git a/include/nmtools/array/view/ref.hpp b/include/nmtools/array/view/ref.hpp
index 67f72c68a..96ed1357f 100644
--- a/include/nmtools/array/view/ref.hpp
+++ b/include/nmtools/array/view/ref.hpp
@@ -32,7 +32,7 @@ namespace nmtools::view
         constexpr auto identity(size_types...indices)
         {
             using common_size_t = meta::type_t<meta::promote_index<size_types...>>;
-            using indices_t = meta::make_array_type_t<common_size_t,sizeof...(indices)>;
+            using indices_t = nmtools_array<common_size_t,sizeof...(indices)>;
             auto ndindex = indices_t{static_cast<common_size_t>(indices)...};
             return ndindex;
         } // identity
diff --git a/include/nmtools/array/view/ref/initializer_list.hpp b/include/nmtools/array/view/ref/initializer_list.hpp
index c58597086..f101fa236 100644
--- a/include/nmtools/array/view/ref/initializer_list.hpp
+++ b/include/nmtools/array/view/ref/initializer_list.hpp
@@ -115,7 +115,7 @@ namespace nmtools
          */
         constexpr auto shape() const
         {
-            auto shape_ = meta::make_array_type_t<size_t,dim_>{};
+            auto shape_ = nmtools_array<size_t,dim_>{};
             // get the size for each 'nested' list, dimension known at compile time
             // assuming each element on each 'axis' has the same size
             // this techniques is similar with nmtools::shape, but since
diff --git a/include/nmtools/array/view/softmax.hpp b/include/nmtools/array/view/softmax.hpp
index e3f19c931..5b75cde38 100644
--- a/include/nmtools/array/view/softmax.hpp
+++ b/include/nmtools/array/view/softmax.hpp
@@ -1,6 +1,7 @@
 #ifndef NMTOOLS_ARRAY_VIEW_SOFTMAX_HPP
 #define NMTOOLS_ARRAY_VIEW_SOFTMAX_HPP
 
+#include "nmtools/array/view/alias.hpp"
 #include "nmtools/array/view/ufuncs/exp.hpp"
 #include "nmtools/array/view/ufuncs/add.hpp"
 #include "nmtools/array/view/ufuncs/maximum.hpp"
@@ -13,23 +14,25 @@ namespace nmtools::view
      * @brief Applies softmax function along specified axis
      * 
      * @tparam input_t 
-     * @tparam dim_t 
+     * @tparam axis_t 
      * @param input input array
-     * @param dim   axis where softmax to be applied
+     * @param axis  axis where softmax to be applied
      * @return constexpr auto 
      */
-    template <typename input_t, typename dim_t>
-    constexpr auto softmax(const input_t& input, dim_t dim)
+    template <typename input_t, typename axis_t>
+    constexpr auto softmax(const input_t& input, axis_t axis)
     {
-        // following pytorch, only allow index dim (index array dim not allowed)
-        static_assert( meta::is_index_v<dim_t>
-            , "unsupported softmax, expect dim to be index"
+        auto a_input = view::aliased(input);
+        // following pytorch, only allow index axis (index array axis not allowed)
+        static_assert( meta::is_index_v<axis_t>
+            , "unsupported softmax, expect axis to be index"
         );
         // NOTE: this follow https://cs231n.github.io/linear-classify/#softmax for numerical stability
-        auto input_    = view::subtract(input,view::reduce_maximum(input,/*axis=*/dim,/*dtype=*/None,/*initial=*/None,/*keepdims=*/True));
-        auto input_exp = view::exp(input_);
-        auto reduced   = view::reduce_add(input_exp,/*axis=*/dim,/*dtype=*/None,/*initial=*/None,/*keepdims=*/True);
-        return view::divide(input_exp,reduced);
+        auto a = view::reduce_maximum(a_input,axis,/*dtype=*/None,/*initial=*/None,/*keepdims=*/True);
+        auto b = view::subtract(a_input,a);
+        auto c = view::exp(b);
+        auto d = view::reduce_add(c,axis,/*dtype=*/None,/*initial=*/None,/*keepdims=*/True);
+        return view::divide(c,d);
     } // softmax
 } // namespace nmtools::view
 
diff --git a/include/nmtools/array/view/transpose.hpp b/include/nmtools/array/view/transpose.hpp
index dfeabada9..a58c5ce66 100644
--- a/include/nmtools/array/view/transpose.hpp
+++ b/include/nmtools/array/view/transpose.hpp
@@ -66,20 +66,38 @@ namespace nmtools::view
         }
     }; // transpose_t
 
-    template <typename array_t, typename axes_t=none_t>
-    constexpr auto make_transpose(const array_t& array, const axes_t& axes=axes_t{})
+    template <typename shape_t, typename size_t, typename axes_t=none_t>
+    constexpr auto transposer(const shape_t& src_shape, size_t src_size, const axes_t& axes=axes_t{})
     {
-        auto src_shape = shape<true>(array);
-        auto src_size  = size<true>(array);
-        auto indexer = transpose_t{src_shape,axes,src_size};
-        return indexing(array,indexer);
+        if constexpr (meta::is_maybe_v<shape_t>) {
+            // assume when shape is maybe, size is also maybe
+            using result_t = decltype(transposer(unwrap(src_shape),unwrap(src_size),axes));
+            using return_t = meta::conditional_t<meta::is_maybe_v<result_t>,result_t,nmtools_maybe<result_t>>;
+            return (static_cast<bool>(src_shape)
+                ? return_t{transposer(unwrap(src_shape),unwrap(src_size),axes)}
+                : return_t{meta::Nothing}
+            );
+        } else if constexpr (meta::is_maybe_v<axes_t>) {
+            using result_t = decltype(transposer(src_shape,src_size,unwrap(axes)));
+            using return_t = nmtools_maybe<result_t>;
+            return (static_cast<bool>(axes)
+                ? return_t{transposer(src_shape,src_size,*axes)}
+                : return_t{meta::Nothing}
+            );
+        } else {
+            auto indexer = transpose_t{src_shape,axes,src_size};
+            return indexer;
+        }
     }
 
     template <typename array_t, typename axes_t=none_t>
     constexpr auto transpose(const array_t& array, const axes_t& axes=axes_t{})
     {
-        auto f = [](const auto&...args){
-            return make_transpose(args...);
+        auto f = [](const auto& array, const auto& axes){
+            auto src_shape = shape<true>(array);
+            auto src_size  = size<true>(array);
+            auto indexer = transposer(src_shape,src_size,axes);
+            return indexing(array,indexer);
         };
         return lift_indexing(f,array,axes);
     }
@@ -100,7 +118,7 @@ namespace nmtools::array
             auto src_shape = as_static<max_dim>(attribute.src_shape);
             auto axes      = as_static<max_dim>(attribute.axes);
             auto src_size  = as_static<max_dim>(attribute.src_size);
-            return view::transpose_t{src_shape,axes,src_size};
+            return view::transposer(src_shape,axes,src_size);
         }
     };
 } // namespace nmtools::array
diff --git a/include/nmtools/array/view/ufunc.hpp b/include/nmtools/array/view/ufunc.hpp
index 0bd99d369..e638ac6fd 100644
--- a/include/nmtools/array/view/ufunc.hpp
+++ b/include/nmtools/array/view/ufunc.hpp
@@ -5,6 +5,7 @@
 #include "nmtools/array/view/ufunc/reduce.hpp"
 #include "nmtools/array/view/ufunc/accumulate.hpp"
 #include "nmtools/array/view/ufunc/outer.hpp"
+#include "nmtools/array/view/alias.hpp"
 
 namespace nmtools::view
 {
@@ -380,7 +381,7 @@ namespace nmtools::view
         else if constexpr (meta::is_boolean_v<keepdims_t>) {
             using left_t   = decltype(reduce(op,array,axis,dtype,initial,True));
             using right_t  = decltype(reduce(op,array,axis,dtype,initial,False));
-            using either_t = meta::make_either_type_t<left_t,right_t>;
+            using either_t = nmtools_either<left_t,right_t>;
             return (
                 keepdims ?
                   either_t{reduce(op,array,axis,dtype,initial,True)}
diff --git a/include/nmtools/array/view/ufunc/detail.hpp b/include/nmtools/array/view/ufunc/detail.hpp
index cc17a38f7..da642245b 100644
--- a/include/nmtools/array/view/ufunc/detail.hpp
+++ b/include/nmtools/array/view/ufunc/detail.hpp
@@ -42,7 +42,7 @@ namespace nmtools::view::detail
         static_assert( sizeof...(arrays_t) > 0, "nmtools internal error" );
         static constexpr auto vtype = [](){
             // TODO: no need to create full tuple here, use meta::type_list
-            using arrays_type = meta::make_tuple_type_t<arrays_t...>;
+            using arrays_type = nmtools_tuple<arrays_t...>;
             // for view / num type: simply copy (take value),
             // otherwise take reference
             return meta::template_reduce<sizeof...(arrays_t)>([](auto init, auto index){
@@ -51,7 +51,7 @@ namespace nmtools::view::detail
                 using operand_t  = view::resolve_array_type_t<array_t>;
                 using init_t = meta::type_t<decltype(init)>; 
                 if constexpr (meta::is_void_v<init_t>) {
-                    return meta::as_value_v<meta::make_tuple_type_t<operand_t>>;
+                    return meta::as_value_v<nmtools_tuple<operand_t>>;
                 } else {
                     return meta::as_value_v<meta::append_type_t<init_t,operand_t>>;
                 }
diff --git a/include/nmtools/array/view/ufunc/ufunc.hpp b/include/nmtools/array/view/ufunc/ufunc.hpp
index 374ab5da4..21e0eee3c 100644
--- a/include/nmtools/array/view/ufunc/ufunc.hpp
+++ b/include/nmtools/array/view/ufunc/ufunc.hpp
@@ -90,7 +90,7 @@ namespace nmtools::view
     {
         // dont take reference for the array, a Num type should be copied
         // and view type should be cheap to copy
-        using operands_type = meta::make_tuple_type_t<arrays_t...>;
+        using operands_type = nmtools_tuple<arrays_t...>;
         using array_type    = operands_type;
         using op_type       = op_t;
         using result_type   = detail::get_ufunc_result_type_t<op_t,meta::get_element_type_t<arrays_t>...>;
diff --git a/include/nmtools/array/view/ufuncs/power.hpp b/include/nmtools/array/view/ufuncs/power.hpp
index 2ecd8bee3..1f97c4ce4 100644
--- a/include/nmtools/array/view/ufuncs/power.hpp
+++ b/include/nmtools/array/view/ufuncs/power.hpp
@@ -6,6 +6,7 @@
 
 namespace nmtools::view
 {
+    #if 0
     template <
         typename lhs_t=none_t, typename rhs_t=none_t,
         typename res_t=none_t, typename=void>
@@ -15,7 +16,47 @@ namespace nmtools::view
         NMTOOLS_UFUNC_CONSTEXPR
         auto operator()(const T& t, const U& u) const
         {
-            return math::pow(t,u);
+            // TODO: formalize casting rules
+            using common_t [[maybe_unused]] = meta::common_type_t<T,U>;
+            using result_t [[maybe_unused]] = meta::conditional_t<is_none_v<res_t>,common_t,res_t>;
+            auto lhs = [&](){
+                if constexpr (!is_none_v<lhs_t>) {
+                    return static_cast<lhs_t>(t);
+                } else {
+                    return static_cast<result_t>(t);
+                }
+            }();
+            auto rhs = [&](){
+                if constexpr (!is_none_v<rhs_t>) {
+                    return static_cast<rhs_t>(u);
+                } else {
+                    return static_cast<result_t>(u);
+                }
+            }();
+            auto result = math::pow(lhs,rhs);
+            if constexpr (!is_none_v<res_t>) {
+                return static_cast<res_t>(result);
+            } else {
+                return result;
+            }
+        } // operator()
+    }; // power_t
+    #else
+    template <
+        typename lhs_t=none_t, typename rhs_t=none_t,
+        typename res_t=none_t, typename=void>
+    struct power_t
+    {
+        template <typename T, typename U>
+        NMTOOLS_UFUNC_CONSTEXPR
+        auto operator()(const T& t, const U& u) const
+        {
+            if constexpr (meta::is_view_v<T> || meta::is_view_v<U>) {
+                using common_t [[maybe_unused]] = meta::common_type_t<T,U>;
+                return math::pow(static_cast<common_t>(t),static_cast<common_t>(u));
+            } else {
+                return math::pow(t,u);
+            }
         } // operator()
     }; // power_t
 
@@ -49,6 +90,7 @@ namespace nmtools::view
             return math::pow(t,u);
         } // operator()
     }; // power_t
+    #endif
 
     template <typename left_t, typename right_t>
     NMTOOLS_UFUNC_CONSTEXPR
diff --git a/include/nmtools/array/view/var.hpp b/include/nmtools/array/view/var.hpp
index 403c0f08e..669e55d6f 100644
--- a/include/nmtools/array/view/var.hpp
+++ b/include/nmtools/array/view/var.hpp
@@ -1,6 +1,7 @@
 #ifndef NMTOOLS_ARRAY_VIEW_VAR_HPP
 #define NMTOOLS_ARRAY_VIEW_VAR_HPP
 
+#include "nmtools/array/view/alias.hpp"
 #include "nmtools/array/view/ufuncs/fabs.hpp"
 #include "nmtools/array/view/ufuncs/square.hpp"
 #include "nmtools/array/view/ufuncs/subtract.hpp"
@@ -27,21 +28,17 @@ namespace nmtools::view
     template <typename array_t, typename axis_t, typename dtype_t=none_t, typename ddof_t=size_t, typename keepdims_t=meta::false_type>
     constexpr auto var(const array_t& array, const axis_t& axis, dtype_t dtype=dtype_t{}, ddof_t ddof=ddof_t{0}, keepdims_t keepdims=keepdims_t{})
     {
+        auto input = view::aliased(array);
         // must keep dimension to properly subtract
-        auto a = mean(array,axis,dtype,/*keepdims=*/True);
-        auto b = subtract(array, a);
-        auto c = fabs(b);
-        auto d = square(c);
+        auto a = view::mean(input,axis,dtype,/*keepdims=*/True);
+        auto b = view::subtract(input, a);
+        auto c = view::fabs(b);
+        auto d = view::square(c);
         // no reason to start from other initial value
-        auto e = sum(d,axis,dtype,/*initial=*/None,keepdims);
-        // TODO: fix unwrap to handle bounded array
-        #if 0
+        auto e = view::sum(d,axis,dtype,/*initial=*/None,keepdims);
         // TODO: error handling
-        auto N = detail::mean_divisor(::nmtools::shape(unwrap(array)),axis);
-        #else
-        auto N = detail::mean_divisor(::nmtools::shape(array),axis);
-        #endif
-        return divide(e,N-ddof);
+        auto N = detail::mean_divisor(::nmtools::shape(unwrap(input)),axis);
+        return view::divide(e,N-ddof);
     } // var
 } // namespace nmtools::view
 
diff --git a/include/nmtools/utility/ct_digraph.hpp b/include/nmtools/utility/ct_digraph.hpp
index b03f88d62..50c6151ab 100644
--- a/include/nmtools/utility/ct_digraph.hpp
+++ b/include/nmtools/utility/ct_digraph.hpp
@@ -2,6 +2,7 @@
 #define NMTOOLS_UTILITY_CT_DIGRAPH_HPP
 
 #include "nmtools/meta.hpp"
+#include "nmtools/array/at.hpp"
 #include "nmtools/utility/ct_map.hpp"
 
 namespace nmtools::utility
@@ -54,19 +55,39 @@ namespace nmtools::utility
         constexpr auto add_edge(from_t from, to_t to) const noexcept
         {
             auto edges = digraph.at(from);
-            auto new_edges = tuple_append(edges,to);
-            auto new_digraph = digraph.update(from,/*edges*/new_edges);
-            using new_digraph_type = decltype(new_digraph);
-            using new_node_data_type = decltype(node_data);
-            using new_ct_digraph_type = ct_digraph<
-                meta::remove_cvref_t<typename new_digraph_type::keys_type>
-                , meta::remove_cvref_t<typename new_digraph_type::values_type>
-                , meta::remove_cvref_t<typename new_node_data_type::values_type>
-            >;
-            return new_ct_digraph_type(
-                new_digraph
-                , node_data
-            );
+            // avoid duplication
+            auto contains = [](auto tuple, auto key){
+                constexpr auto N = meta::len_v<decltype(tuple)>;
+                constexpr auto KEY = meta::to_value_v<decltype(key)>;
+                return meta::template_reduce<N>([&](auto init, auto index){
+                    auto element = nmtools::at(tuple,index);
+                    constexpr auto ELEMENT = meta::to_value_v<decltype(element)>;
+                    if constexpr (ELEMENT == KEY) {
+                        return meta::true_type{};
+                    } else {
+                        return init;
+                    }
+                }, meta::false_type{});
+            };
+            auto has_key = contains(edges,to);
+            constexpr auto HAS_KEY = meta::to_value_v<decltype(has_key)>;
+            if constexpr (HAS_KEY) {
+                return *this;
+            } else {
+                auto new_edges = tuple_append(edges,to);
+                auto new_digraph = digraph.update(from,/*edges*/new_edges);
+                using new_digraph_type = decltype(new_digraph);
+                using new_node_data_type = decltype(node_data);
+                using new_ct_digraph_type = ct_digraph<
+                    meta::remove_cvref_t<typename new_digraph_type::keys_type>
+                    , meta::remove_cvref_t<typename new_digraph_type::values_type>
+                    , meta::remove_cvref_t<typename new_node_data_type::values_type>
+                >;
+                return new_ct_digraph_type(
+                    new_digraph
+                    , node_data
+                );
+            }
         }
 
         constexpr auto nodes() const noexcept
@@ -103,7 +124,7 @@ namespace nmtools::utility
         {
             return digraph.at(key);
         }
-    };
+    }; // ct_digraph
 
     template <typename nodes_t, typename edges_t, typename node_data_t>
     ct_digraph(const ct_map<nodes_t,edges_t>&, const ct_map<nodes_t,node_data_t>&) -> ct_digraph<nodes_t,edges_t,node_data_t>;
diff --git a/include/nmtools/utility/fwd.hpp b/include/nmtools/utility/fwd.hpp
index 243a1eb9f..cbd780365 100644
--- a/include/nmtools/utility/fwd.hpp
+++ b/include/nmtools/utility/fwd.hpp
@@ -222,7 +222,7 @@ namespace nmtools
     }
 
     template <typename T, template<typename...>typename tuple, typename...Ts, auto...Is>
-    constexpr auto append_operands(const tuple<Ts...>& ts, const T& t)
+    constexpr auto append_operands(const tuple<Ts...>& ts, const T& t, meta::index_sequence<Is...>)
     {
         using result_t = tuple<
               meta::fwd_operand_t<meta::remove_cvref_t<Ts>>...
diff --git a/include/nmtools/utility/unwrap.hpp b/include/nmtools/utility/unwrap.hpp
index 2b9762779..96bb7e4dc 100644
--- a/include/nmtools/utility/unwrap.hpp
+++ b/include/nmtools/utility/unwrap.hpp
@@ -29,7 +29,7 @@ namespace nmtools
         }
     }
 
-    #if 0
+    #if 1
     template <typename T, auto N>
     constexpr auto unwrap(const T(&t)[N])
         -> const T(&)[N]