diff --git a/proxy.h b/proxy.h
index 4004ca8..f947804 100644
--- a/proxy.h
+++ b/proxy.h
@@ -90,11 +90,20 @@ consteval bool has_destructibility(constraint_level level) {
 
 // As per std::to_address() wording in [pointer.conversion]
 template <class P>
-concept is_address_deducible =
-    (std::is_pointer_v<P> && !std::is_function_v<std::remove_pointer_t<P>>) ||
+concept is_address_deducible = std::is_pointer_v<P> ||
     requires(P p) { std::pointer_traits<P>::to_address(p); } ||
     requires(P p) { p.operator->(); };
 
+// Bypass function pointer restriction of std::to_address()
+template <class P>
+auto deduce_address(const P& p) {
+  if constexpr (std::is_pointer_v<P>) {
+    return p;
+  } else {
+    return std::to_address(p);
+  }
+}
+
 template <class T, class... Us> struct contains_traits : inapplicable_traits {};
 template <class T, class... Us>
 struct contains_traits<T, T, Us...> : applicable_traits {};
@@ -130,14 +139,14 @@ struct overload_traits<R(Args...)> : applicable_traits {
 
   template <class D, class P>
   static constexpr bool applicable_pointer = requires(const P& p, Args... args)
-      { { D{}(*std::to_address(p), std::forward<Args>(args)...) }; };
+      { D{}(*deduce_address(p), std::forward<Args>(args)...); };
   template <class D, class P>
   static R dispatcher(const char* erased, Args... args) {
     const P& p = *reinterpret_cast<const P*>(erased);
     if constexpr (std::is_void_v<R>) {
-      D{}(*std::to_address(p), std::forward<Args>(args)...);
+      D{}(*deduce_address(p), std::forward<Args>(args)...);
     } else {
-      return D{}(*std::to_address(p), std::forward<Args>(args)...);
+      return D{}(*deduce_address(p), std::forward<Args>(args)...);
     }
   }
 };
@@ -180,7 +189,7 @@ struct dispatch_traits_impl<D, std::tuple<Os...>> : applicable_traits,
 template <class D> struct dispatch_traits : inapplicable_traits {};
 template <class D> requires(requires {
       typename D::overload_types;
-      { D{} };
+      D{};
     })
 struct dispatch_traits<D>
     : dispatch_traits_impl<D, typename D::overload_types> {};
@@ -603,7 +612,7 @@ struct facade_prototype {
 
 #define PRO_DEF_MEMBER_DISPATCH(__NAME, ...) \
     struct __NAME { \
-      using overload_types = std::tuple<__VA_ARGS__>;\
+      using overload_types = std::tuple<__VA_ARGS__>; \
       template <class __T, class... __Args> \
       decltype(auto) operator()(__T&& __self, __Args&&... __args) \
           requires(requires{ std::forward<__T>(__self) \
@@ -614,7 +623,7 @@ struct facade_prototype {
     }
 #define PRO_DEF_FREE_DISPATCH(__NAME, __FUNC, ...) \
     struct __NAME { \
-      using overload_types = std::tuple<__VA_ARGS__>;\
+      using overload_types = std::tuple<__VA_ARGS__>; \
       template <class __T, class... __Args> \
       decltype(auto) operator()(__T&& __self, __Args&&... __args) \
           requires(requires{ __FUNC(std::forward<__T>(__self), \
diff --git a/tests/proxy_invocation_tests.cpp b/tests/proxy_invocation_tests.cpp
index 106d9c5..99cea48 100644
--- a/tests/proxy_invocation_tests.cpp
+++ b/tests/proxy_invocation_tests.cpp
@@ -43,7 +43,6 @@ struct Append {
 
 }  // namespace poly
 
-
 template <class F, class D, class... Args>
 concept InvocableWithDispatch = requires(pro::proxy<F> p, Args... args)
     { { p.template invoke<D>(std::forward<Args>(args)...) }; };
@@ -163,3 +162,10 @@ TEST(ProxyInvocationTests, TestOverloadResolution) {
   ASSERT_EQ(side_effect, (GetTypeIndices<std::string, int>()));
   ASSERT_FALSE((std::is_invocable_v<decltype(p), std::vector<int>>));
 }
+
+TEST(ProxyInvocationTests, TestFunctionPointer) {
+  struct TestFacade : poly::Callable<std::vector<std::type_index>()> {};
+  pro::proxy<TestFacade> p{ &GetTypeIndices<int, double> };
+  auto ret = p();
+  ASSERT_EQ(ret, (GetTypeIndices<int, double>()));
+}
diff --git a/tests/proxy_traits_tests.cpp b/tests/proxy_traits_tests.cpp
index 41daddd..4a34658 100644
--- a/tests/proxy_traits_tests.cpp
+++ b/tests/proxy_traits_tests.cpp
@@ -22,6 +22,7 @@ using MockMovablePtr = MockPtr<true, false, false, sizeof(void*) * 2, alignof(vo
 using MockCopyablePtr = MockPtr<true, true, false, sizeof(void*) * 2, alignof(void*)>;
 using MockCopyableSmallPtr = MockPtr<true, true, false, sizeof(void*), alignof(void*)>;
 using MockTrivialPtr = MockPtr<true, true, true, sizeof(void*), alignof(void*)>;
+using MockFunctionPtr = void(*)();
 
 PRO_DEF_FACADE(DefaultFacade);
 static_assert(DefaultFacade::pointer_constraints.minimum_copyability == pro::constraint_level::none);
@@ -39,6 +40,7 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::in
 static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::in_place_type_t<MockCopyablePtr>, int>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::in_place_type_t<MockCopyableSmallPtr>, int>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::in_place_type_t<MockTrivialPtr>, int>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<DefaultFacade>, std::in_place_type_t<MockFunctionPtr>, MockFunctionPtr>);
 
 PRO_DEF_FACADE(RelocatableFacade);
 static_assert(!std::is_copy_constructible_v<pro::proxy<RelocatableFacade>>);
@@ -55,6 +57,7 @@ static_assert(pro::proxiable<MockMovablePtr, RelocatableFacade>);
 static_assert(pro::proxiable<MockCopyablePtr, RelocatableFacade>);
 static_assert(pro::proxiable<MockCopyableSmallPtr, RelocatableFacade>);
 static_assert(pro::proxiable<MockTrivialPtr, RelocatableFacade>);
+static_assert(pro::proxiable<MockFunctionPtr, RelocatableFacade>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockMovablePtr>);
 static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockMovablePtr>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockCopyablePtr>);
@@ -63,6 +66,8 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, Moc
 static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockCopyableSmallPtr>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockTrivialPtr>);
 static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockTrivialPtr>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<RelocatableFacade>, MockFunctionPtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<RelocatableFacade>, MockFunctionPtr>);
 
 PRO_DEF_FACADE(CopyableFacade, PRO_MAKE_DISPATCH_PACK(), pro::copyable_pointer_constraints);
 static_assert(std::is_copy_constructible_v<pro::proxy<CopyableFacade>>);
@@ -79,6 +84,7 @@ static_assert(!pro::proxiable<MockMovablePtr, CopyableFacade>);
 static_assert(pro::proxiable<MockCopyablePtr, CopyableFacade>);
 static_assert(pro::proxiable<MockCopyableSmallPtr, CopyableFacade>);
 static_assert(pro::proxiable<MockTrivialPtr, CopyableFacade>);
+static_assert(pro::proxiable<MockFunctionPtr, CopyableFacade>);
 static_assert(!std::is_constructible_v<pro::proxy<CopyableFacade>, MockMovablePtr>);
 static_assert(!std::is_assignable_v<pro::proxy<CopyableFacade>, MockMovablePtr>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<CopyableFacade>, MockCopyablePtr>);
@@ -87,6 +93,8 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<CopyableFacade>, MockCo
 static_assert(std::is_nothrow_assignable_v<pro::proxy<CopyableFacade>, MockCopyableSmallPtr>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<CopyableFacade>, MockTrivialPtr>);
 static_assert(std::is_nothrow_assignable_v<pro::proxy<CopyableFacade>, MockTrivialPtr>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<CopyableFacade>, MockFunctionPtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<CopyableFacade>, MockFunctionPtr>);
 
 PRO_DEF_FACADE(CopyableSmallFacade, PRO_MAKE_DISPATCH_PACK(), pro::proxy_pointer_constraints{
     .maximum_size = sizeof(void*),
@@ -99,6 +107,7 @@ static_assert(!pro::proxiable<MockMovablePtr, CopyableSmallFacade>);
 static_assert(!pro::proxiable<MockCopyablePtr, CopyableSmallFacade>);
 static_assert(pro::proxiable<MockCopyableSmallPtr, CopyableSmallFacade>);
 static_assert(pro::proxiable<MockTrivialPtr, CopyableSmallFacade>);
+static_assert(pro::proxiable<MockFunctionPtr, CopyableSmallFacade>);
 static_assert(!std::is_constructible_v<pro::proxy<CopyableSmallFacade>, MockMovablePtr>);
 static_assert(!std::is_assignable_v<pro::proxy<CopyableSmallFacade>, MockMovablePtr>);
 static_assert(!std::is_constructible_v<pro::proxy<CopyableSmallFacade>, MockCopyablePtr>);
@@ -107,6 +116,8 @@ static_assert(std::is_nothrow_constructible_v<pro::proxy<CopyableSmallFacade>, M
 static_assert(std::is_nothrow_assignable_v<pro::proxy<CopyableSmallFacade>, MockCopyableSmallPtr>);
 static_assert(std::is_constructible_v<pro::proxy<CopyableSmallFacade>, MockTrivialPtr>);
 static_assert(std::is_assignable_v<pro::proxy<CopyableSmallFacade>, MockTrivialPtr>);
+static_assert(std::is_constructible_v<pro::proxy<CopyableSmallFacade>, MockFunctionPtr>);
+static_assert(std::is_assignable_v<pro::proxy<CopyableSmallFacade>, MockFunctionPtr>);
 
 PRO_DEF_FACADE(TrivialFacade, PRO_MAKE_DISPATCH_PACK(), pro::trivial_pointer_constraints);
 static_assert(std::is_trivially_copy_constructible_v<pro::proxy<TrivialFacade>>);
@@ -120,6 +131,7 @@ static_assert(!pro::proxiable<MockMovablePtr, TrivialFacade>);
 static_assert(!pro::proxiable<MockCopyablePtr, TrivialFacade>);
 static_assert(!pro::proxiable<MockCopyableSmallPtr, TrivialFacade>);
 static_assert(pro::proxiable<MockTrivialPtr, TrivialFacade>);
+static_assert(pro::proxiable<MockFunctionPtr, TrivialFacade>);
 static_assert(!std::is_constructible_v<pro::proxy<TrivialFacade>, MockMovablePtr>);
 static_assert(!std::is_assignable_v<pro::proxy<TrivialFacade>, MockMovablePtr>);
 static_assert(!std::is_constructible_v<pro::proxy<TrivialFacade>, MockCopyablePtr>);
@@ -128,5 +140,7 @@ static_assert(!std::is_constructible_v<pro::proxy<TrivialFacade>, MockCopyableSm
 static_assert(!std::is_assignable_v<pro::proxy<TrivialFacade>, MockCopyableSmallPtr>);
 static_assert(std::is_nothrow_constructible_v<pro::proxy<TrivialFacade>, MockTrivialPtr>);
 static_assert(std::is_nothrow_assignable_v<pro::proxy<TrivialFacade>, MockTrivialPtr>);
+static_assert(std::is_nothrow_constructible_v<pro::proxy<TrivialFacade>, MockFunctionPtr>);
+static_assert(std::is_nothrow_assignable_v<pro::proxy<TrivialFacade>, MockFunctionPtr>);
 
 }  // namespace