Index: libcfa/src/concurrency/future.hfa
===================================================================
--- libcfa/src/concurrency/future.hfa	(revision fbaea97009f70b67f476a193ca6b049a1100402d)
+++ libcfa/src/concurrency/future.hfa	(revision 00aa122cd8a610fd71bc1afaa8e4910742e18a62)
@@ -10,6 +10,6 @@
 // Created On       : Wed Jan 06 17:33:18 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Nov 23 22:48:08 2025
-// Update Count     : 208
+// Last Modified On : Mon Nov 24 16:08:52 2025
+// Update Count     : 222
 //
 
@@ -100,5 +100,4 @@
  			except = 0p;
  			state = FUTURE_EMPTY$;
- 			lock{};
  		}
 
@@ -320,13 +319,12 @@
 
 //--------------------------------------------------------------------------------------------------------
-// These futures below do not support waituntil statements so they may not have as many features as 'future'
-//  however the 'single_future' is cheap and cheerful and is most likely more performant than 'future'
-//  since it uses raw atomics and no locks
-//
-// As far as 'multi_future' goes I can't see many use cases as it will be less performant than 'future'
-//  since it is monitor based and also is not compatible with waituntil statement.
+// This future does not support waituntil statements so it does not have as many features as 'future'.
+// However, it is cheap and cheerful and is more performant than 'future' since it uses raw atomics
+// and no locks
 //--------------------------------------------------------------------------------------------------------
 
 forall( T ) {
+	// PUBLIC
+
 	struct single_future {
 		inline future_t;
@@ -335,94 +333,21 @@
 
 	static inline {
-		// Reset future back to original state
-		void reset(single_future(T) & this) { reset( (future_t&)this ); }
-
-		// check if the future is available
-		bool available( single_future(T) & this ) { return available( (future_t&)this ); }
-
-		// Mark the future as abandoned, meaning it will be deleted by the server
-		// This doesn't work beause of the potential need for a destructor
-		// void abandon( single_future(T) & this );
-
-		// Fulfil the future, returns whether or not someone was unblocked
-		thread$ * fulfil( single_future(T) & this, T result ) {
-			this.result = result;
-			return fulfil( (future_t&)this );
-		}
-
-		// Wait for the future to be fulfilled
-		// Also return whether the thread had to block or not
-		[T, bool] wait( single_future(T) & this ) {
-			bool r = wait( (future_t&)this );
-			return [this.result, r];
-		}
-
-		// Wait for the future to be fulfilled
-		T wait( single_future(T) & this ) {
-			[T, bool] tt;
-			tt = wait( this );
-			return tt.0;
-		}
-	}
-}
-
-forall( T ) {
-	monitor multi_future {
-		inline future_t;
-		condition blocked;
-		bool has_first;
-		T result;
-	};
-
-	static inline {
-		void ?{}(multi_future(T) & this) {
-			this.has_first = false;
-		}
-
-		bool $first( multi_future(T) & mutex this ) {
-			if ( this.has_first ) {
-				wait( this.blocked );
-				return false;
-			}
-
-			this.has_first = true;
-			return true;
-		}
-
-		void $first_done( multi_future(T) & mutex this ) {
-			this.has_first = false;
-			signal_all( this.blocked );
-		}
-
-		// Reset future back to original state
-		void reset(multi_future(T) & mutex this) {
-			if ( this.has_first != false ) abort("Attempting to reset a multi_future with at least one blocked threads");
-			if ( ! empty( this.blocked ) ) abort("Attempting to reset a multi_future with multiple blocked threads");
-			reset( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) );
-		}
-
-		// Fulfil the future, returns whether or not someone was unblocked
-		bool fulfil( multi_future(T) & this, T result ) {
-			this.result = result;
-			return fulfil( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) ) != 0p;
-		}
-
-		// Wait for the future to be fulfilled
-		// Also return whether the thread had to block or not
-		[T, bool] wait( multi_future(T) & this ) {
-			bool sw = $first( this );
-			bool w = !sw;
-			if ( sw ) {
-				w = wait( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) );
-				$first_done( this );
-			}
-
-			return [this.result, w];
-		}
-
-		// Wait for the future to be fulfilled
-		T wait( multi_future(T) & this ) {
-			return wait( this ).0;
-		}
-	}
-}
+		// PUBLIC
+
+		bool available( single_future(T) & fut ) { return available( (future_t &)fut ); } // future result available ?
+
+		// Return a value/exception from the future.
+		[T, bool] get( single_future(T) & fut ) { return [fut.result, wait( fut )]; }
+		T get( single_future(T) & fut ) { wait( fut ); return fut.result; }
+		T ?()( single_future(T) & fut ) { return get( fut ); }	// alternate interface
+
+		// Load a value into the future, returns whether or not waiting threads.
+		bool fulfil( single_future(T) & fut, T result ) {
+			fut.result = result;
+			return fulfil( (future_t &)fut ) != 0p;
+		}
+		bool ?()( single_future(T) & fut, T val ) { return fulfil( fut, val ); } // alternate interface
+
+		void reset( single_future(T) & fut ) { reset( (future_t &)fut ); } // mark future as empty (for reuse)
+	} // static inline
+} // forall( T )