diff --git a/cmake/oneflow.cmake b/cmake/oneflow.cmake
index 1763cbb3bec..5806d7205e4 100644
--- a/cmake/oneflow.cmake
+++ b/cmake/oneflow.cmake
@@ -174,7 +174,7 @@ foreach(oneflow_single_file ${oneflow_all_src})
     continue()
   endif()
 
-  if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user|xrt)/.*\\.(h|hpp)$")
+  if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user|xrt|maybe)/.*\\.(h|hpp)$")
     if((NOT RPC_BACKEND MATCHES "GRPC") AND "${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/core/control/.*")
       # skip if GRPC not enabled
     elseif(APPLE AND "${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/core/comm_network/(epoll|ibverbs)/.*")
@@ -228,8 +228,8 @@ foreach(oneflow_single_file ${oneflow_all_src})
 
   endif(BUILD_PYTHON)
 
-  if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user|xrt)/.*\\.cpp$")
-    if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user|xrt)/.*_test\\.cpp$")
+  if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user|xrt|maybe)/.*\\.cpp$")
+    if("${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/(core|user|xrt|maybe)/.*_test\\.cpp$")
       # test file
       list(APPEND of_all_test_cc ${oneflow_single_file})
     elseif(APPLE AND "${oneflow_single_file}" MATCHES "^${PROJECT_SOURCE_DIR}/oneflow/core/comm_network/(epoll|ibverbs)/.*")
