diff --git a/src/Algos.cc b/src/Algos.cc
index 5679f6730..fa5b644ff 100644
--- a/src/Algos.cc
+++ b/src/Algos.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cctype>
 #include <memory>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <thread>
@@ -145,7 +146,7 @@ equalsInsensitive(
   );
 }
 
-Option<std::string_view>
+std::optional<std::string_view>
 findSimilarStr(
     const std::string_view lhs, std::span<const std::string_view> candidates
 ) {
@@ -163,7 +164,7 @@ findSimilarStr(
   const usize length = lhs.size();
   const usize maxDist = length < 3 ? length - 1 : length / 3;
 
-  Option<std::pair<std::string_view, usize>> similarStr = None;
+  std::optional<std::pair<std::string_view, usize>> similarStr = std::nullopt;
   for (const std::string_view str : candidates) {
     const usize curDist = levDistance(lhs, str);
     if (curDist <= maxDist) {
@@ -177,7 +178,7 @@ findSimilarStr(
   if (similarStr.has_value()) {
     return similarStr->first;
   } else {
-    return None;
+    return std::nullopt;
   }
 }
 
@@ -246,8 +247,10 @@ testFindSimilarStr() {
   assertEq(findSimilarStr("els", candidates), "else"sv);
   assertEq(findSimilarStr("endi", candidates), "endif"sv);
 
-  assertEq(findSimilarStr("i", candidates), None);
-  assertEq(findSimilarStr("special_compiler_directive", candidates), None);
+  assertEq(findSimilarStr("i", candidates), std::nullopt);
+  assertEq(
+      findSimilarStr("special_compiler_directive", candidates), std::nullopt
+  );
 
   pass();
 }
@@ -256,7 +259,7 @@ void
 testFindSimilarStr2() {
   constexpr std::array<std::string_view, 2> candidates{ "aaab", "aaabc" };
   assertEq(findSimilarStr("aaaa", candidates), "aaab"sv);
-  assertEq(findSimilarStr("1111111111", candidates), None);
+  assertEq(findSimilarStr("1111111111", candidates), std::nullopt);
 
   constexpr std::array<std::string_view, 1> candidateS2{ "AAAA" };
   assertEq(findSimilarStr("aaaa", candidateS2), "AAAA"sv);
diff --git a/src/Algos.hpp b/src/Algos.hpp
index 8703480a8..718c88b82 100644
--- a/src/Algos.hpp
+++ b/src/Algos.hpp
@@ -7,6 +7,7 @@
 #include <iostream>
 #include <list>
 #include <memory>
+#include <optional>
 #include <queue>
 #include <span>
 #include <sstream>
@@ -84,7 +85,7 @@ topoSort(
 /// \param candidates the candidates to find a similar string.
 ///
 /// \returns a similar string if exists. If no similar string exists,
-/// returns None.
-Option<std::string_view> findSimilarStr(
+/// returns std::nullopt.
+std::optional<std::string_view> findSimilarStr(
     std::string_view lhs, std::span<const std::string_view> candidates
 );
diff --git a/src/BuildConfig.cc b/src/BuildConfig.cc
index 1018f209f..f78b6097e 100644
--- a/src/BuildConfig.cc
+++ b/src/BuildConfig.cc
@@ -19,6 +19,7 @@
 #include <iomanip>
 #include <iostream>
 #include <memory>
+#include <optional>
 #include <ostream>
 #include <span>
 #include <sstream>
@@ -89,7 +90,7 @@ operator<<(std::ostream& os, const Variable& var) {
 
 struct Target {
   std::vector<std::string> commands;
-  Option<std::string> sourceFile;
+  std::optional<std::string> sourceFile;
   HashSet<std::string> remDeps;
 };
 
@@ -101,8 +102,8 @@ struct BuildConfig {
   HashMap<std::string, std::vector<std::string>> varDeps;
   HashMap<std::string, Target> targets;
   HashMap<std::string, std::vector<std::string>> targetDeps;
-  Option<HashSet<std::string>> phony;
-  Option<HashSet<std::string>> all;
+  std::optional<HashSet<std::string>> phony;
+  std::optional<HashSet<std::string>> all;
 
   std::string OUT_DIR;
   std::string CXX = "clang++";
@@ -155,7 +156,7 @@ struct BuildConfig {
   void defineTarget(
       const std::string& name, const std::vector<std::string>& commands,
       const HashSet<std::string>& remDeps = {},
-      const Option<std::string>& sourceFile = None
+      const std::optional<std::string>& sourceFile = std::nullopt
   ) {
     targets[name] = { commands, sourceFile, remDeps };
 
@@ -212,7 +213,7 @@ static void
 emitTarget(
     std::ostream& os, const std::string_view target,
     const HashSet<std::string>& dependsOn,
-    const Option<std::string>& sourceFile = None,
+    const std::optional<std::string>& sourceFile = std::nullopt,
     const std::vector<std::string>& commands = {}
 ) {
   usize offset = 0;
@@ -324,8 +325,8 @@ BuildConfig::emitCompdb(const std::string_view baseDir, std::ostream& os)
       continue;
     }
 
-    // We don't check the Option value because we know the first dependency
-    // always exists for compile targets.
+    // We don't check the std::optional value because we know the first
+    // dependency always exists for compile targets.
     const std::string file = targetInfo.sourceFile.value();
     // The output is the target.
     const std::string output = target;
diff --git a/src/Cli.hpp b/src/Cli.hpp
index 8c20bca1d..69233c5a4 100644
--- a/src/Cli.hpp
+++ b/src/Cli.hpp
@@ -6,6 +6,7 @@
 #include <cstdlib>
 #include <functional>
 #include <iterator>
+#include <optional>
 #include <span>
 #include <string>
 #include <string_view>
@@ -142,7 +143,7 @@ class Subcmd : public CliBase<Subcmd>, public ShortAndHidden<Subcmd> {
   friend class Cli;
 
   std::string_view cmdName;
-  Option<std::vector<Opt>> globalOpts = None;
+  std::optional<std::vector<Opt>> globalOpts = std::nullopt;
   std::vector<Opt> localOpts;
   Arg arg;
   std::function<int(std::span<const std::string_view>)> mainFn;
@@ -204,11 +205,12 @@ class Cli : public CliBase<Cli> {
 
   static constexpr int CONTINUE = -1;
 
-  // Returns the exit code if the global option was handled, otherwise None.
-  // Returns CONTINUE if the caller should not propagate the exit code.
+  // Returns the exit code if the global option was handled, otherwise
+  // std::nullopt. Returns CONTINUE if the caller should not propagate the exit
+  // code.
   // TODO: -1 is not a good idea.
   // TODO: result-like types make more sense.
-  [[nodiscard]] static inline Option<int> handleGlobalOpts(
+  [[nodiscard]] static inline std::optional<int> handleGlobalOpts(
       std::forward_iterator auto& itr, const std::forward_iterator auto end,
       std::string_view subcmd = ""
   ) {
@@ -237,7 +239,7 @@ class Cli : public CliBase<Cli> {
         return EXIT_FAILURE;
       }
     }
-    return None;
+    return std::nullopt;
   }
 
 private:
diff --git a/src/Cmd/Add.cc b/src/Cmd/Add.cc
index af794b61f..e28e7dfb3 100644
--- a/src/Cmd/Add.cc
+++ b/src/Cmd/Add.cc
@@ -8,6 +8,7 @@
 #include <cstdlib>
 #include <fstream>
 #include <functional>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <toml.hpp>
@@ -36,7 +37,7 @@ const Subcmd ADD_CMD =
                     .setPlaceholder("<BRANCH_NAME>"))
         .setMainFn(addMain);
 
-static Option<int>
+static std::optional<int>
 handleNextArg(
     std::span<const std::string_view>::iterator& itr,
     const std::span<const std::string_view>::iterator& end, std::string& arg
@@ -46,7 +47,7 @@ handleNextArg(
     return Subcmd::missingArgumentForOpt(*--itr);
   }
   arg = std::string(*itr);
-  return None;
+  return std::nullopt;
 }
 
 static void
@@ -167,13 +168,13 @@ addMain(const std::span<const std::string_view> args) {
   // clang-format off
   HashMap<
     std::string_view,
-    std::function<Option<int>(decltype(args)::iterator&, decltype(args)::iterator)>
+    std::function<std::optional<int>(decltype(args)::iterator&, decltype(args)::iterator)>
   >
   handlers = {
     {
       "--sys", [&](auto&, auto) {
         isSystemDependency = true;
-        return None;
+        return std::nullopt;
       }
     },
     {
diff --git a/src/Manifest.cc b/src/Manifest.cc
index 2a19bfaaf..ebcba38a2 100644
--- a/src/Manifest.cc
+++ b/src/Manifest.cc
@@ -11,6 +11,7 @@
 
 #include <cctype>
 #include <cstdlib>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <variant>
@@ -118,7 +119,7 @@ findManifest() {
 struct GitDependency {
   std::string name;
   std::string url;
-  Option<std::string> target;
+  std::optional<std::string> target;
 
   DepMetadata install() const;
 };
@@ -158,21 +159,21 @@ struct Manifest {
     return instance;
   }
 
-  Option<fs::path> manifestPath = None;
+  std::optional<fs::path> manifestPath = std::nullopt;
 
-  Option<toml::value> data = None;
+  std::optional<toml::value> data = std::nullopt;
 
-  Option<Package> package = None;
-  Option<std::vector<std::variant<GitDependency, SystemDependency>>>
-      dependencies = None;
-  Option<std::vector<std::variant<GitDependency, SystemDependency>>>
-      devDependencies = None;
+  std::optional<Package> package = std::nullopt;
+  std::optional<std::vector<std::variant<GitDependency, SystemDependency>>>
+      dependencies = std::nullopt;
+  std::optional<std::vector<std::variant<GitDependency, SystemDependency>>>
+      devDependencies = std::nullopt;
 
-  Option<Profile> profile = None;
-  Option<Profile> devProfile = None;
-  Option<Profile> releaseProfile = None;
+  std::optional<Profile> profile = std::nullopt;
+  std::optional<Profile> devProfile = std::nullopt;
+  std::optional<Profile> releaseProfile = std::nullopt;
 
-  Option<std::vector<std::string>> cpplintFilters = None;
+  std::optional<std::vector<std::string>> cpplintFilters = std::nullopt;
 
 private:
   Manifest() noexcept = default;
@@ -199,7 +200,7 @@ getManifestPath() {
 }
 
 // Returns an error message if the package name is invalid.
-Option<std::string> // TODO: result-like types make more sense.
+std::optional<std::string> // TODO: result-like types make more sense.
 validatePackageName(const std::string_view name) noexcept {
   // Empty
   if (name.empty()) {
@@ -237,7 +238,7 @@ validatePackageName(const std::string_view name) noexcept {
     return "must not be a C++ keyword";
   }
 
-  return None;
+  return std::nullopt;
 }
 
 static Package&
@@ -324,7 +325,7 @@ parseProfile(const toml::table& table) {
 }
 
 static Profile
-getProfile(Option<std::string> profileName) {
+getProfile(std::optional<std::string> profileName) {
   Manifest& manifest = Manifest::instance();
   if (!manifest.data.value().contains("profile")) {
     return {};
@@ -357,7 +358,7 @@ getBaseProfile() {
     return manifest.profile.value();
   }
 
-  const Profile baseProfile = getProfile(None);
+  const Profile baseProfile = getProfile(std::nullopt);
   manifest.profile = baseProfile;
   return manifest.profile.value();
 }
@@ -507,7 +508,7 @@ static GitDependency
 parseGitDep(const std::string& name, const toml::table& info) {
   validateDepName(name);
   std::string gitUrlStr;
-  Option<std::string> target = None;
+  std::optional<std::string> target = std::nullopt;
 
   const auto& gitUrl = info.at("git");
   if (gitUrl.is_string()) {
@@ -539,13 +540,13 @@ parseSystemDep(const std::string& name, const toml::table& info) {
   return { name, VersionReq::parse(versionReq) };
 }
 
-static Option<std::vector<std::variant<GitDependency, SystemDependency>>>
+static std::optional<std::vector<std::variant<GitDependency, SystemDependency>>>
 parseDependencies(const char* key) {
   Manifest& manifest = Manifest::instance();
   const auto& table = toml::get<toml::table>(manifest.data.value());
   if (!table.contains(key)) {
     logger::debug("[dependencies] not found");
-    return None;
+    return std::nullopt;
   }
   const auto tomlDeps = toml::find<toml::table>(manifest.data.value(), key);
 
diff --git a/src/Manifest.hpp b/src/Manifest.hpp
index 3e8c1cdc0..27bbb18ec 100644
--- a/src/Manifest.hpp
+++ b/src/Manifest.hpp
@@ -4,6 +4,7 @@
 #include "Semver.hpp"
 
 #include <compare>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -16,8 +17,8 @@ struct DepMetadata {
 struct Profile {
   HashSet<std::string> cxxflags;
   bool lto = false;
-  Option<bool> debug = None;
-  Option<usize> opt_level = None;
+  std::optional<bool> debug = std::nullopt;
+  std::optional<usize> opt_level = std::nullopt;
 
   // Merges this profile with another profile. If a field in this profile is
   // set, it will not be overwritten by the other profile. Only default values
@@ -57,7 +58,7 @@ struct Edition {
 };
 
 const fs::path& getManifestPath();
-Option<std::string> validatePackageName(std::string_view name) noexcept;
+std::optional<std::string> validatePackageName(std::string_view name) noexcept;
 const std::string& getPackageName();
 const Edition& getPackageEdition();
 const Version& getPackageVersion();
diff --git a/src/Rustify/Aliases.hpp b/src/Rustify/Aliases.hpp
index 92ddea653..d9c338b12 100644
--- a/src/Rustify/Aliases.hpp
+++ b/src/Rustify/Aliases.hpp
@@ -4,12 +4,9 @@
 #include <cstdlib>
 #include <filesystem>
 #include <iostream>
-#include <optional>
-#include <ostream>
 #include <string_view>
 #include <unordered_map>
 #include <unordered_set>
-#include <variant>
 
 namespace fs = std::filesystem;
 
@@ -37,31 +34,6 @@ using HashMap = std::unordered_map<K, V>;
 template <typename K>
 using HashSet = std::unordered_set<K>;
 
-template <typename T>
-using Option = std::optional<T>;
-
-struct NoneT : protected std::monostate {
-  constexpr bool operator==(const usize rhs) const {
-    return std::string_view::npos == rhs;
-  }
-
-  // NOLINTNEXTLINE(google-explicit-constructor)
-  constexpr operator std::nullopt_t() const {
-    return std::nullopt;
-  }
-
-  template <typename T>
-  constexpr operator Option<T>() const { // NOLINT(google-explicit-constructor)
-    return std::nullopt;
-  }
-};
-inline constinit const NoneT None; // NOLINT(readability-identifier-naming)
-
-inline std::ostream&
-operator<<(std::ostream& os, const NoneT& /*unused*/) {
-  return os << "None";
-}
-
 // NOLINTBEGIN(google-global-names-in-headers)
 using std::literals::string_literals::operator""s;
 using std::literals::string_view_literals::operator""sv;
diff --git a/src/Rustify/Traits.hpp b/src/Rustify/Traits.hpp
index 541162791..c099011ba 100644
--- a/src/Rustify/Traits.hpp
+++ b/src/Rustify/Traits.hpp
@@ -5,6 +5,12 @@
 #include <ostream>
 #include <type_traits>
 
+inline std::ostream&
+operator<<(std::ostream& os, const std::nullopt_t&) {
+  os << "None";
+  return os;
+}
+
 template <typename T>
 std::ostream&
 operator<<(std::ostream& os, const std::optional<T>& opt) {
diff --git a/src/VersionReq.hpp b/src/VersionReq.hpp
index 6e2d61291..150f35d2a 100644
--- a/src/VersionReq.hpp
+++ b/src/VersionReq.hpp
@@ -17,14 +17,15 @@
 #include "Rustify.hpp"
 #include "Semver.hpp"
 
+#include <optional>
 #include <ostream>
 #include <string>
 #include <string_view>
 
 struct OptVersion {
   u64 major{};
-  Option<u64> minor;
-  Option<u64> patch;
+  std::optional<u64> minor;
+  std::optional<u64> patch;
   Prerelease pre;
 };
 
@@ -70,10 +71,10 @@ struct Comparator {
   };
   using enum Op;
 
-  Option<Op> op;
+  std::optional<Op> op;
   u64 major{};
-  Option<u64> minor;
-  Option<u64> patch;
+  std::optional<u64> minor;
+  std::optional<u64> patch;
   Prerelease pre;
 
   static Comparator parse(std::string_view str);
@@ -86,7 +87,7 @@ struct Comparator {
 
 struct VersionReq {
   Comparator left;
-  Option<Comparator> right;
+  std::optional<Comparator> right;
 
   static VersionReq parse(std::string_view str);
   bool satisfiedBy(const Version& ver) const noexcept;
diff --git a/srcOld/Cfg.hpp b/srcOld/Cfg.hpp
index 40cc41690..5546ebb35 100644
--- a/srcOld/Cfg.hpp
+++ b/srcOld/Cfg.hpp
@@ -277,13 +277,13 @@ struct Lexer {
 
   explicit Lexer(std::string_view str) : str(str) {}
 
-  inline auto next() -> Option<Token> {
+  inline auto next() -> std::optional<Token> {
     const auto [diff, token] = tokenize(this->index);
     this->step_n(diff);
     return token;
   }
 
-  [[nodiscard]] inline auto peek() const -> Option<Token> {
+  [[nodiscard]] inline auto peek() const -> std::optional<Token> {
     const auto [diff, token] = tokenize(this->index);
     static_cast<void>(diff);
     return token;
@@ -291,21 +291,21 @@ struct Lexer {
 
 private:
   [[nodiscard]] inline auto generate_token(
-      SizeType index_, const Option<Token>& token
-  ) const -> std::pair<SizeType, Option<Token>> {
+      SizeType index_, const std::optional<Token>& token
+  ) const -> std::pair<SizeType, std::optional<Token>> {
     return { this->diff_step(index_), token };
   }
   [[nodiscard]] inline auto generate_token(
       SizeType index_, std::string_view kind
-  ) const -> std::pair<SizeType, Option<Token>> {
+  ) const -> std::pair<SizeType, std::optional<Token>> {
     return generate_token(index_, Token{ to_kind(kind) });
   }
 
   [[nodiscard]] auto analyze_two_phrase(SizeType index_, char kind) const
-      -> std::pair<SizeType, Option<Token>>;
+      -> std::pair<SizeType, std::optional<Token>>;
 
   [[nodiscard]] auto tokenize(SizeType index_
-  ) const -> std::pair<SizeType, Option<Token>>;
+  ) const -> std::pair<SizeType, std::optional<Token>>;
 
   void step(SizeType& index_) const noexcept;
   void step_n(SizeType n) noexcept;
@@ -325,12 +325,13 @@ struct Lexer {
 
   [[nodiscard]] auto ident(SizeType index_) const -> std::pair<SizeType, Token>;
 
-  static auto to_ident(std::string_view s) noexcept -> Option<Token::ident>;
+  static auto to_ident(std::string_view s
+  ) noexcept -> std::optional<Token::ident>;
 };
 
 auto
 Lexer::analyze_two_phrase(SizeType index_, const char kind) const
-    -> std::pair<Lexer::SizeType, Option<Token>> {
+    -> std::pair<Lexer::SizeType, std::optional<Token>> {
   if (this->one(index_) == '=') {
     this->step(index_);
     return generate_token(index_, std::string{ kind } + '=');
@@ -341,9 +342,9 @@ Lexer::analyze_two_phrase(SizeType index_, const char kind) const
 
 auto
 Lexer::tokenize(SizeType index_
-) const -> std::pair<Lexer::SizeType, Option<Token>> {
+) const -> std::pair<Lexer::SizeType, std::optional<Token>> {
   if (index_ >= this->str.size()) {
-    return generate_token(index_, None);
+    return generate_token(index_, std::nullopt);
   }
   const char one = this->one(index_);
   switch (one) {
@@ -432,7 +433,7 @@ Lexer::ident(SizeType index_) const -> std::pair<Lexer::SizeType, Token> {
 }
 
 auto
-Lexer::to_ident(std::string_view s) noexcept -> Option<Token::ident> {
+Lexer::to_ident(std::string_view s) noexcept -> std::optional<Token::ident> {
   if (s == "cfg") {
     return Token::ident::cfg;
   } else if (s == "not") {
@@ -454,7 +455,7 @@ Lexer::to_ident(std::string_view s) noexcept -> Option<Token::ident> {
   } else if (s == "os_version") {
     return Token::ident::os_version;
   } else {
-    return None;
+    return std::nullopt;
   }
 }
 
diff --git a/srcOld/Lockfile.hpp b/srcOld/Lockfile.hpp
index 963a155ff..5da91707f 100644
--- a/srcOld/Lockfile.hpp
+++ b/srcOld/Lockfile.hpp
@@ -136,7 +136,8 @@ convert_to_deps(const Lockfile& lock
 ) -> resolver::UniqDeps<resolver::WithDeps> {
   resolver::UniqDeps<resolver::WithDeps> deps;
   for (const auto& package : lock.package) {
-    resolver::UniqDeps<resolver::WithDeps>::mapped_type inner_deps = None;
+    resolver::UniqDeps<resolver::WithDeps>::mapped_type inner_deps =
+        std::nullopt;
     if (!package.dependencies.empty()) {
       // When serializing lockfile, package version of inner dependencies
       // will be dropped (ref: `convert_to_lock` function).
@@ -156,9 +157,9 @@ convert_to_deps(const Lockfile& lock
 
 [[nodiscard]] auto
 read(const fs::path& base_dir
-) -> Result<Option<resolver::UniqDeps<resolver::WithDeps>>> {
+) -> Result<std::optional<resolver::UniqDeps<resolver::WithDeps>>> {
   if (!fs::exists(base_dir / LOCKFILE_NAME)) {
-    return Ok(None);
+    return Ok(std::nullopt);
   }
 
   try {
diff --git a/srcOld/Resolver.hpp b/srcOld/Resolver.hpp
index 0c08b01f0..3e2c4a0fe 100644
--- a/srcOld/Resolver.hpp
+++ b/srcOld/Resolver.hpp
@@ -333,17 +333,17 @@ get_resolved_deps(const toml::value& manifest) -> Result<ResolvedDeps> {
 
 // If lockfile is not outdated, read it.
 [[nodiscard]] auto
-try_to_read_lockfile() -> Result<Option<ResolvedDeps>> {
+try_to_read_lockfile() -> Result<std::optional<ResolvedDeps>> {
   if (!data::lockfile::is_outdated(config::cwd)) {
     return data::lockfile::read(config::cwd);
   } else {
-    return Ok(None);
+    return Ok(std::nullopt);
   }
 }
 
 [[nodiscard]] auto
 resolve_deps(const toml::value& manifest) -> Result<ResolvedDeps> {
-  const Option<ResolvedDeps> locked_deps = Try(try_to_read_lockfile());
+  const std::optional<ResolvedDeps> locked_deps = Try(try_to_read_lockfile());
   if (locked_deps.has_value()) {
     // Lockfile exists and is not outdated.
     return Ok(locked_deps.value());
diff --git a/srcOld/Resolver/Resolve.hpp b/srcOld/Resolver/Resolve.hpp
index c184b7f1e..86e0c10b5 100644
--- a/srcOld/Resolver/Resolve.hpp
+++ b/srcOld/Resolver/Resolve.hpp
@@ -314,7 +314,7 @@ gather_deps(
   const UniqDeps<WithoutDeps> deps_api_res =
       util::net::api::deps(package.name, package.dep_info.version_rq).unwrap();
   if (deps_api_res.empty()) {
-    new_deps.emplace_back(package, None);
+    new_deps.emplace_back(package, std::nullopt);
   } else {
     const DupDeps<WithoutDeps> deps_of_deps =
         gather_deps_of_deps(deps_api_res, interval_cache);
@@ -341,7 +341,7 @@ gather_all_deps(const UniqDeps<WithoutDeps>& deps
 
     // We don't resolve deps of conan packages, this is defer to conan itself
     if (poac::util::registry::conan::v1::resolver::is_conan(package)) {
-      duplicate_deps.emplace_back(package, None);
+      duplicate_deps.emplace_back(package, std::nullopt);
       continue;
     }
 
diff --git a/srcOld/Resolver/Types.hpp b/srcOld/Resolver/Types.hpp
index ce3783e0b..be1c35c9c 100644
--- a/srcOld/Resolver/Types.hpp
+++ b/srcOld/Resolver/Types.hpp
@@ -84,7 +84,7 @@ struct DuplicateDeps<WithoutDeps> {
   using Type = std::vector<Package>;
 };
 
-using Deps = Option<DupDeps<WithoutDeps>>;
+using Deps = std::optional<DupDeps<WithoutDeps>>;
 
 template <>
 struct DuplicateDeps<WithDeps> {