pw_minimal_cpp_stdlib: Extremely limited C++ lib pw_minimal_cpp_stdlib is an extremely limited, non-standard implementation of the C++ Standard Library. It requires C++17 and a C standard library. Change-Id: I2d0b8d6cf49730e2c746eddf2c4a23308af1eb6a

diff --git a/BUILD.gn b/BUILD.gn
index 6379134..355b961 100644
--- a/BUILD.gn
+++ b/BUILD.gn

@@ -1,4 +1,4 @@
-# Copyright 2019 The Pigweed Authors
+# Copyright 2020 The Pigweed Authors
 #
 # 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
@@ -54,6 +54,7 @@
     "$dir_pw_base64",
     "$dir_pw_checksum",
     "$dir_pw_kvs",
+    "$dir_pw_minimal_cpp_stdlib",
     "$dir_pw_polyfill",
     "$dir_pw_preprocessor",
     "$dir_pw_protobuf",
@@ -73,6 +74,7 @@
     "$dir_pw_checksum:tests",
     "$dir_pw_kvs:tests",
     "$dir_pw_log:tests",
+    "$dir_pw_minimal_cpp_stdlib:tests",
     "$dir_pw_polyfill:tests",
     "$dir_pw_preprocessor:tests",
     "$dir_pw_protobuf:tests",

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d8ed777..3e6b40d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt

@@ -27,6 +27,7 @@
 add_subdirectory(pw_kvs)
 add_subdirectory(pw_log)
 add_subdirectory(pw_log_basic)
+add_subdirectory(pw_minimal_cpp_stdlib)
 add_subdirectory(pw_polyfill)
 add_subdirectory(pw_preprocessor)
 add_subdirectory(pw_span)

diff --git a/docs/BUILD.gn b/docs/BUILD.gn
index 031834e..076900d 100644
--- a/docs/BUILD.gn
+++ b/docs/BUILD.gn

@@ -51,6 +51,7 @@
     "$dir_pw_dumb_io_baremetal_stm32f429:docs",
     "$dir_pw_dumb_io_stdio:docs",
     "$dir_pw_log:docs",
+    "$dir_pw_minimal_cpp_stdlib:docs",
     "$dir_pw_module:docs",
     "$dir_pw_polyfill:docs",
     "$dir_pw_preprocessor:docs",

diff --git a/modules.gni b/modules.gni
index 41fe5cf..d543d55 100644
--- a/modules.gni
+++ b/modules.gni

@@ -32,6 +32,7 @@
 dir_pw_kvs = "$dir_pigweed/pw_kvs"
 dir_pw_log = "$dir_pigweed/pw_log"
 dir_pw_log_basic = "$dir_pigweed/pw_log_basic"
+dir_pw_minimal_cpp_stdlib = "$dir_pigweed/pw_minimal_cpp_stdlib"
 dir_pw_module = "$dir_pigweed/pw_module"
 dir_pw_polyfill = "$dir_pigweed/pw_polyfill"
 dir_pw_preprocessor = "$dir_pigweed/pw_preprocessor"

diff --git a/pw_minimal_cpp_stdlib/BUILD b/pw_minimal_cpp_stdlib/BUILD
new file mode 100644
index 0000000..3e39d7b
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/BUILD

@@ -0,0 +1,70 @@
+# Copyright 2020 The Pigweed Authors
+#
+# 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
+#
+#     https://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.
+
+load(
+    "//pw_build:pigweed.bzl",
+    "pw_cc_library",
+    "pw_cc_test",
+)
+
+pw_cc_library(
+    name = "pw_minimal_cpp_stdlib",
+    srcs = [
+        "public/internal/algorithm.h",
+        "public/internal/array.h",
+        "public/internal/cinttypes.h",
+        "public/internal/cmath.h",
+        "public/internal/cstdarg.h",
+        "public/internal/cstddef.h",
+        "public/internal/cstdint.h",
+        "public/internal/cstdio.h",
+        "public/internal/cstring.h",
+        "public/internal/iterator.h",
+        "public/internal/limits.h",
+        "public/internal/new.h",
+        "public/internal/string_view.h",
+        "public/internal/type_traits.h",
+        "public/internal/utility.h",
+    ],
+    hdrs = [
+        "public/algorithm",
+        "public/array",
+        "public/cinttypes",
+        "public/cmath",
+        "public/cstdarg",
+        "public/cstddef",
+        "public/cstdint",
+        "public/cstdio",
+        "public/cstring",
+        "public/iterator",
+        "public/limits",
+        "public/new",
+        "public/string_view",
+        "public/type_traits",
+        "public/utility",
+    ],
+    copts = ["-nostdinc++"],
+    includes = ["public"],
+)
+
+pw_cc_test(
+    name = "test",
+    srcs = [
+        "test.cc",
+    ],
+    copts = ["-nostdinc++"],
+    deps = [
+        ":pw_minimal_cpp_stdlib",
+    ],
+)

diff --git a/pw_minimal_cpp_stdlib/BUILD.gn b/pw_minimal_cpp_stdlib/BUILD.gn
new file mode 100644
index 0000000..d9ac40f
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/BUILD.gn