diff --git a/oneflow/maybe/config.h b/oneflow/maybe/config.h
new file mode 100644
index 00000000000..6d4562f7c93
--- /dev/null
+++ b/oneflow/maybe/config.h
@@ -0,0 +1,52 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef ONEFLOW_MAYBE_CONFIG_H_
+#define ONEFLOW_MAYBE_CONFIG_H_
+
+#include <cassert>
+
+// pre-define it if you use a logging library like glog
+#ifndef OF_MAYBE_ASSERT
+#define OF_MAYBE_ASSERT(_cond_) assert(_cond_)
+#endif
+
+// ASSERT_EQ is different from ASSERT in logging / testing framework
+// pre-define it if you use a logging library like glog
+#ifndef OF_MAYBE_ASSERT_EQ
+#define OF_MAYBE_ASSERT_EQ(_lhs_, _rhs_) OF_MAYBE_ASSERT(_lhs_ == _rhs_)
+#endif
+
+#if __GNUC__ >= 7
+#define OF_MAYBE_HAS_IS_AGGREGATE
+// in old versions of clang, __has_builtin(__is_aggregate) returns false
+#elif __clang__
+#if !__is_identifier(__is_aggregate)
+#define OF_MAYBE_HAS_IS_AGGREGATE
+#endif
+#elif __has_builtin(__is_aggregate)
+#define OF_MAYBE_HAS_IS_AGGREGATE
+#endif
+
+#ifdef OF_MAYBE_HAS_IS_AGGREGATE
+#define OF_MAYBE_IS_AGGREGATE(...) __is_aggregate(__VA_ARGS__)
+#else
+// decay to POD checking if no such builtin (because implementing __is_aggregate need reflection)
+#define OF_MAYBE_IS_AGGREGATE(...) \
+  std::is_standard_layout<__VA_ARGS__>::value&& std::is_trivial<__VA_ARGS__>::value
+#endif
+
+#endif  // ONEFLOW_MAYBE_CONFIG_H_
diff --git a/oneflow/maybe/type_traits.h b/oneflow/maybe/type_traits.h
new file mode 100644
index 00000000000..29bd52543b4
--- /dev/null
+++ b/oneflow/maybe/type_traits.h
@@ -0,0 +1,152 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef ONEFLOW_MAYBE_TYPE_TRAITS_H_
+#define ONEFLOW_MAYBE_TYPE_TRAITS_H_
+
+#include <cstddef>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+#include "config.h"
+
+namespace oneflow {
+
+namespace maybe {
+
+// in this file, xxxS represents struct of xxx
+// for implementant aspect, xxx is an alias of xxxS::type or xxxS::value
+
+template<bool B>
+using BoolConstant = std::integral_constant<bool, B>;
+
+template<std::size_t I>
+using IndexConstant = std::integral_constant<std::size_t, I>;
+
+constexpr std::size_t NPos = -1;
+
+template<typename...>
+struct ConjS : std::true_type {};
+template<typename B1>
+struct ConjS<B1> : B1 {};
+template<typename B1, typename... Bn>
+struct ConjS<B1, Bn...> : std::conditional_t<bool(B1::value), ConjS<Bn...>, B1> {};
+
+template<typename... B>
+constexpr bool Conj = ConjS<B...>::value;
+
+template<typename...>
+struct DisjS : std::false_type {};
+template<typename B1>
+struct DisjS<B1> : B1 {};
+template<typename B1, typename... Bn>
+struct DisjS<B1, Bn...> : std::conditional_t<bool(B1::value), B1, DisjS<Bn...>> {};
+
+template<typename... B>
+constexpr bool Disj = DisjS<B...>::value;
+
+template<typename B>
+struct NegS : BoolConstant<!bool(B::value)> {};
+
+template<typename B>
+constexpr bool Neg = NegS<B>::value;
+
+struct TypeNotFound;
+
+// return TypeNotFound while out of range
+template<std::size_t I, typename... Tn>
+struct TypeGetS;
+
+template<std::size_t I, typename T1, typename... Tn>
+struct TypeGetS<I, T1, Tn...> : TypeGetS<I - 1, Tn...> {};
+
+template<typename T1, typename... Tn>
+struct TypeGetS<0, T1, Tn...> {
+  using type = T1;
+};
+
+template<std::size_t N>
+struct TypeGetS<N> {
+  using type = TypeNotFound;
+};
+
+template<std::size_t I, typename... Ts>
+using TypeGet = typename TypeGetS<I, Ts...>::type;
+
+// return NPos (-1) while not found
+template<std::size_t I, typename T, typename... Tn>
+struct IndexGetFromS;
+
+template<std::size_t I, typename T, typename T1, typename... Tn>
+struct IndexGetFromS<I, T, T1, Tn...> : IndexGetFromS<I + 1, T, Tn...> {};
+
+template<std::size_t I, typename T1, typename... Tn>
+struct IndexGetFromS<I, T1, T1, Tn...> : IndexConstant<I> {};
+
+template<std::size_t I, typename T>
+struct IndexGetFromS<I, T> : IndexConstant<NPos> {};
+
+template<typename T, typename... Ts>
+constexpr auto IndexGet = IndexGetFromS<0, T, Ts...>::value;
+
+template<typename T, typename... Ts>
+constexpr auto TypeIn = IndexGet<T, Ts...> != NPos;
+
+template<typename T, typename... Ts>
+using TypeInS = BoolConstant<TypeIn<T, Ts...>>;
+
+template<typename T>
+struct RemoveCVRefS {
+  using type = std::remove_cv_t<std::remove_reference_t<T>>;
+};
+
+template<typename T>
+using RemoveCVRef = typename RemoveCVRefS<T>::type;
+
+template<typename T, typename... Ts>
+struct IsDifferentTypesS : BoolConstant<!TypeIn<T, Ts...> && IsDifferentTypesS<Ts...>::value> {};
+
+template<typename T>
+struct IsDifferentTypesS<T> : std::true_type {};
+
+template<typename T, typename... Ts>
+constexpr auto IsDifferentTypes = IsDifferentTypesS<T, Ts...>::value;
+
+template<typename T>
+struct ConstRefExceptVoidS {
+  using type = const T&;
+};
+
+template<>
+struct ConstRefExceptVoidS<void> {
+  using type = void;
+};
+
+template<typename T>
+using ConstRefExceptVoid = typename ConstRefExceptVoidS<T>::type;
+
+template<typename T>
+using RemoveRValRef =
+    std::conditional_t<std::is_rvalue_reference<T>::value, std::remove_reference_t<T>, T>;
+
+template<typename T>
+constexpr bool IsAggregate = OF_MAYBE_IS_AGGREGATE(T);
+
+}  // namespace maybe
+
+}  // namespace oneflow
+
+#endif  // ONEFLOW_MAYBE_TYPE_TRAITS_H_
diff --git a/oneflow/maybe/type_traits_test.cpp b/oneflow/maybe/type_traits_test.cpp
new file mode 100644
index 00000000000..35b6e8f7c46
--- /dev/null
+++ b/oneflow/maybe/type_traits_test.cpp
@@ -0,0 +1,64 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <gtest/gtest.h>
+#include <type_traits>
+#include "oneflow/maybe/type_traits.h"
+
+using namespace oneflow::maybe;
+
+TEST(TypeTraits, Basics) {
+  static_assert(Conj<std::true_type, std::true_type>, "");
+  static_assert(!Conj<std::false_type, std::true_type>, "");
+  static_assert(!Conj<std::true_type, std::false_type>, "");
+  static_assert(!Conj<std::false_type, std::false_type>, "");
+  static_assert(!Conj<std::true_type, std::true_type, std::false_type>, "");
+
+  static_assert(Disj<std::true_type, std::true_type>, "");
+  static_assert(Disj<std::false_type, std::true_type>, "");
+  static_assert(Disj<std::true_type, std::false_type>, "");
+  static_assert(!Disj<std::false_type, std::false_type>, "");
+  static_assert(Disj<std::true_type, std::true_type, std::false_type>, "");
+  static_assert(!Disj<std::false_type, std::false_type, std::false_type>, "");
+
+  static_assert(std::is_same<TypeGet<0, int>, int>::value, "");
+  static_assert(std::is_same<TypeGet<0, int, float>, int>::value, "");
+  static_assert(std::is_same<TypeGet<1, int, float>, float>::value, "");
+  static_assert(std::is_same<TypeGet<2, int, float, bool, int>, bool>::value, "");
+  static_assert(std::is_same<TypeGet<2, int, int>, TypeNotFound>::value, "");
+  static_assert(std::is_same<TypeGet<2, int, int, float>, float>::value, "");
+  static_assert(std::is_same<TypeGet<2, int, int, float, int>, float>::value, "");
+  static_assert(std::is_same<TypeGet<2>, TypeNotFound>::value, "");
+
+  static_assert(IndexGet<int, int> == 0, "");
+  static_assert(IndexGet<int, float> == NPos, "");
+  static_assert(IndexGet<int, int, int> == 0, "");
+  static_assert(IndexGet<int, float, int> == 1, "");
+  static_assert(IndexGet<bool, int, float, int, bool, bool, int> == 3, "");
+  static_assert(IndexGet<int> == NPos, "");
+
+  static_assert(!TypeIn<int>, "");
+  static_assert(TypeIn<int, int>, "");
+  static_assert(TypeIn<int, float, int>, "");
+  static_assert(!TypeIn<int, float, float, bool>, "");
+  static_assert(TypeIn<int, float, bool, int, float>, "");
+  static_assert(TypeIn<bool, float, float, bool>, "");
+
+  static_assert(IsDifferentTypes<int, float, bool>, "");
+  static_assert(!IsDifferentTypes<int, float, int, bool>, "");
+  static_assert(IsDifferentTypes<int>, "");
+  static_assert(!IsDifferentTypes<int, int>, "");
+}
diff --git a/oneflow/maybe/utility.h b/oneflow/maybe/utility.h
new file mode 100644
index 00000000000..c62833a4cde
--- /dev/null
+++ b/oneflow/maybe/utility.h
@@ -0,0 +1,89 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef ONEFLOW_MAYBE_UTILITY_H_
+#define ONEFLOW_MAYBE_UTILITY_H_
+
+#include <cstddef>
+#include <functional>
+
+namespace oneflow {
+
+namespace maybe {
+
+// unlike std::nullopt in c++17, the NullOptType is used in both Variant and Optional,
+// so it is more like both std::nullopt and std::monostate (in c++17),
+// the advantage of this unification is a more unifed experience,
+// i.e. `return NullOpt` can be used in both Variant and Optional context
+struct NullOptType {
+  explicit constexpr NullOptType() = default;
+
+  bool operator==(NullOptType) const { return true; }
+  bool operator!=(NullOptType) const { return false; }
+  bool operator<(NullOptType) const { return false; }
+  bool operator>(NullOptType) const { return false; }
+  bool operator<=(NullOptType) const { return true; }
+  bool operator>=(NullOptType) const { return true; }
+};
+
+constexpr const std::size_t NullOptHash = -3333;
+
+constexpr NullOptType NullOpt{};
+
+struct InPlaceT {
+  explicit constexpr InPlaceT() = default;
+};
+
+constexpr InPlaceT InPlace;
+
+template<typename T>
+struct InPlaceTypeT {
+  explicit constexpr InPlaceTypeT() = default;
+};
+
+template<typename T>
+constexpr InPlaceTypeT<T> InPlaceType;
+
+template<std::size_t I>
+struct InPlaceIndexT {
+  explicit constexpr InPlaceIndexT() = default;
+};
+
+template<std::size_t I>
+constexpr InPlaceIndexT<I> InPlaceIndex;
+
+template<class T>
+constexpr void HashCombine(std::size_t& seed, const T& v) {
+  std::hash<T> hasher;
+  seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+}
+
+}  // namespace maybe
+
+}  // namespace oneflow
+
+namespace std {
+
+template<>
+struct hash<oneflow::maybe::NullOptType> {
+  size_t operator()(oneflow::maybe::NullOptType) const noexcept {
+    return oneflow::maybe::NullOptHash;
+  }
+};
+
+}  // namespace std
+
+#endif  // ONEFLOW_MAYBE_UTILITY_H_
diff --git a/oneflow/maybe/utility_test.cpp b/oneflow/maybe/utility_test.cpp
new file mode 100644
index 00000000000..7520e1b6eea
--- /dev/null
+++ b/oneflow/maybe/utility_test.cpp
@@ -0,0 +1,36 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <gtest/gtest.h>
+#include "oneflow/maybe/utility.h"
+
+using namespace oneflow::maybe;
+
+TEST(Utility, NullOpt) {
+  NullOptType a, b(NullOpt), c(a);  // NOLINT
+
+  a = NullOpt;
+
+  a = b;
+
+  ASSERT_EQ(a, NullOptType{});
+  ASSERT_EQ(std::hash<NullOptType>()(a), std::hash<NullOptType>()(NullOpt));
+  ASSERT_EQ(NullOpt, a);
+  ASSERT_GE(NullOpt, a);
+  ASSERT_LE(NullOpt, a);
+  ASSERT_FALSE(NullOpt < a);
+  ASSERT_FALSE(NullOpt > a);
+}
diff --git a/oneflow/maybe/variant.h b/oneflow/maybe/variant.h
new file mode 100644
index 00000000000..413ed2f559f
--- /dev/null
+++ b/oneflow/maybe/variant.h
@@ -0,0 +1,454 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#ifndef ONEFLOW_MAYBE_VARIANT_H_
+#define ONEFLOW_MAYBE_VARIANT_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#include <utility>
+#include <functional>
+#include <iostream>
+
+#include "oneflow/maybe/utility.h"
+#include "oneflow/maybe/type_traits.h"
+
+namespace oneflow {
+
+namespace maybe {
+
+template<typename... Ts>
+struct Variant;
+
+namespace details {
+
+// there are generally two ways to implement visit (like std::visit in c++17)
+// 1. O(N) or O(log N), to iterate for all types or do a binary search on type index recursively
+// 2. O(1), to store an static (storage duration) array of function pointers for every (Variant, F)
+// where N = Variant<T...>::Num, and normally (in most cases) within the range [2, 5]
+// the 2nd method is required in std::visit(f, x...) while sizeof...(x) == 1
+// but weakness of the 2nd method is that compilers usually cannot efficiently optimize these
+// function pointers (compared to trivial recursion, which is easy to do optimization, and also
+// friendly to CPU cache) here we implement visit via the first method:
+// 1. for 2 <= N < 4, we use the O(N) algorithm (TrivialRecursiveVisitImpl) for better optimization
+// 2. for N >= 4, we use the O(log N) algorithm (BinarySearchVisitImpl) for less recursion rounds
+
+struct VariantPrivateScope {
+  template<typename R, typename F, typename V>
+  static R TrivialRecursiveVisitImpl(F&& f, V&& v, InPlaceIndexT<RemoveCVRef<V>::Num - 1>) {
+    // assume v.Index() == N - 1 now
+    return static_cast<R>(
+        std::forward<F>(f)(std::forward<V>(v).template Value<RemoveCVRef<V>::Num - 1>()));
+  }
+
+  template<typename R, std::size_t I, typename F, typename V,
+           std::enable_if_t<(I < RemoveCVRef<V>::Num - 1), int> = 0>
+  static R TrivialRecursiveVisitImpl(F&& f, V&& v, InPlaceIndexT<I>) {
+    if (v.Index() == I) {
+      return static_cast<R>(std::forward<F>(f)(std::forward<V>(v).template Value<I>()));
+    }
+
+    return TrivialRecursiveVisitImpl<R>(std::forward<F>(f), std::forward<V>(v),
+                                        InPlaceIndex<I + 1>);
+  }
+
+  template<typename R, std::size_t I, typename F, typename V,
+           std::enable_if_t<(I < RemoveCVRef<V>::Num), int> = 0>
+  static R BinarySearchVisitImpl(F&& f, V&& v, InPlaceIndexT<I>, InPlaceIndexT<I>) {
+    return static_cast<R>(std::forward<F>(f)(std::forward<V>(v).template Value<I>()));
+  }
+
+  template<typename R, std::size_t I, typename F, typename V,
+           std::enable_if_t<(I + 1 < RemoveCVRef<V>::Num), int> = 0>
+  static R BinarySearchVisitImpl(F&& f, V&& v, InPlaceIndexT<I>, InPlaceIndexT<I + 1>) {
+    constexpr std::size_t M = (I + I + 1) / 2;
+    constexpr std::size_t N = (M == I) ? I + 1 : I;
+
+    if (v.Index() == M) {
+      return static_cast<R>(std::forward<F>(f)(std::forward<V>(v).template Value<M>()));
+    } else {
+      return static_cast<R>(std::forward<F>(f)(std::forward<V>(v).template Value<N>()));
+    }
+  }
+
+  template<typename R, std::size_t L, std::size_t U, typename F, typename V,
+           std::enable_if_t<(L + 1 < U) && (U < RemoveCVRef<V>::Num), int> = 0>
+  static R BinarySearchVisitImpl(F&& f, V&& v, InPlaceIndexT<L>, InPlaceIndexT<U>) {
+    constexpr std::size_t M = (L + U) / 2;
+
+    if (v.Index() < M) {
+      return BinarySearchVisitImpl<R>(std::forward<F>(f), std::forward<V>(v), InPlaceIndex<L>,
+                                      InPlaceIndex<M - 1>);
+    } else if (v.Index() > M) {
+      return BinarySearchVisitImpl<R>(std::forward<F>(f), std::forward<V>(v), InPlaceIndex<M + 1>,
+                                      InPlaceIndex<U>);
+    } else {
+      return static_cast<R>(std::forward<F>(f)(std::forward<V>(v).template Value<M>()));
+    }
+  }
+
+  template<typename R, typename F, typename V,
+           std::enable_if_t<RemoveCVRef<V>::Num<4, int> = 0> static R VisitImpl(F&& f, V&& v) {
+    return TrivialRecursiveVisitImpl<R>(std::forward<F>(f), std::forward<V>(v), InPlaceIndex<0>);
+  }
+
+  template<typename R, typename F, typename V, std::enable_if_t<RemoveCVRef<V>::Num >= 4, int> = 0>
+  static R VisitImpl(F&& f, V&& v) {
+    return BinarySearchVisitImpl<R>(std::forward<F>(f), std::forward<V>(v), InPlaceIndex<0>,
+                                    InPlaceIndex<RemoveCVRef<V>::Num - 1>);
+  }
+};
+
+struct AutoDeducedResultType;
+
+template<typename R, typename F, typename... Ts>
+struct VisitResultS {
+  using type = R;
+};
+
+template<typename F, typename... Ts>
+struct VisitResultS<AutoDeducedResultType, F, Ts...> {
+  using type = std::common_type_t<decltype(std::declval<F>()(std::declval<Ts>()))...>;
+};
+
+template<typename R, typename F, typename... Ts>
+using VisitResult = typename VisitResultS<R, F, Ts...>::type;
+
+}  // namespace details
+
+// preconditions: template type arguments must be no less than 2 different type
+// and without reference and cv qualifiers
+// this Variant DO NOT guarantee exception safty
+template<typename... Ts>
+struct Variant {  // NOLINT(cppcoreguidelines-pro-type-member-init)
+ public:
+  static_assert(sizeof...(Ts) > 1, "expected more than two types");
+  static_assert(Conj<NegS<std::is_reference<Ts>>...>, "reference types are not allowed here");
+  static_assert(Conj<NegS<DisjS<std::is_const<Ts>, std::is_volatile<Ts>>>...>,
+                "cv qualifiers are not allowed here");
+  // important precondition to optimize Visit via binary search
+  static_assert(IsDifferentTypes<Ts...>, "expected all of different types");
+
+  static constexpr std::size_t Num = sizeof...(Ts);
+
+  template<typename T>
+  static constexpr auto IndexOfType = IndexGet<T, Ts...>;
+
+  template<typename T>
+  static constexpr bool HasType = TypeIn<T, Ts...>;
+
+  template<std::size_t I>
+  using TypeByIndex = TypeGet<I, Ts...>;
+
+  template<typename T = TypeByIndex<0>,
+           std::enable_if_t<std::is_default_constructible<T>::value, int> = 0>
+  Variant() {  // NOLINT(cppcoreguidelines-pro-type-member-init)
+    Construct<0>();
+  }
+
+  // unlike std::variant, we only accept exact types to avoid wrong construction
+  template<typename T, std::enable_if_t<HasType<RemoveCVRef<T>>, int> = 0>
+  Variant(T&& v) {  // NOLINT(cppcoreguidelines-pro-type-member-init, google-explicit-constructor)
+    Construct<RemoveCVRef<T>>(std::forward<T>(v));
+  }
+
+  template<typename T, typename... Args, std::enable_if_t<HasType<RemoveCVRef<T>>, int> = 0>
+  explicit Variant(InPlaceTypeT<T>,  // NOLINT(cppcoreguidelines-pro-type-member-init)
+                   Args&&... args) {
+    Construct<RemoveCVRef<T>>(std::forward<Args>(args)...);
+  }
+
+  template<std::size_t I, typename... Args, std::enable_if_t<(I < Num), int> = 0>
+  explicit Variant(InPlaceIndexT<I>,  // NOLINT(cppcoreguidelines-pro-type-member-init)
+                   Args&&... args) {
+    Construct<I>(std::forward<Args>(args)...);
+  }
+
+  template<typename R = details::AutoDeducedResultType, typename F>
+  decltype(auto) Visit(F&& f) & {
+    using Result = details::VisitResult<R, F, Ts&...>;
+    return details::VariantPrivateScope::VisitImpl<Result>(std::forward<F>(f), *this);
+  }
+
+  template<typename R = details::AutoDeducedResultType, typename F>
+  decltype(auto) Visit(F&& f) && {
+    using Result = details::VisitResult<R, F, Ts&&...>;
+    return details::VariantPrivateScope::VisitImpl<Result>(std::forward<F>(f), std::move(*this));
+  }
+
+  template<typename R = details::AutoDeducedResultType, typename F>
+  decltype(auto) Visit(F&& f) const& {
+    using Result = details::VisitResult<R, F, const Ts&...>;
+    return details::VariantPrivateScope::VisitImpl<Result>(std::forward<F>(f), *this);
+  }
+
+  Variant(const Variant& v) {  // NOLINT(cppcoreguidelines-pro-type-member-init)
+    CopyConstruct(v);
+  }
+
+  Variant(Variant&& v) noexcept {  // NOLINT(cppcoreguidelines-pro-type-member-init)
+    CopyConstruct(std::move(v));
+  }
+
+  template<typename T, std::enable_if_t<HasType<RemoveCVRef<T>>, int> = 0>
+  Variant& operator=(T&& v) {
+    using Type = RemoveCVRef<T>;
+
+    Emplace<Type>(std::forward<T>(v));
+
+    return *this;
+  }
+
+  Variant& operator=(const Variant& v) {
+    Copy(v);
+    return *this;
+  }
+
+  Variant& operator=(Variant&& v) noexcept {
+    Copy(std::move(v));
+    return *this;
+  }
+
+  std::size_t Index() const { return type_index_; }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  bool Is() const {
+    return type_index_ == IndexOfType<T>;
+  }
+
+  ~Variant() { Destory(); }
+
+  bool operator==(const Variant& v) const {
+    if (type_index_ != v.type_index_) return false;
+
+    return v.Visit(
+        [this](const auto& elem) { return elem == Value<RemoveCVRef<decltype(elem)>>(); });
+  }
+
+  bool operator!=(const Variant& v) const { return !operator==(v); }
+
+  bool operator<(const Variant& v) const {
+    if (type_index_ < v.type_index_) return true;
+    if (type_index_ > v.type_index_) return false;
+
+    return v.Visit(
+        [this](const auto& elem) { return Value<RemoveCVRef<decltype(elem)>>() < elem; });
+  }
+
+  bool operator>=(const Variant& v) const { return !(*this < v); }
+
+  bool operator>(const Variant& v) const {
+    if (type_index_ > v.type_index_) return true;
+    if (type_index_ < v.type_index_) return false;
+
+    return v.Visit(
+        [this](const auto& elem) { return Value<RemoveCVRef<decltype(elem)>>() > elem; });
+  }
+
+  bool operator<=(const Variant& v) const { return !(*this > v); }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  friend bool operator==(const Variant& v, const T& x) {
+    if (v.type_index_ != IndexOfType<T>) return false;
+
+    return v.Value<T>() == x;
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  friend bool operator!=(const Variant& v, const T& x) {
+    return !(v == x);
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  friend bool operator==(const T& x, const Variant& v) {
+    return v == x;
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  friend bool operator!=(const T& x, const Variant& v) {
+    return !(v == x);
+  }
+
+  template<typename T, typename... Args>
+  T& Emplace(Args&&... args) {
+    if (Is<T>()) {
+      return Value<T>() = T(std::forward<Args>(args)...);
+    } else {
+      Destory();
+      Construct<T>(std::forward<Args>(args)...);
+      return Value<T>();
+    }
+  }
+
+  template<std::size_t I, typename... Args>
+  decltype(auto) Emplace(Args&&... args) {
+    return Emplace<TypeByIndex<I>>(std::forward<Args>(args)...);
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  T& Get() & {
+    OF_MAYBE_ASSERT_EQ(Index(), IndexOfType<T>);
+    return Value<T>();
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  T&& Get() && {
+    OF_MAYBE_ASSERT_EQ(Index(), IndexOfType<T>);
+    return std::move(*this).template Value<T>();
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  const T& Get() const& {
+    OF_MAYBE_ASSERT_EQ(Index(), IndexOfType<T>);
+    return Value<T>();
+  }
+
+  template<std::size_t I, std::enable_if_t<(I < Num), int> = 0>
+  TypeByIndex<I>& Get() & {
+    OF_MAYBE_ASSERT_EQ(Index(), I);
+    return Value<I>();
+  }
+
+  template<std::size_t I, std::enable_if_t<(I < Num), int> = 0>
+  TypeByIndex<I>&& Get() && {
+    OF_MAYBE_ASSERT_EQ(Index(), I);
+    return std::move(*this).template Value<I>();
+  }
+
+  template<std::size_t I, std::enable_if_t<(I < Num), int> = 0>
+  const TypeByIndex<I>& Get() const& {
+    OF_MAYBE_ASSERT_EQ(Index(), I);
+    return Value<I>();
+  }
+
+ protected:
+  // use std::launder while updating to c++17
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  T& Value() & {
+    return *reinterpret_cast<T*>(storage_);
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  T&& Value() && {
+    return std::move(*reinterpret_cast<T*>(storage_));
+  }
+
+  template<typename T, std::enable_if_t<HasType<T>, int> = 0>
+  const T& Value() const& {
+    return *reinterpret_cast<const T*>(storage_);
+  }
+
+  template<std::size_t I, std::enable_if_t<(I < Num), int> = 0>
+  TypeByIndex<I>& Value() & {
+    return *reinterpret_cast<TypeByIndex<I>*>(storage_);
+  }
+
+  template<std::size_t I, std::enable_if_t<(I < Num), int> = 0>
+  TypeByIndex<I>&& Value() && {
+    return std::move(*reinterpret_cast<TypeByIndex<I>*>(storage_));
+  }
+
+  template<std::size_t I, std::enable_if_t<(I < Num), int> = 0>
+  const TypeByIndex<I>& Value() const& {
+    return *reinterpret_cast<const TypeByIndex<I>*>(storage_);
+  }
+
+ private:
+  static constexpr const std::size_t size = std::max({sizeof(Ts)...});
+
+  alignas(Ts...) unsigned char storage_[size];
+  std::uint8_t type_index_;
+
+  friend struct details::VariantPrivateScope;
+
+  template<typename T, typename... Args, std::enable_if_t<HasType<T> && IsAggregate<T>, int> = 0>
+  void Construct(Args&&... args) {
+    new (storage_) T{std::forward<Args>(args)...};
+    type_index_ = IndexOfType<T>;
+  }
+
+  template<typename T, typename... Args, std::enable_if_t<HasType<T> && !IsAggregate<T>, int> = 0>
+  void Construct(Args&&... args) {
+    new (storage_) T(std::forward<Args>(args)...);
+    type_index_ = IndexOfType<T>;
+  }
+
+  template<std::size_t I, typename... Args, std::enable_if_t<(I < Num), int> = 0>
+  void Construct(Args&&... args) {
+    Construct<TypeByIndex<I>>(std::forward<Args>(args)...);
+  }
+
+  template<typename V>
+  void CopyConstruct(V&& v) {
+    std::forward<V>(v).Visit([this](auto&& elem) {
+      using T = RemoveCVRef<decltype(elem)>;
+
+      new (storage_) T(std::forward<decltype(elem)>(elem));
+      type_index_ = IndexOfType<T>;
+    });
+  }
+
+  template<typename V>
+  void Copy(V&& v) {
+    std::forward<V>(v).Visit([this](auto&& elem) {
+      using T = RemoveCVRef<decltype(elem)>;
+
+      if (Is<T>()) {
+        Value<T>() = std::forward<decltype(elem)>(elem);
+      } else {
+        Destory();
+        Construct<T>(std::forward<decltype(elem)>(elem));
+      }
+    });
+  }
+
+  void Destory() {
+    Visit([this](auto& elem) {
+      using T = RemoveCVRef<decltype(elem)>;
+
+      Value<T>().~T();
+    });
+  }
+};
+
+template<typename... Ts>
+using OptionalVariant = Variant<NullOptType, Ts...>;
+
+}  // namespace maybe
+
+}  // namespace oneflow
+
+namespace std {
+
+template<typename... Ts>
+struct hash<oneflow::maybe::Variant<Ts...>> {
+  size_t operator()(const oneflow::maybe::Variant<Ts...>& v) const noexcept {
+    size_t seed = hash<size_t>()(v.Index());
+
+    v.Visit([&seed](const auto& x) {
+      using type = oneflow::maybe::RemoveCVRef<decltype(x)>;
+      oneflow::maybe::HashCombine<type>(seed, x);
+    });
+
+    return seed;
+  }
+};
+
+}  // namespace std
+
+#endif  // ONEFLOW_MAYBE_VARIANT_H_
diff --git a/oneflow/maybe/variant_test.cpp b/oneflow/maybe/variant_test.cpp
new file mode 100644
index 00000000000..7d1ebe128ae
--- /dev/null
+++ b/oneflow/maybe/variant_test.cpp
@@ -0,0 +1,236 @@
+/*
+Copyright 2020 The OneFlow Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <gtest/gtest.h>
+#include <memory>
+#include "oneflow/maybe/variant.h"
+
+using namespace oneflow::maybe;
+using namespace std::string_literals;
+
+TEST(Variant, Basics) {
+  Variant<int, float> a, b(1), c(1.2f), d(InPlaceType<int>, 'a'), e(InPlaceType<float>, 6.66);
+  ASSERT_TRUE(a.Is<int>());
+  ASSERT_EQ(a.Get<int>(), 0);
+  ASSERT_TRUE(b.Is<int>());
+  ASSERT_EQ(b.Get<int>(), 1);
+  ASSERT_TRUE(c.Is<float>());
+  ASSERT_EQ(c.Get<float>(), 1.2f);
+  ASSERT_TRUE(d.Is<int>());
+  ASSERT_EQ(d.Get<int>(), 'a');
+  ASSERT_TRUE(e.Is<float>());
+  ASSERT_FLOAT_EQ(e.Get<float>(), 6.66);
+
+  Variant<int, float> f(b), g(c), h(InPlaceIndex<1>, 2.33), i(InPlaceIndex<0>, 2.33);
+  ASSERT_TRUE(f.Is<int>());
+  ASSERT_EQ(f.Get<int>(), 1);
+  ASSERT_TRUE(g.Is<float>());
+  ASSERT_EQ(g.Get<float>(), 1.2f);
+  ASSERT_TRUE(h.Is<float>());
+  ASSERT_FLOAT_EQ(h.Get<float>(), 2.33);
+  ASSERT_TRUE(i.Is<int>());
+  ASSERT_EQ(i.Get<int>(), 2);
+
+  a = 1;
+  ASSERT_TRUE(a.Is<int>());
+  ASSERT_EQ(a.Get<int>(), 1);
+
+  a = 1.3f;
+  ASSERT_TRUE(a.Is<float>());
+  ASSERT_EQ(a.Get<float>(), 1.3f);
+
+  a = b;
+  ASSERT_TRUE(a.Is<int>());
+  ASSERT_EQ(a.Get<int>(), 1);
+
+  a = c;
+  ASSERT_TRUE(a.Is<float>());
+  ASSERT_EQ(a.Get<float>(), 1.2f);
+
+  ASSERT_EQ((b.Visit<Variant<int, float>>([](auto&& x) { return x + 1; })),
+            (Variant<int, float>(2)));
+  ASSERT_EQ((c.Visit<Variant<int, float>>([](auto&& x) { return x + 1; })),
+            (Variant<int, float>(2.2f)));
+
+  ASSERT_EQ(a.Emplace<1>(1.3f), 1.3f);
+  ASSERT_TRUE(a.Is<float>());
+  ASSERT_EQ(a.Get<1>(), 1.3f);
+
+  ASSERT_EQ(a.Emplace<0>(233), 233);
+  ASSERT_TRUE(a.Is<int>());
+  ASSERT_EQ(a.Get<0>(), 233);
+}
+
+TEST(Variant, NonPOD) {
+  Variant<bool, std::shared_ptr<int>> a;
+  ASSERT_TRUE(a.Is<bool>());
+  ASSERT_EQ(a.Get<bool>(), false);
+
+  a = true;
+  ASSERT_TRUE(a.Is<bool>());
+  ASSERT_EQ(a.Get<bool>(), true);
+
+  a = std::make_shared<int>(233);
+  ASSERT_EQ(a.Index(), 1);
+  ASSERT_EQ(*a.Get<1>(), 233);
+  ASSERT_EQ(a.Get<1>().use_count(), 1);
+
+  {
+    Variant<bool, std::shared_ptr<int>> b = a;
+    ASSERT_EQ(b.Index(), 1);
+    ASSERT_EQ(*b.Get<1>(), 233);
+    ASSERT_EQ(a.Get<1>().use_count(), 2);
+    *b.Get<1>() = 234;
+  }
+
+  ASSERT_EQ(a.Get<1>().use_count(), 1);
+  ASSERT_EQ(*a.Get<1>(), 234);
+
+  Variant<bool, std::shared_ptr<int>> b = std::move(a);
+  ASSERT_EQ(b.Get<1>().use_count(), 1);
+  ASSERT_EQ(*b.Get<1>(), 234);
+
+  Variant<bool, std::shared_ptr<int>> c = b;
+  ASSERT_EQ(c.Get<1>().use_count(), 2);
+  ASSERT_EQ(b, c);
+
+  b = true;
+  ASSERT_EQ(c.Get<1>().use_count(), 1);
+
+  ASSERT_NE(b, c);
+}
+
+TEST(Variant, Optional) {
+  OptionalVariant<int, const char*> a, b(NullOpt), c(a);
+
+  const char* hello = "hello";
+
+  std::size_t hash = 0, hash2 = 1, hash3 = 2;
+  HashCombine(hash, NullOpt);
+  HashCombine(hash2, 1);
+  HashCombine(hash3, hello);
+
+  ASSERT_TRUE(a == NullOpt);
+  ASSERT_EQ(std::hash<decltype(a)>()(a), hash);
+
+  a = 1;
+  ASSERT_EQ(a, 1);
+  ASSERT_EQ(std::hash<decltype(a)>()(a), hash2);
+
+  a = NullOpt;
+  ASSERT_EQ(a, NullOpt);
+  ASSERT_EQ(std::hash<decltype(a)>()(a), hash);
+
+  a = hello;
+  ASSERT_EQ(a, hello);
+  ASSERT_EQ(std::hash<decltype(a)>()(a), hash3);
+
+  ASSERT_EQ(b, NullOpt);
+  ASSERT_EQ(c, NullOpt);
+  ASSERT_NE(a, b);
+}
+
+TEST(Variant, BinarySearchVisit) {
+  const char* hello = "hello";
+
+  OptionalVariant<int, float, bool> x, y(123), z(1.2f), w(true);
+  OptionalVariant<int, float, bool, const char*> a, b(123), c(1.2f), d(true), e(hello);
+
+  ASSERT_EQ(x, NullOpt);
+  ASSERT_EQ(y, 123);
+  ASSERT_EQ(z, 1.2f);
+  ASSERT_EQ(w, true);
+  ASSERT_EQ(a, NullOpt);
+  ASSERT_EQ(b, 123);
+  ASSERT_EQ(c, 1.2f);
+  ASSERT_EQ(d, true);
+  ASSERT_EQ(e, hello);
+
+  OptionalVariant<int, float, bool, const char*> a1(a), b1(b), c1(c), d1(d), e1(e);
+
+  ASSERT_EQ(a1, NullOpt);
+  ASSERT_EQ(b1, 123);
+  ASSERT_EQ(c1, 1.2f);
+  ASSERT_EQ(d1, true);
+  ASSERT_EQ(e1, hello);
+
+  a = 233;
+  ASSERT_EQ(a, 233);
+
+  a = hello;
+  ASSERT_EQ(a, hello);
+
+  a = c;
+  ASSERT_EQ(a, 1.2f);
+  ASSERT_EQ(1.2f, a);
+  ASSERT_EQ(a, c);
+  ASSERT_NE(a, b);
+}
+
+TEST(Variant, Compare) {
+  OptionalVariant<int, float, bool> a, b, c(0), d(5), dd(5), e(-1.2f), f(2.3f), g(false), h(true);
+
+  ASSERT_EQ(a, b);
+  ASSERT_EQ(d, dd);
+  ASSERT_NE(a, c);
+  ASSERT_NE(c, d);
+  ASSERT_NE(d, e);
+  ASSERT_NE(e, f);
+  ASSERT_NE(f, g);
+  ASSERT_NE(g, h);
+  ASSERT_LT(a, c);
+  ASSERT_LT(c, d);
+  ASSERT_LT(d, e);
+  ASSERT_LT(e, f);
+  ASSERT_LT(f, g);
+  ASSERT_LT(g, h);
+  ASSERT_GT(c, a);
+  ASSERT_GT(d, c);
+  ASSERT_GT(e, d);
+  ASSERT_GT(f, e);
+  ASSERT_GT(g, f);
+  ASSERT_GT(h, g);
+  ASSERT_LE(a, b);
+  ASSERT_LE(b, c);
+  ASSERT_LE(c, d);
+  ASSERT_LE(d, dd);
+
+  std::set<OptionalVariant<int, float, bool>> s{100, 2.3f,  true, 3.3f, NullOpt,
+                                                0,   false, 22,   true, NullOpt};
+  ASSERT_EQ(s.size(), 8);
+
+  auto iter = s.begin();
+  ASSERT_EQ(*(iter++), NullOpt);
+  ASSERT_EQ(*(iter++), 0);
+  ASSERT_EQ(*(iter++), 22);
+  ASSERT_EQ(*(iter++), 100);
+  ASSERT_EQ(*(iter++), 2.3f);
+  ASSERT_EQ(*(iter++), 3.3f);
+  ASSERT_EQ(*(iter++), false);
+  ASSERT_EQ(*(iter++), true);
+}
+
+TEST(Variant, UniquePtr) {
+  Variant<std::string, std::unique_ptr<int>> a("hello"s), b(std::make_unique<int>(1));
+
+  ASSERT_EQ(a, "hello"s);
+  ASSERT_EQ(*b.Get<1>(), 1);
+
+  Variant<std::string, std::unique_ptr<int>> c(std::move(a)), d(std::move(b));
+
+  ASSERT_EQ(c, "hello"s);
+  ASSERT_EQ(*d.Get<1>(), 1);
+}