diff --git a/src/Memory/NonNullOwnPtr.hpp b/src/Memory/NonNullOwnPtr.hpp
index d62bc2e..2e9bf6c 100644
--- a/src/Memory/NonNullOwnPtr.hpp
+++ b/src/Memory/NonNullOwnPtr.hpp
@@ -3,14 +3,14 @@
 
 #include "../Assert.hpp"
 #include "NonNullBorrowedPtr.hpp"
-#include "OwnPtr.hpp"
+#include "BorrowedPtr.hpp"
 
 namespace Arbutils::Memory {
     template <class T> class NonNullOwnPtr {
         T* _ptr;
 
     public:
-        inline NonNullOwnPtr() {};
+        inline NonNullOwnPtr(){};
         inline NonNullOwnPtr(T* ptr) : _ptr(ptr) { AssertNotNull(ptr); };
 
         NonNullOwnPtr<T>(const NonNullOwnPtr<T>&) = delete;
@@ -21,10 +21,9 @@ namespace Arbutils::Memory {
         inline constexpr const T* GetUnsafe() const noexcept { return _ptr; }
 
         inline NonNullBorrowedPtr<T> Borrow() { return NonNullBorrowedPtr<T>(_ptr); }
-
-        inline const NonNullBorrowedPtr<const T> Borrow() const{
-            return NonNullBorrowedPtr<const T>(_ptr);
-        }
+        inline const NonNullBorrowedPtr<const T> Borrow() const { return NonNullBorrowedPtr<const T>(_ptr); }
+        inline BorrowedPtr<T> BorrowOptional() { return BorrowedPtr<T>(_ptr); }
+        inline const BorrowedPtr<const T> BorrowOptional() const { return BorrowedPtr<const T>(_ptr); }
 
         T* operator->() noexcept { return _ptr; }
         const T* operator->() const noexcept { return _ptr; }
diff --git a/src/Memory/OwnPtr.hpp b/src/Memory/OwnPtr.hpp
index 93594ac..4d6994a 100644
--- a/src/Memory/OwnPtr.hpp
+++ b/src/Memory/OwnPtr.hpp
@@ -3,6 +3,7 @@
 
 #include <memory>
 #include "BorrowedPtr.hpp"
+#include "NonNullBorrowedPtr.hpp"
 
 namespace Arbutils::Memory {
     template <class T> class OwnPtr {
@@ -22,6 +23,8 @@ namespace Arbutils::Memory {
 
         inline BorrowedPtr<T> Borrow() { return BorrowedPtr<T>(_ptr); }
         inline const BorrowedPtr<const T> Borrow() const { return BorrowedPtr<const T>(_ptr); }
+        inline BorrowedPtr<T> BorrowNonNull() { return NonNullBorrowedPtr<T>(_ptr); }
+        inline const BorrowedPtr<const T> BorrowNonNull() const { return NonNullBorrowedPtr<const T>(_ptr); }
 
         T* operator->() noexcept { return _ptr; }
         const T* operator->() const noexcept { return _ptr; }