@@ -0,0 +1,92 @@
+# Copyright 2020 The Pigweed Authors
+#
+# 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
+#
+#     https://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.
+
+import("$dir_pw_docgen/docs.gni")
+import("$dir_pw_unit_test/test.gni")
+
+config("include_dirs") {
+  include_dirs = [ "public" ]
+}
+
+config("no_cpp_includes") {
+  cflags = [ "-nostdinc++" ]
+}
+
+source_set("pw_minimal_cpp_stdlib") {
+  public_configs = [ ":include_dirs" ]
+  configs = [ ":no_cpp_includes" ]
+  public = [
+    "public/algorithm",
+    "public/array",
+    "public/cinttypes",
+    "public/cmath",
+    "public/cstdarg",
+    "public/cstddef",
+    "public/cstdint",
+    "public/cstdio",
+    "public/cstring",
+    "public/iterator",
+    "public/limits",
+    "public/new",
+    "public/string_view",
+    "public/type_traits",
+    "public/utility",
+  ]
+  sources = [
+    "public/internal/algorithm.h",
+    "public/internal/array.h",
+    "public/internal/cinttypes.h",
+    "public/internal/cmath.h",
+    "public/internal/cstdarg.h",
+    "public/internal/cstddef.h",
+    "public/internal/cstdint.h",
+    "public/internal/cstdio.h",
+    "public/internal/cstring.h",
+    "public/internal/iterator.h",
+    "public/internal/limits.h",
+    "public/internal/new.h",
+    "public/internal/string_view.h",
+    "public/internal/type_traits.h",
+    "public/internal/utility.h",
+  ]
+}
+
+pw_test_group("tests") {
+  tests = [
+    ":minimal_cpp_stdlib_test",
+    ":standard_library_test",
+  ]
+}
+
+pw_test("minimal_cpp_stdlib_test") {
+  configs = [ ":no_cpp_includes" ]
+  deps = [
+    ":pw_minimal_cpp_stdlib",
+  ]
+  sources = [
+    "test.cc",
+  ]
+}
+
+pw_test("standard_library_test") {
+  sources = [
+    "test.cc",
+  ]
+}
+
+pw_doc_group("docs") {
+  sources = [
+    "docs.rst",
+  ]
+}

diff --git a/pw_minimal_cpp_stdlib/CMakeLists.txt b/pw_minimal_cpp_stdlib/CMakeLists.txt
new file mode 100644
index 0000000..90f96cd
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright 2020 The Pigweed Authors
+#
+# 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
+#
+#     https://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.
+
+pw_auto_add_simple_module(pw_minimal_cpp_stdlib)

diff --git a/pw_minimal_cpp_stdlib/docs.rst b/pw_minimal_cpp_stdlib/docs.rst
new file mode 100644
index 0000000..904f369
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/docs.rst

@@ -0,0 +1,31 @@
+.. _chapter-pw-minimal-cpp-stdlib:
+
+.. default-domain:: cpp
+
+---------------------
+pw_minimal_cpp_stdlib
+---------------------
+The pw_minimal_cpp_stdlib module provides an extremely limited implementation of
+the C++ Standard Library. This module falls far, far short of providing a
+complete C++ Standard Library and should only be used in dire situations where
+you happen to be compiling with C++17 but don't have a C++ Standard Library
+available to you.
+
+The C++ Standard Library headers (e.g. ``<cstdint>`` and ``<type_traits>``) are
+defined in ``public/``. These files are symlinks to their implementations in
+``public/internal/``.
+
+.. tip::
+
+  You can automatically recreate the symlinks in ``public/`` by executing the
+  following Bash code from ``pw_minimal_cpp_stdlib/public/``.
+
+  .. code-block:: bash
+
+    for f in $(ls internal/); do ln -s internal/$f ${f%.h}; done
+
+Requirments
+===========
+- C++17
+- gcc or clang
+- The C Standard Library

diff --git a/pw_minimal_cpp_stdlib/public/algorithm b/pw_minimal_cpp_stdlib/public/algorithm
new file mode 120000
index 0000000..81f8692
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/algorithm

@@ -0,0 +1 @@
+internal/algorithm.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/array b/pw_minimal_cpp_stdlib/public/array
new file mode 120000
index 0000000..e9f7bca
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/array

@@ -0,0 +1 @@
+internal/array.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/cinttypes b/pw_minimal_cpp_stdlib/public/cinttypes
new file mode 120000
index 0000000..8b251e5
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/cinttypes

@@ -0,0 +1 @@
+internal/cinttypes.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/cmath b/pw_minimal_cpp_stdlib/public/cmath
new file mode 120000
index 0000000..caf5054
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/cmath

@@ -0,0 +1 @@
+internal/cmath.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/cstdarg b/pw_minimal_cpp_stdlib/public/cstdarg
new file mode 120000
index 0000000..5d649b5
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/cstdarg

@@ -0,0 +1 @@
+internal/cstdarg.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/cstddef b/pw_minimal_cpp_stdlib/public/cstddef
new file mode 120000
index 0000000..c351114
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/cstddef

@@ -0,0 +1 @@
+internal/cstddef.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/cstdint b/pw_minimal_cpp_stdlib/public/cstdint
new file mode 120000
index 0000000..749150f
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/cstdint

@@ -0,0 +1 @@
+internal/cstdint.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/cstdio b/pw_minimal_cpp_stdlib/public/cstdio
new file mode 120000
index 0000000..12ae705
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/cstdio

@@ -0,0 +1 @@
+internal/cstdio.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/cstring b/pw_minimal_cpp_stdlib/public/cstring
new file mode 120000
index 0000000..429e026
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/cstring

@@ -0,0 +1 @@
+internal/cstring.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/internal/algorithm.h b/pw_minimal_cpp_stdlib/public/internal/algorithm.h
new file mode 100644
index 0000000..2556702
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/algorithm.h

