diff --git a/libc/src/__support/CPP/functional.h b/libc/src/__support/CPP/functional.h
--- a/libc/src/__support/CPP/functional.h
+++ b/libc/src/__support/CPP/functional.h
@@ -9,19 +9,51 @@
 #ifndef LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_FUNCTIONAL_H
 
+#include "src/__support/CPP/type_traits.h"
+#include "src/__support/CPP/utility.h"
+#include "src/__support/macros/attributes.h"
+
+#include <stdint.h>
+
 namespace __llvm_libc {
 namespace cpp {
 
-template <typename F> class function;
+/// A function type adapted from LLVM's function_ref type. This class does not
+/// own the callable, so it is not in general safe to store a function_ref.
+template <typename Fn> class function;
 
-template <typename R, typename... Args> class function<R(Args...)> {
-  R (*func)(Args...) = nullptr;
+template <typename Ret, typename... Params> class function<Ret(Params...)> {
+  Ret (*callback)(intptr_t callable, Params... params) = nullptr;
+  intptr_t callable;
 
-public:
-  constexpr function() = default;
-  template <typename F> constexpr function(F &&f) : func(f) {}
+  template <typename Callable>
+  LIBC_INLINE static Ret callback_fn(intptr_t callable, Params... params) {
+    return (*reinterpret_cast<Callable *>(callable))(
+        forward<Params>(params)...);
+  }
 
-  constexpr R operator()(Args... params) { return func(params...); }
+public:
+  LIBC_INLINE function() = default;
+  LIBC_INLINE function(decltype(nullptr)) {}
+  LIBC_INLINE ~function() = default;
+
+  template <typename Callable>
+  LIBC_INLINE function(
+      Callable &&callable,
+      enable_if_t<!is_same<remove_cvref_t<Callable>, function>::value> * =
+          nullptr,
+      cpp::enable_if_t<cpp::is_void<Ret>::value ||
+                       cpp::is_convertible<decltype(cpp::declval<Callable>()(
+                                               cpp::declval<Params>()...)),
+                                           Ret>::value> * = nullptr)
+      : callback(callback_fn<remove_reference_t<Callable>>),
+        callable(reinterpret_cast<intptr_t>(&callable)) {}
+
+  LIBC_INLINE Ret operator()(Params... params) const {
+    return callback(callable, forward<Params>(params)...);
+  }
+
+  LIBC_INLINE explicit operator bool() const { return callback; }
 };
 
 } // namespace cpp
diff --git a/libc/src/__support/CPP/type_traits.h b/libc/src/__support/CPP/type_traits.h
--- a/libc/src/__support/CPP/type_traits.h
+++ b/libc/src/__support/CPP/type_traits.h
@@ -12,7 +12,9 @@
 namespace __llvm_libc {
 namespace cpp {
 
-template <typename T> struct type_identity { using type = T; };
+template <typename T> struct type_identity {
+  using type = T;
+};
 
 template <bool B, typename T> struct enable_if;
 template <typename T> struct enable_if<true, T> : type_identity<T> {};
@@ -49,6 +51,19 @@
 template <typename T> struct remove_cv<const volatile T> : type_identity<T> {};
 template <typename T> using remove_cv_t = typename remove_cv<T>::type;
 
+template <typename T> struct remove_reference : type_identity<T> {};
+template <typename T> struct remove_reference<T &> : type_identity<T> {};
+template <typename T> struct remove_reference<T &&> : type_identity<T> {};
+template <typename T>
+using remove_reference_t = typename remove_reference<T>::type;
+
+template <typename T> struct add_rvalue_reference : type_identity<T &&> {};
+
+template <typename T> struct remove_cvref {
+  using type = remove_cv_t<remove_reference_t<T>>;
+};
+template <typename T> using remove_cvref_t = typename remove_cvref<T>::type;
+
 namespace details {
 template <typename T, typename... Args> constexpr bool is_unqualified_any_of() {
   return (... || is_same_v<remove_cv_t<T>, Args>);
@@ -148,6 +163,31 @@
 template <bool B, typename T, typename F>
 using conditional_t = typename conditional<B, T, F>::type;
 
+template <typename T> typename add_rvalue_reference<T>::type declval() {}
+
+template <typename T>
+struct is_void : cpp::is_same<void, typename remove_cv<T>::type> {};
+
+// Compile time checks on implicit conversions.
+namespace details {
+// Return the true type if T can be returned, otherwise return false type.
+template <typename T>
+decltype(void(static_cast<T (*)()>(nullptr)), true_type{}) returnable(int);
+template <typename> false_type returnable(...);
+// Return the true type if T can be converted to F, otherwise return false type.
+template <typename F, typename T>
+decltype(void(declval<void (&)(T)>()(declval<F>())), true_type{})
+implicitly_convertible(int);
+template <typename, typename> false_type implicitly_convertible(...);
+} // namespace details
+
+template <typename F, typename T>
+struct is_convertible
+    : integral_constant<bool, (decltype(details::returnable<T>(0))::value &&
+                               decltype(details::implicitly_convertible<F, T>(
+                                   0))::value) ||
+                                  (is_void<F>::value && is_void<T>::value)> {};
+
 } // namespace cpp
 } // namespace __llvm_libc
 
diff --git a/libc/src/__support/CPP/utility.h b/libc/src/__support/CPP/utility.h
--- a/libc/src/__support/CPP/utility.h
+++ b/libc/src/__support/CPP/utility.h
@@ -10,6 +10,7 @@
 #define LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H
 
 #include "src/__support/CPP/type_traits.h"
+#include "src/__support/macros/attributes.h"
 
 namespace __llvm_libc::cpp {
 
@@ -35,6 +36,21 @@
 using make_integer_sequence =
     typename internal::make_integer_sequence<T, N - 1>::type;
 
+template <typename T>
+LIBC_INLINE constexpr T &&forward(typename remove_reference<T>::type &value) {
+  return static_cast<T &&>(value);
+}
+
+template <typename T>
+LIBC_INLINE constexpr T &&forward(typename remove_reference<T>::type &&value) {
+  return static_cast<T &&>(value);
+}
+
+template <typename T>
+LIBC_INLINE constexpr typename remove_reference<T>::type &&move(T &&value) {
+  return static_cast<typename remove_reference<T>::type &&>(value);
+}
+
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_UTILITY_H