@@ -0,0 +1,40 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <type_traits>
+
+namespace std {
+
+template <typename T>
+constexpr const T& min(const T& lhs, const T& rhs) {
+  return (rhs < lhs) ? rhs : lhs;
+}
+
+template <typename T>
+constexpr const T& max(const T& lhs, const T& rhs) {
+  return (lhs < rhs) ? rhs : lhs;
+}
+
+template <typename T>
+constexpr T&& forward(remove_reference_t<T>& value) {
+  return static_cast<T&&>(value);
+}
+
+template <typename T>
+constexpr T&& forward(remove_reference_t<T>&& value) {
+  return static_cast<T&&>(value);
+}
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/array.h b/pw_minimal_cpp_stdlib/public/internal/array.h
new file mode 100644
index 0000000..80aeeca
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/array.h

@@ -0,0 +1,103 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <iterator>
+
+namespace std {
+
+template <typename T, decltype(sizeof(0)) kSize>
+struct array {
+  using value_type = T;
+  using size_type = decltype(kSize);
+  using difference_type =
+      decltype(static_cast<int*>(nullptr) - static_cast<int*>(nullptr));
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
+  using iterator = T*;
+  using const_iterator = const T*;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  // NOT IMPLEMENTED: at() does not bounds checking.
+  constexpr reference at(size_type index) { return data()[index]; }
+  constexpr const_reference at(size_type index) const { return data()[index]; }
+
+  constexpr reference operator[](size_type index) { return data()[index]; }
+  constexpr const_reference operator[](size_type index) const {
+    return data()[index];
+  }
+
+  constexpr reference front() { return data()[0]; }
+  constexpr const_reference front() const { return data()[0]; }
+
+  constexpr reference back() {
+    static_assert(kSize > 0);
+    return data()[size() - 1];
+  }
+  constexpr const_reference back() const {
+    static_assert(kSize > 0);
+    return data()[size() - 1];
+  }
+
+  constexpr pointer data() noexcept {
+    static_assert(kSize > 0);
+    return __data;
+  }
+  constexpr const_pointer data() const noexcept {
+    static_assert(kSize > 0);
+    return __data;
+  }
+
+  constexpr iterator begin() noexcept { return data(); }
+  constexpr const_iterator begin() const noexcept { return data(); }
+  constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+  constexpr iterator end() noexcept { return data() + kSize; }
+  constexpr const_iterator end() const noexcept { return data() + kSize; }
+  constexpr const_iterator cend() const noexcept { return end(); }
+
+  // NOT IMPLEMENTED
+  constexpr reverse_iterator rbegin() noexcept;
+  constexpr const_reverse_iterator rbegin() const noexcept;
+  constexpr const_reverse_iterator crbegin() const noexcept;
+
+  // NOT IMPLEMENTED
+  constexpr reverse_iterator rend() noexcept;
+  constexpr const_reverse_iterator rend() const noexcept;
+  constexpr const_reverse_iterator crend() const noexcept;
+
+  [[nodiscard]] constexpr bool empty() const noexcept { return kSize == 0u; }
+
+  constexpr size_type size() const noexcept { return kSize; }
+
+  constexpr size_type max_size() const noexcept { return size(); }
+
+  constexpr void fill(const T& value) {
+    for (T& array_value : __data) {
+      array_value = value;
+    }
+  }
+
+  // NOT IMPLEMENTED
+  constexpr void swap(array& other) noexcept;
+
+  T __data[kSize];
+};
+
+// NOT IMPLEMENTED: comparison operators, get, swap, tuple specializations
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/cinttypes.h b/pw_minimal_cpp_stdlib/public/internal/cinttypes.h
new file mode 100644
index 0000000..5141862
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/cinttypes.h

@@ -0,0 +1,16 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include "inttypes.h"

diff --git a/pw_minimal_cpp_stdlib/public/internal/cmath.h b/pw_minimal_cpp_stdlib/public/internal/cmath.h
new file mode 100644
index 0000000..cec4a7e
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/cmath.h

@@ -0,0 +1,55 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <math.h>
+
+namespace std {
+
+// The integer overloads of these functions are not provided.
+
+// This is not technically correct, but avoids ambiguous calls to an overloaded
+// abs function.
+template <typename T>
+inline T abs(T value) {
+  return value < 0 ? -value : value;
+}
+
+#ifdef isfinite
+#undef isfinite
+#endif  // isfinite
+
+inline bool isfinite(float value) { return __builtin_isfinite(value); }
+inline bool isfinite(double value) { return __builtin_isfinite(value); }
+inline bool isfinite(long double value) { return __builtin_isfinite(value); }
+
+#ifdef isnan
+#undef isnan
+#endif  // isnan
+
+inline bool isnan(float value) { return __builtin_isnan(value); }
+inline bool isnan(double value) { return __builtin_isnan(value); }
+inline bool isnan(long double value) { return __builtin_isnan(value); }
+
+#ifdef signbit
+#undef signbit
+#endif  // signbit
+
+inline bool signbit(float value) { return __builtin_signbit(value); }
+inline bool signbit(double value) { return __builtin_signbit(value); }
+inline bool signbit(long double value) { return __builtin_signbit(value); }
+
+using ::round;
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/cstdarg.h b/pw_minimal_cpp_stdlib/public/internal/cstdarg.h
new file mode 100644
index 0000000..8d31c67
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/cstdarg.h

@@ -0,0 +1,22 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <stdarg.h>
+
+namespace std {
+
+using ::va_list;
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/cstddef.h b/pw_minimal_cpp_stdlib/public/internal/cstddef.h
new file mode 100644
index 0000000..bcb7bb2
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/cstddef.h

@@ -0,0 +1,74 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <stddef.h>
+
+namespace std {
+
+using ::ptrdiff_t;
+using ::size_t;
+using nullptr_t = decltype(nullptr);
+using ::max_align_t;
+
+#define __cpp_lib_byte 201603L
+
+enum class byte : unsigned char {};
+
+template <typename I>
+constexpr I to_integer(byte b) noexcept {
+  return I(b);
+}
+
+constexpr byte operator|(byte l, byte r) noexcept {
+  return byte(static_cast<unsigned int>(l) | static_cast<unsigned int>(r));
+}
+
+constexpr byte operator&(byte l, byte r) noexcept {
+  return byte(static_cast<unsigned int>(l) & static_cast<unsigned int>(r));
+}
+
+constexpr byte operator^(byte l, byte r) noexcept {
+  return byte(static_cast<unsigned int>(l) ^ static_cast<unsigned int>(r));
+}
+
+constexpr byte operator~(byte b) noexcept {
+  return byte(~static_cast<unsigned int>(b));
+}
+
+template <typename I>
+constexpr byte operator<<(byte b, I shift) noexcept {
+  return byte(static_cast<unsigned int>(b) << shift);
+}
+
+template <typename I>
+constexpr byte operator>>(byte b, I shift) noexcept {
+  return byte(static_cast<unsigned int>(b) >> shift);
+}
+
+constexpr byte& operator|=(byte& l, byte r) noexcept { return l = l | r; }
+constexpr byte& operator&=(byte& l, byte r) noexcept { return l = l & r; }
+constexpr byte& operator^=(byte& l, byte r) noexcept { return l = l ^ r; }
+
+template <typename I>
+inline byte& operator<<=(byte& b, I shift) noexcept {
+  return b = b << shift;
+}
+
+template <typename I>
+inline byte& operator>>=(byte& b, I shift) noexcept {
+  return b = b >> shift;
+}
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/cstdint.h b/pw_minimal_cpp_stdlib/public/internal/cstdint.h
new file mode 100644
index 0000000..abe9e04
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/cstdint.h

@@ -0,0 +1,16 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include "stdint.h"

diff --git a/pw_minimal_cpp_stdlib/public/internal/cstdio.h b/pw_minimal_cpp_stdlib/public/internal/cstdio.h
new file mode 100644
index 0000000..0a4bae6
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/cstdio.h

@@ -0,0 +1,32 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <stdio.h>
+
+namespace std {
+
+using ::size_t;
+
+// Only a small subset of functions are exposed here.
+
+using ::putchar;
+using ::puts;
+using ::snprintf;
+using ::vsnprintf;
+
+using ::getchar;
+using ::sscanf;
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/cstring.h b/pw_minimal_cpp_stdlib/public/internal/cstring.h
new file mode 100644
index 0000000..b2f08ad
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/cstring.h

@@ -0,0 +1,39 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <string.h>
+
+namespace std {
+
+using ::size_t;
+
+// Only a small subset of functions are exposed here.
+
+using ::memchr;
+using ::memcmp;
+using ::memcpy;
+using ::memmove;
+using ::memset;
+
+using ::strcat;
+using ::strcpy;
+using ::strncat;
+using ::strncpy;
+
+using ::strcmp;
+using ::strlen;
+using ::strncmp;
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/iterator.h b/pw_minimal_cpp_stdlib/public/internal/iterator.h
new file mode 100644
index 0000000..9c5e9ad
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/iterator.h

@@ -0,0 +1,51 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <cstddef>
+
+namespace std {
+
+#define __cpp_lib_nonmember_container_access 201411L
+
+template <typename C>
+constexpr auto data(C& container) -> decltype(container.data()) {
+  return container.data();
+}
+
+template <typename C>
+constexpr auto data(const C& container) -> decltype(container.data()) {
+  return container.data();
+}
+
+template <typename T, decltype(sizeof(int)) kSize>
+constexpr T* data(T (&array)[kSize]) noexcept {
+  return array;
+}
+
+template <typename C>
+constexpr auto size(const C& container) -> decltype(container.size()) {
+  return container.size();
+}
+
+template <typename T, decltype(sizeof(int)) kSize>
+constexpr decltype(sizeof(int)) size(const T (&)[kSize]) noexcept {
+  return kSize;
+}
+
+// NOT IMPLEMENTED: Reverse iterators are not implemented.
+template <typename>
+struct reverse_iterator;
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/limits.h b/pw_minimal_cpp_stdlib/public/internal/limits.h
new file mode 100644
index 0000000..6c14180
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/limits.h

@@ -0,0 +1,65 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <limits.h>
+
+namespace std {
+
+template <typename T>
+struct numeric_limits {
+  static constexpr bool is_specialized = false;
+};
+
+// Only a few of the numeric_limits methods are implemented.
+#define _PW_LIMITS_SPECIALIZATION(                               \
+    type, val_signed, val_int, min_value, max_value)             \
+  template <>                                                    \
+  struct numeric_limits<type> {                                  \
+    static constexpr bool is_specialized = true;                 \
+                                                                 \
+    static constexpr bool is_signed = (val_signed);              \
+    static constexpr bool is_integer = (val_int);                \
+                                                                 \
+    static constexpr type min() noexcept { return (min_value); } \
+    static constexpr type max() noexcept { return (max_value); } \
+  }
+
+#define _PW_INTEGRAL_LIMIT(type, sname, uname)            \
+  _PW_LIMITS_SPECIALIZATION(                              \
+      signed type, true, true, sname##_MIN, sname##_MAX); \
+  _PW_LIMITS_SPECIALIZATION(unsigned type, false, true, 0u, uname##_MAX)
+
+_PW_LIMITS_SPECIALIZATION(bool, false, true, false, true);
+_PW_LIMITS_SPECIALIZATION(char, char(-1) < char(0), true, CHAR_MIN, CHAR_MAX);
+
+_PW_INTEGRAL_LIMIT(char, SCHAR, UCHAR);
+_PW_INTEGRAL_LIMIT(short, SHRT, USHRT);
+_PW_INTEGRAL_LIMIT(int, INT, UINT);
+_PW_INTEGRAL_LIMIT(long, LONG, ULONG);
+
+#ifndef LLONG_MIN
+#define LLONG_MIN ((long long)(~0ull ^ (~0ull >> 1)))
+#define LLONG_MAX ((long long)(~0ull >> 1))
+
+#define ULLONG_MIN (0ull)
+#define ULLONG_MAX (~0ull)
+#endif  // LLONG_MIN
+
+_PW_INTEGRAL_LIMIT(long long, LLONG, ULLONG);
+
+#undef _PW_LIMITS_SPECIALIZATION
+#undef _PW_INTEGRAL_LIMIT
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/new.h b/pw_minimal_cpp_stdlib/public/internal/new.h
new file mode 100644
index 0000000..d21d991
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/new.h

@@ -0,0 +1,17 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+// Placement new
+inline void* operator new(decltype(sizeof(0)), void* ptr) { return ptr; }

diff --git a/pw_minimal_cpp_stdlib/public/internal/string_view.h b/pw_minimal_cpp_stdlib/public/internal/string_view.h
new file mode 100644
index 0000000..65ee858
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/string_view.h

@@ -0,0 +1,174 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+
+#define __cpp_lib_string_view 201606L
+
+namespace std {
+
+template <typename T>
+class basic_string_view {
+ public:
+  using traits_type = void;  // No traits object is used.
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using const_iterator = const T*;
+  using iterator = const_iterator;
+  using const_reverse_iterator = ::std::reverse_iterator<const_iterator>;
+  using reverse_iterator = const_reverse_iterator;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+
+  static constexpr size_type npos = size_type(-1);
+
+  constexpr basic_string_view() noexcept : string_(nullptr), size_(0) {}
+  constexpr basic_string_view(const basic_string_view&) noexcept = default;
+  constexpr basic_string_view(const T* string, size_type count)
+      : string_(string), size_(count) {}
+  constexpr basic_string_view(const T* string)
+      : string_(string), size_(CStringLength(string)) {}
+
+  constexpr basic_string_view& operator=(const basic_string_view&) noexcept =
+      default;
+
+  constexpr const_iterator begin() const noexcept { return string_; }
+  constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+  constexpr const_iterator end() const noexcept { return string_ + size_; }
+  constexpr const_iterator cend() const noexcept { return end(); }
+
+  // NOT IMPLEMENTED: Reverse iterators not supported.
+  constexpr const_reverse_iterator rbegin() const noexcept;
+  constexpr const_reverse_iterator crbegin() const noexcept;
+
+  constexpr const_reverse_iterator rend() const noexcept;
+  constexpr const_reverse_iterator crend() const noexcept;
+
+  constexpr const_reference operator[](size_type pos) const {
+    return data()[pos];
+  }
+
+  // NOT IMPLEMENTED: at() has no bounds checking.
+  constexpr const_reference at(size_type pos) const { return data()[pos]; }
+
+  constexpr const_reference front() const { return data()[0]; }
+
+  constexpr const_reference back() const { return data()[size() - 1]; }
+
+  constexpr const_pointer data() const noexcept { return string_; }
+
+  constexpr size_type size() const noexcept { return size_; }
+  constexpr size_type length() const noexcept { return size(); }
+
+  constexpr size_type max_size() const noexcept { return ~size_t{0}; }
+
+  [[nodiscard]] constexpr bool empty() const noexcept { return size() == 0u; }
+
+  constexpr void remove_prefix(size_type characters) {
+    string_ += characters;
+    size_ -= characters;
+  }
+
+  constexpr void remove_suffix(size_type characters) { size_ -= characters; }
+
+  constexpr void swap(basic_string_view& other) noexcept {
+    pointer temp_string = string_;
+    string_ = other.string_;
+    other.string_ = temp_string;
+
+    size_type temp_size = size_;
+    size_ = other.size_;
+    other.size_ = temp_size;
+  }
+
+  // NOT IMPLEMENTED: copy does no bounds checking.
+  constexpr size_type copy(T* dest, size_type count, size_type pos = 0) const {
+    const size_type to_copy = min(count, size() - pos);
+    for (size_type i = pos; i < pos + to_copy; ++i) {
+      *dest++ = string_[i];
+    }
+    return to_copy;
+  }
+
+  constexpr basic_string_view substr(size_type pos = 0,
+                                     size_type count = npos) const {
+    return basic_string_view(string_ + pos, min(count, size() - pos));
+  }
+
+  // NOT IMPLEMENTED: These functions and their overloads are not defined.
+  constexpr int compare(basic_string_view view) const noexcept;
+  constexpr bool starts_with(basic_string_view view) const noexcept;
+  constexpr bool ends_with(basic_string_view view) const noexcept;
+  constexpr size_type find(basic_string_view view,
+                           size_type pos = 0) const noexcept;
+  constexpr size_type rfind(basic_string_view view,
+                            size_type pos = npos) const noexcept;
+  constexpr size_type find_first_of(basic_string_view view,
+                                    size_type pos = 0) const noexcept;
+  constexpr size_type find_last_of(basic_string_view view,
+                                   size_type pos = npos) const noexcept;
+  constexpr size_type find_first_not_of(basic_string_view view,
+                                        size_type pos = 0) const noexcept;
+  constexpr size_type find_last_not_of(basic_string_view view,
+                                       size_type pos = npos) const noexcept;
+
+ private:
+  static constexpr size_type CStringLength(const T* string) {
+    size_type length = 0;
+    while (string[length] != T()) {
+      length += 1;
+    }
+    return length;
+  }
+
+  const_pointer string_;
+  size_type size_;
+};
+
+template <typename T>
+constexpr bool operator==(basic_string_view<T> lhs, basic_string_view<T> rhs) {
+  if (lhs.size() != rhs.size()) {
+    return false;
+  }
+  for (typename basic_string_view<T>::size_type i = 0; i < lhs.size(); ++i) {
+    if (lhs[i] != rhs[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <typename T>
+constexpr bool operator!=(basic_string_view<T> lhs, basic_string_view<T> rhs) {
+  return !(lhs == rhs);
+}
+
+// NOT IMPLEMENTED: Other comparison operators are not defined.
+
+using string_view = basic_string_view<char>;
+using wstring_view = basic_string_view<wchar_t>;
+using u16string_view = basic_string_view<char16_t>;
+using u32string_view = basic_string_view<char32_t>;
+
+// NOT IMPLEMENTED: string_view literals cannot be implemented since they do not
+//                  start with _.
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/type_traits.h b/pw_minimal_cpp_stdlib/public/internal/type_traits.h
new file mode 100644
index 0000000..422b2df
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/type_traits.h

@@ -0,0 +1,425 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+namespace std {
+
+#define __cpp_lib_transformation_trait_aliases 201304L
+#define __cpp_lib_type_trait_variable_templates 201510L
+
+template <decltype(sizeof(0)) kLength,
+          decltype(sizeof(0)) kAlignment>  // no default
+struct aligned_storage {
+  struct type {
+    alignas(kAlignment) unsigned char __data[kLength];
+  };
+};
+
+template <decltype(sizeof(0)) kLength,
+          decltype(sizeof(0)) kAlignment>  // no default
+using aligned_storage_t = typename aligned_storage<kLength, kAlignment>::type;
+
+#define __cpp_lib_integral_constant_callable 201304L
+
+template <typename T, T kValue>
+struct integral_constant {
+  using value_type = T;
+  using type = integral_constant;
+
+  static constexpr T value = kValue;
+
+  constexpr operator value_type() const noexcept { return value; }
+
+  constexpr value_type operator()() const noexcept { return value; }
+};
+
+#define __cpp_lib_bool_constant 201505L
+
+template <bool kValue>
+using bool_constant = integral_constant<bool, kValue>;
+
+using true_type = bool_constant<true>;
+using false_type = bool_constant<false>;
+
+template <typename T>
+struct is_array : false_type {};
+
+template <typename T>
+struct is_array<T[]> : true_type {};
+
+template <typename T, decltype(sizeof(int)) kSize>
+struct is_array<T[kSize]> : true_type {};
+
+template <typename T>
+inline constexpr bool is_array_v = is_array<T>::value;
+
+template <typename T>
+struct is_const : false_type {};
+
+template <typename T>
+struct is_const<const T> : true_type {};
+
+// NOT IMPLEMENTED: is_enum requires compiler builtins.
+template <typename T>
+struct is_enum : false_type {};
+
+template <typename T>
+inline constexpr bool is_enum_v = is_enum<T>::value;
+
+template <typename T>
+struct remove_cv;  // Forward declaration
+
+namespace impl {
+
+template <typename T>
+struct is_floating_point : false_type {};
+
+template <>
+struct is_floating_point<float> : true_type {};
+template <>
+struct is_floating_point<double> : true_type {};
+template <>
+struct is_floating_point<long double> : true_type {};
+
+}  // namespace impl
+
+template <typename T>
+struct is_floating_point
+    : impl::is_floating_point<typename remove_cv<T>::type> {};
+
+template <typename T>
+inline constexpr bool is_floating_point_v = is_floating_point<T>::value;
+
+namespace impl {
+
+template <typename T>
+struct is_integral : false_type {};
+
+template <>
+struct is_integral<bool> : true_type {};
+template <>
+struct is_integral<char> : true_type {};
+template <>
+struct is_integral<char16_t> : true_type {};
+template <>
+struct is_integral<char32_t> : true_type {};
+template <>
+struct is_integral<wchar_t> : true_type {};
+
+template <>
+struct is_integral<short> : true_type {};
+template <>
+struct is_integral<unsigned short> : true_type {};
+template <>
+struct is_integral<int> : true_type {};
+template <>
+struct is_integral<unsigned int> : true_type {};
+template <>
+struct is_integral<long> : true_type {};
+template <>
+struct is_integral<unsigned long> : true_type {};
+template <>
+struct is_integral<long long> : true_type {};
+template <>
+struct is_integral<unsigned long long> : true_type {};
+
+}  // namespace impl
+
+template <typename T>
+struct is_integral : impl::is_integral<typename remove_cv<T>::type> {};
+
+template <typename T>
+inline constexpr bool is_integral_v = is_integral<T>::value;
+
+template <typename T>
+struct is_arithmetic
+    : bool_constant<is_integral_v<T> || is_floating_point_v<T>> {};
+
+template <typename T>
+inline constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
+
+#define __cpp_lib_is_null_pointer 201309L
+
+template <typename T>
+struct is_null_pointer : false_type {};
+
+template <>
+struct is_null_pointer<decltype(nullptr)> : true_type {};
+
+template <typename T>
+inline constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
+
+template <typename T>
+struct is_pointer : false_type {};
+
+template <typename T>
+struct is_pointer<T*> : true_type {};
+
+template <typename T>
+inline constexpr bool is_pointer_v = is_pointer<T>::value;
+
+template <typename T, typename U>
+struct is_same : false_type {};
+
+template <typename T>
+struct is_same<T, T> : true_type {};
+
+template <typename T, typename U>
+inline constexpr bool is_same_v = is_same<T, U>::value;
+
+namespace impl {
+
+template <typename T, bool = is_arithmetic<T>::value>
+struct is_signed : integral_constant<bool, T(-1) < T(0)> {};
+
+template <typename T>
+struct is_signed<T, false> : false_type {};
+
+}  // namespace impl
+
+template <typename T>
+struct is_signed : impl::is_signed<T>::type {};
+
+template <typename T>
+inline constexpr bool is_signed_v = is_signed<T>::value;
+
+template <typename T>
+struct is_unsigned : bool_constant<!is_signed_v<T>> {};
+
+template <typename T>
+inline constexpr bool is_unsigned_v = is_unsigned<T>::value;
+
+template <typename T>
+struct is_void : is_same<void, typename remove_cv<T>::type> {};
+
+template <typename T>
+inline constexpr bool is_void_v = is_void<T>::value;
+
+template <bool kBool, typename TrueType, typename FalseType>
+struct conditional {
+  using type = TrueType;
+};
+
+template <typename TrueType, typename FalseType>
+struct conditional<false, TrueType, FalseType> {
+  using type = FalseType;
+};
+
+template <bool kBool, typename TrueType, typename FalseType>
+using conditional_t = typename conditional<kBool, TrueType, FalseType>::type;
+
+template <bool kEnable, typename T = void>
+struct enable_if {
+  using type = T;
+};
+
+template <typename T>
+struct enable_if<false, T> {};
+
+template <bool kEnable, typename T = void>
+using enable_if_t = typename enable_if<kEnable, T>::type;
+
+template <typename T>
+struct remove_const {
+  using type = T;
+};
+
+template <typename T>
+struct remove_const<const T> {
+  using type = T;
+};
+
+template <typename T>
+using remove_const_t = typename remove_const<T>::type;
+
+template <typename T>
+struct remove_volatile {
+  using type = T;
+};
+
+template <typename T>
+struct remove_volatile<volatile T> {
+  using type = T;
+};
+
+template <typename T>
+using remove_volatile_t = typename remove_volatile<T>::type;
+
+template <typename T>
+struct remove_cv {
+  using type = remove_volatile_t<remove_const_t<T>>;
+};
+
+template <typename T>
+using remove_cv_t = typename remove_cv<T>::type;
+
+template <typename T>
+struct remove_extent {
+  using type = T;
+};
+
+template <typename T>
+struct remove_extent<T[]> {
+  using type = T;
+};
+
+template <typename T, decltype(sizeof(0)) kSize>
+struct remove_extent<T[kSize]> {
+  using type = T;
+};
+
+template <typename T>
+using remove_extent_t = typename remove_extent<T>::type;
+
+template <typename T>
+struct remove_pointer {
+  using type = T;
+};
+
+template <typename T>
+struct remove_pointer<T*> {
+  using type = T;
+};
+
+template <typename T>
+struct remove_pointer<T* const> {
+  using type = T;
+};
+
+template <typename T>
+struct remove_pointer<T* volatile> {
+  using type = T;
+};
+
+template <typename T>
+struct remove_pointer<T* const volatile> {
+  using type = T;
+};
+
+template <typename T>
+using remove_pointer_t = typename remove_pointer<T>::type;
+
+template <typename T>
+struct remove_reference {
+  using type = T;
+};
+
+template <typename T>
+struct remove_reference<T&> {
+  using type = T;
+};
+
+template <typename T>
+struct remove_reference<T&&> {
+  using type = T;
+};
+
+template <typename T>
+using remove_reference_t = typename remove_reference<T>::type;
+
+// NOT IMPLEMENTED: This implementation is INCOMPLETE, as it does not cover
+// function types.
+template <typename T>
+struct decay {
+ private:
+  using U = remove_reference_t<T>;
+
+ public:
+  using type =
+      conditional_t<is_array<U>::value, remove_extent_t<U>*, remove_cv_t<U>>;
+};
+
+template <typename T>
+using decay_t = typename decay<T>::type;
+
+#define __cpp_lib_type_identity 201806
+
+template <class T>
+struct type_identity {
+  using type = T;
+};
+
+template <typename T>
+using type_identity_t = typename type_identity<T>::type;
+
+#define __cpp_lib_void_t void_t 201411L
+
+template <typename...>
+using void_t = void;
+
+// NOT IMPLEMENTED: add_rvalue_refernce does work with reference types.
+template <typename T>
+struct add_rvalue_reference {
+  using type = T&&;
+};
+
+template <typename T>
+using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+
+template <typename T>
+add_rvalue_reference_t<T> declval() noexcept;
+
+namespace impl {
+
+template <typename>
+using templated_true = true_type;
+
+template <typename T>
+auto returnable(int) -> templated_true<T()>;
+
+template <typename>
+auto returnable(...) -> false_type;
+
+template <typename From, typename To>
+auto convertible(int)
+    -> templated_true<decltype(declval<void (&)(To)>()(declval<From>()))>;
+
+template <typename, typename>
+auto convertible(...) -> false_type;
+
+}  // namespace impl
+
+template <typename From, typename To>
+struct is_convertible
+    : bool_constant<(decltype(impl::returnable<To>(0))() &&
+                     decltype(impl::convertible<From, To>(0))()) ||
+                    (is_void_v<From> && is_void_v<To>)> {};
+
+template <typename T, typename U>
+inline constexpr bool is_convertible_v = is_convertible<T, U>::value;
+
+// NOT IMPLEMENTED: Stubs are provided for these traits classes, but they do not
+// return useful values. Many of these would require compiler builtins.
+template <typename T>
+struct is_function : false_type {};
+template <typename T>
+struct is_trivially_copyable : true_type {};
+template <typename T>
+struct is_polymorphic : false_type {};
+template <typename T, typename U>
+struct is_base_of : false_type {};
+template <typename T>
+struct extent : integral_constant<decltype(sizeof(int)), 1> {};
+template <typename T>
+inline constexpr bool extent_v = extent<T>::value;
+template <typename T>
+struct underlying_type {
+  using type = T;
+};
+template <typename T>
+using underlying_type_t = typename underlying_type<T>::type;
+template <typename T>
+inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<T>::value;
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/internal/utility.h b/pw_minimal_cpp_stdlib/public/internal/utility.h
new file mode 100644
index 0000000..6d238f7
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/internal/utility.h

@@ -0,0 +1,25 @@
+// Copyright 2020 The Pigweed Authors
+//
+// 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
+//
+//     https://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.
+#pragma once
+
+namespace std {
+
+// Forward declare these classes, which are specialized in other headers.
+template <decltype(sizeof(0)), typename>
+struct tuple_element;
+
+template <typename>
+struct tuple_size;
+
+}  // namespace std

diff --git a/pw_minimal_cpp_stdlib/public/iterator b/pw_minimal_cpp_stdlib/public/iterator
new file mode 120000
index 0000000..4703aa8
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/iterator

@@ -0,0 +1 @@
+internal/iterator.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/limits b/pw_minimal_cpp_stdlib/public/limits
new file mode 120000
index 0000000..8309de0
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/limits

@@ -0,0 +1 @@
+internal/limits.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/new b/pw_minimal_cpp_stdlib/public/new
new file mode 120000
index 0000000..ed0129c
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/new

@@ -0,0 +1 @@
+internal/new.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/string_view b/pw_minimal_cpp_stdlib/public/string_view
new file mode 120000
index 0000000..8e1be67
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/string_view

@@ -0,0 +1 @@
+internal/string_view.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/type_traits b/pw_minimal_cpp_stdlib/public/type_traits
new file mode 120000
index 0000000..71b1217
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/type_traits

@@ -0,0 +1 @@
+internal/type_traits.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/public/utility b/pw_minimal_cpp_stdlib/public/utility
new file mode 120000
index 0000000..58c32f2
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/public/utility

@@ -0,0 +1 @@
+internal/utility.h
\ No newline at end of file

diff --git a/pw_minimal_cpp_stdlib/test.cc b/pw_minimal_cpp_stdlib/test.cc
new file mode 100644
index 0000000..1d9c6c3
--- /dev/null
+++ b/pw_minimal_cpp_stdlib/test.cc

@@ -0,0 +1,151 @@
+// Copyright 2019 The Pigweed Authors
+//
+// 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
+//
+//     https://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 all of the provided headers, even if they aren't tested.
+#include <algorithm>
+#include <array>
+#include <cinttypes>
+#include <cmath>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <new>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(Algorithm, Basic) {
+  static_assert(std::min(1, 2) == 1);
+  static_assert(std::max(1, 2) == 2);
+
+  EXPECT_EQ(std::forward<int>(2), 2);
+}
+
+TEST(Array, Basic) {
+  constexpr std::array<int, 4> array{0, 1, 2, 3};
+
+  static_assert(array[2] == 2);
+
+  for (int i = 0; i < static_cast<int>(array.size()); ++i) {
+    EXPECT_EQ(i, array[i]);
+  }
+}
+
+TEST(Cmath, Basic) {
+  EXPECT_EQ(std::abs(-1), 1);
+  EXPECT_EQ(std::abs(1), 1);
+
+  EXPECT_TRUE(std::isfinite(1.0));
+  EXPECT_FALSE(std::isfinite(1.0 / 0.0));
+
+  EXPECT_FALSE(std::isnan(1.0));
+  EXPECT_TRUE(std::isnan(0.0 / 0.0));
+
+  EXPECT_FALSE(std::signbit(1.0));
+  EXPECT_TRUE(std::signbit(-1.0));
+}
+
+TEST(Cstddef, Basic) {
+  using std::byte;
+  byte foo = byte{12};
+  EXPECT_EQ(foo, byte{12});
+}
+
+TEST(Iterator, Basic) {
+  std::array<int, 3> foo{3, 2, 1};
+
+  EXPECT_EQ(std::data(foo), foo.data());
+  EXPECT_EQ(std::size(foo), foo.size());
+
+  foo.fill(99);
+  EXPECT_EQ(foo[0], 99);
+  EXPECT_EQ(foo[1], 99);
+  EXPECT_EQ(foo[2], 99);
+}
+
+TEST(Limits, Basic) {
+  static_assert(std::numeric_limits<unsigned char>::is_specialized);
+  static_assert(std::numeric_limits<unsigned char>::is_integer);
+  static_assert(std::numeric_limits<unsigned char>::min() == 0u);
+  static_assert(std::numeric_limits<unsigned char>::max() == 255u);
+
+  static_assert(std::numeric_limits<signed char>::is_specialized);
+  static_assert(std::numeric_limits<signed char>::is_integer);
+  static_assert(std::numeric_limits<signed char>::min() == -128);
+  static_assert(std::numeric_limits<signed char>::max() == 127);
+
+  // Assume 64-bit long long
+  static_assert(std::numeric_limits<long long>::is_specialized);
+  static_assert(std::numeric_limits<long long>::is_integer);
+  static_assert(std::numeric_limits<long long>::min() ==
+                (-9223372036854775807ll - 1));
+  static_assert(std::numeric_limits<long long>::max() == 9223372036854775807ll);
+
+  static_assert(std::numeric_limits<unsigned long long>::is_specialized);
+  static_assert(std::numeric_limits<unsigned long long>::is_integer);
+  static_assert(std::numeric_limits<unsigned long long>::min() == 0u);
+  static_assert(std::numeric_limits<unsigned long long>::max() ==
+                18446744073709551615ull);
+}
+
+TEST(New, Basic) {
+  unsigned char value[4];
+  new (value) int(1234);
+
+  int int_value;
+  std::memcpy(&int_value, value, sizeof(int_value));
+  EXPECT_EQ(1234, int_value);
+}
+
+TEST(StringView, Basic) {
+  constexpr std::string_view value("1234567890");
+  static_assert(value.size() == 10);
+  static_assert(value[1] == '2');
+
+  char buffer[] = "!!!!!";
+  constexpr size_t buffer_size = sizeof(buffer) - 1;  // always keep the \0
+
+  value.copy(buffer, buffer_size, 10);
+  EXPECT_STREQ(buffer, "!!!!!");
+
+  value.copy(buffer, buffer_size, 9);
+  EXPECT_STREQ(buffer, "0!!!!");
+
+  value.copy(buffer, buffer_size, 2);
+  EXPECT_STREQ(buffer, "34567");
+
+  value.copy(buffer, buffer_size);
+  EXPECT_STREQ(buffer, "12345");
+}
+
+TEST(TypeTraits, Basic) {
+  static_assert(std::is_integral_v<bool>);
+  static_assert(!std::is_integral_v<float>);
+
+  static_assert(std::is_floating_point_v<float>);
+  static_assert(!std::is_floating_point_v<bool>);
+
+  static_assert(std::is_same_v<float, float>);
+  static_assert(!std::is_same_v<char, unsigned char>);
+}
+
+}  // namespace