async 2.14.2 → 2.23.1

data/lib/async/scheduler.rb

@@ -5,17 +5,30 @@
 # Copyright, 2020, by Jun Jiang.
 # Copyright, 2021, by Julien Portalier.
 
-require_relative 'clock'
-require_relative 'task'
+require_relative "clock"
+require_relative "task"
+require_relative "worker_pool"
 
-require 'io/event'
+require "io/event"
 
-require 'console'
-require 'resolv'
+require "console"
+require "resolv"
 
 module Async
+	begin
+		require "fiber/profiler"
+		Profiler = Fiber::Profiler
+	rescue LoadError
+		# Fiber::Profiler is not available.
+		Profiler = nil
+	end
+	
 	# Handles scheduling of fibers. Implements the fiber scheduler interface.
 	class Scheduler < Node
+		WORKER_POOL = ENV.fetch("ASYNC_SCHEDULER_WORKER_POOL", nil).then do |value|
+			value == "true" ? true : nil
+		end
+		
 		# Raised when an operation is attempted on a closed scheduler.
 		class ClosedError < RuntimeError
 			# Create a new error.
@@ -27,20 +40,22 @@ module Async
 		end
 		
 		# Whether the fiber scheduler is supported.
-		# @public Since `stable-v1`.
+		# @public Since *Async v1*.
 		def self.supported?
 			true
 		end
 		
 		# Create a new scheduler.
 		#
-		# @public Since `stable-v1`.
+		# @public Since *Async v1*.
 		# @parameter parent [Node | Nil] The parent node to use for task hierarchy.
 		# @parameter selector [IO::Event::Selector] The selector to use for event handling.
-		def initialize(parent = nil, selector: nil)
+		def initialize(parent = nil, selector: nil, profiler: Profiler&.default, worker_pool: WORKER_POOL)
 			super(parent)
 			
 			@selector = selector || ::IO::Event::Selector.new(Fiber.current)
+			@profiler = profiler
+			
 			@interrupted = false
 			
 			@blocked = 0
@@ -49,9 +64,19 @@ module Async
 			@idle_time = 0.0
 			
 			@timers = ::IO::Event::Timers.new
+			if worker_pool == true
+				@worker_pool = WorkerPool.new
+			else
+				@worker_pool = worker_pool
+			end
+			
+			if @worker_pool
+				self.singleton_class.prepend(WorkerPool::BlockingOperationWait)
+			end
 		end
 		
 		# Compute the scheduler load according to the busy and idle times that are updated by the run loop.
+		#
 		# @returns [Float] The load of the scheduler. 0.0 means no load, 1.0 means fully loaded or over-loaded.
 		def load
 			total_time = @busy_time + @idle_time
@@ -71,52 +96,56 @@ module Async
 				return @busy_time / total_time
 			end
 		end
-		
+	
 		# Invoked when the fiber scheduler is being closed.
 		#
 		# Executes the run loop until all tasks are finished, then closes the scheduler.
-		def scheduler_close
+		def scheduler_close(error = $!)
 			# If the execution context (thread) was handling an exception, we want to exit as quickly as possible:
-			unless $!
+			unless error
 				self.run
 			end
 		ensure
 			self.close
 		end
 		
-		# Terminate the scheduler. We deliberately ignore interrupts here, as this code can be called from an interrupt, and we don't want to be interrupted while cleaning up.
+		# Terminate all child tasks.
 		def terminate
-			Thread.handle_interrupt(::Interrupt => :never) do
-				super
+			# If that doesn't work, take more serious action:
+			@children&.each do |child|
+				child.terminate
 			end
+			
+			return @children.nil?
 		end
 		
 		# Terminate all child tasks and close the scheduler.
-		# @public Since `stable-v1`.
+		# @public Since *Async v1*.
 		def close
-			# It's critical to stop all tasks. Otherwise they might be holding on to resources which are never closed/released correctly.
-			until self.terminate
-				self.run_once!
+			self.run_loop do
+				until self.terminate
+					self.run_once!
+				end
 			end
 			
 			Kernel.raise "Closing scheduler with blocked operations!" if @blocked > 0
-			
-			# We depend on GVL for consistency:
-			# @guard.synchronize do
-			
+		ensure
 			# We want `@selector = nil` to be a visible side effect from this point forward, specifically in `#interrupt` and `#unblock`. If the selector is closed, then we don't want to push any fibers to it.
 			selector = @selector
 			@selector = nil
 			
 			selector&.close
 			
-			# end
+			worker_pool = @worker_pool
+			@worker_pool = nil
+			
+			worker_pool&.close
 			
 			consume
 		end
 		
 		# @returns [Boolean] Whether the scheduler has been closed.
-		# @public Since `stable-v1`.
+		# @public Since *Async v1*.
 		def closed?
 			@selector.nil?
 		end
@@ -168,7 +197,12 @@ module Async
 		end
 		
 		# Invoked when a fiber tries to perform a blocking operation which cannot continue. A corresponding call {unblock} must be performed to allow this fiber to continue.
+		#
+		# @public Since *Async v2*.
 		# @asynchronous May only be called on same thread as fiber scheduler.
+		#
+		# @parameter blocker [Object] The object that is blocking the fiber.
+		# @parameter timeout [Float | Nil] The maximum time to block, or if nil, indefinitely.
 		def block(blocker, timeout)
 			# $stderr.puts "block(#{blocker}, #{Fiber.current}, #{timeout})"
 			fiber = Fiber.current
@@ -191,7 +225,13 @@ module Async
 			timer&.cancel!
 		end
 		
+		# Unblock a fiber that was previously blocked.
+		#
+		# @public Since *Async v2* and *Ruby v3.1*.
 		# @asynchronous May be called from any thread.
+		#
+		# @parameter blocker [Object] The object that was blocking the fiber.
+		# @parameter fiber [Fiber] The fiber to unblock.
 		def unblock(blocker, fiber)
 			# $stderr.puts "unblock(#{blocker}, #{fiber})"
 			
@@ -202,7 +242,12 @@ module Async
 			end
 		end
 		
-		# @asynchronous May be non-blocking..
+		# Sleep for the specified duration.
+		#
+		# @public Since *Async v2* and *Ruby v3.1*.
+		# @asynchronous May be non-blocking.
+		#
+		# @parameter duration [Numeric | Nil] The time in seconds to sleep, or if nil, indefinitely.
 		def kernel_sleep(duration = nil)
 			if duration
 				self.block(nil, duration)
@@ -211,7 +256,12 @@ module Async
 			end
 		end
 		
-		# @asynchronous May be non-blocking..
+		# Resolve the address of the given hostname.
+		#
+		# @public Since *Async v2*.
+		# @asynchronous May be non-blocking.
+		#
+		# @parameter hostname [String] The hostname to resolve.
 		def address_resolve(hostname)
 			# On some platforms, hostnames may contain a device-specific suffix (e.g. %en0). We need to strip this before resolving.
 			# See <https://github.com/socketry/async/issues/180> for more details.
@@ -219,7 +269,6 @@ module Async
 			::Resolv.getaddresses(hostname)
 		end
 		
-		
 		if IO.method_defined?(:timeout)
 			private def get_timeout(io)
 				io.timeout
@@ -230,7 +279,14 @@ module Async
 			end
 		end
 		
-		# @asynchronous May be non-blocking..
+		# Wait for the specified IO to become ready for the specified events.
+		#
+		# @public Since *Async v2*.
+		# @asynchronous May be non-blocking.
+		#
+		# @parameter io [IO] The IO object to wait on.
+		# @parameter events [Integer] The events to wait for, e.g. `IO::READABLE`, `IO::WRITABLE`, etc.
+		# @parameter timeout [Float | Nil] The maximum time to wait, or if nil, indefinitely.
 		def io_wait(io, events, timeout = nil)
 			fiber = Fiber.current
 			
@@ -242,7 +298,7 @@ module Async
 			elsif timeout = get_timeout(io)
 				# Otherwise, if we default to the io's timeout, we raise an exception:
 				timer = @timers.after(timeout) do
-					fiber.raise(::IO::TimeoutError, "Timeout while waiting for IO to become ready!")
+					fiber.raise(::IO::TimeoutError, "Timeout (#{timeout}s) while waiting for IO to become ready!")
 				end
 			end
 			
@@ -252,12 +308,21 @@ module Async
 		end
 		
 		if ::IO::Event::Support.buffer?
+			# Read from the specified IO into the buffer.
+			#
+			# @public Since *Async v2* and Ruby with `IO::Buffer` support.
+			# @asynchronous May be non-blocking.
+			#
+			# @parameter io [IO] The IO object to read from.
+			# @parameter buffer [IO::Buffer] The buffer to read into.
+			# @parameter length [Integer] The minimum number of bytes to read.
+			# @parameter offset [Integer] The offset within the buffer to read into.
 			def io_read(io, buffer, length, offset = 0)
 				fiber = Fiber.current
 				
 				if timeout = get_timeout(io)
 					timer = @timers.after(timeout) do
-						fiber.raise(::IO::TimeoutError, "Timeout while waiting for IO to become readable!")
+						fiber.raise(::IO::TimeoutError, "Timeout (#{timeout}s) while waiting for IO to become readable!")
 					end
 				end
 				
@@ -267,12 +332,21 @@ module Async
 			end
 			
 			if RUBY_ENGINE != "ruby" || RUBY_VERSION >= "3.3.1"
+				# Write the specified buffer to the IO.
+				#
+				# @public Since *Async v2* and *Ruby v3.3.1* with `IO::Buffer` support.
+				# @asynchronous May be non-blocking.
+				#
+				# @parameter io [IO] The IO object to write to.
+				# @parameter buffer [IO::Buffer] The buffer to write from.
+				# @parameter length [Integer] The minimum number of bytes to write.
+				# @parameter offset [Integer] The offset within the buffer to write from.
 				def io_write(io, buffer, length, offset = 0)
 					fiber = Fiber.current
 					
 					if timeout = get_timeout(io)
 						timer = @timers.after(timeout) do
-							fiber.raise(::IO::TimeoutError, "Timeout while waiting for IO to become writable!")
+							fiber.raise(::IO::TimeoutError, "Timeout (#{timeout}s) while waiting for IO to become writable!")
 						end
 					end
 					
@@ -284,6 +358,10 @@ module Async
 		end
 		
 		# Wait for the specified process ID to exit.
+		#
+		# @public Since *Async v2*.
+		# @asynchronous May be non-blocking.
+		#
 		# @parameter pid [Integer] The process ID to wait for.
 		# @parameter flags [Integer] A bit-mask of flags suitable for `Process::Status.wait`.
 		# @returns [Process::Status] A process status instance.
@@ -292,28 +370,13 @@ module Async
 			return @selector.process_wait(Fiber.current, pid, flags)
 		end
 		
-		# Run one iteration of the event loop.
-		# Does not handle interrupts.
-		# @parameter timeout [Float | Nil] The maximum timeout, or if nil, indefinite.
-		# @returns [Boolean] Whether there is more work to do.
-		def run_once(timeout = nil)
-			Kernel::raise "Running scheduler on non-blocking fiber!" unless Fiber.blocking?
-			
-			# If we are finished, we stop the task tree and exit:
-			if self.finished?
-				return false
-			end
-			
-			return run_once!(timeout)
-		end
-		
 		# Run one iteration of the event loop.
 		#
 		# When terminating the event loop, we already know we are finished. So we don't need to check the task tree. This is a logical requirement because `run_once` ignores transient tasks. For example, a single top level transient task is not enough to keep the reactor running, but during termination we must still process it in order to terminate child tasks.
 		#
 		# @parameter timeout [Float | Nil] The maximum timeout, or if nil, indefinite.
 		# @returns [Boolean] Whether there is more work to do.
-		private def run_once!(timeout = 0)
+		private def run_once!(timeout = nil)
 			start_time = Async::Clock.now
 			
 			interval = @timers.wait_interval
@@ -350,7 +413,30 @@ module Async
 			return true
 		end
 		
+		# Run one iteration of the event loop.
+		#
+		# @public Since *Async v1*.
+		# @asynchronous Must be invoked from blocking (root) fiber.
+		#
+		# @parameter timeout [Float | Nil] The maximum timeout, or if nil, indefinite.
+		# @returns [Boolean] Whether there is more work to do.
+		def run_once(timeout = nil)
+			Kernel.raise "Running scheduler on non-blocking fiber!" unless Fiber.blocking?
+			
+			if self.finished?
+				self.stop
+			end
+			
+			# If we are finished, we stop the task tree and exit:
+			if @children.nil?
+				return false
+			end
+			
+			return run_once!(timeout)
+		end
+		
 		# Checks and clears the interrupted state of the scheduler.
+		#
 		# @returns [Boolean] Whether the reactor has been interrupted.
 		private def interrupted?
 			if @interrupted
@@ -365,26 +451,34 @@ module Async
 			return false
 		end
 		
-		# Run the reactor until all tasks are finished. Proxies arguments to {#async} immediately before entering the loop, if a block is provided.
-		def run(...)
-			Kernel::raise ClosedError if @selector.nil?
-			
-			initial_task = self.async(...) if block_given?
+		# Stop all children, including transient children.
+		#
+		# @public Since *Async v1*.
+		def stop
+			@children&.each do |child|
+				child.stop
+			end
+		end
+		
+		private def run_loop(&block)
 			interrupt = nil
 			
 			begin
 				# In theory, we could use Exception here to be a little bit safer, but we've only shown the case for SignalException to be a problem, so let's not over-engineer this.
 				Thread.handle_interrupt(::SignalException => :never) do
-					while true
-						# If we are interrupted, we need to exit:
-						break if self.interrupted?
-						
+					until self.interrupted?
 						# If we are finished, we need to exit:
-						break unless self.run_once
+						break unless yield
 					end
 				end
 			rescue Interrupt => interrupt
+				# If an interrupt did occur during an iteration of the event loop, we need to handle it. More specifically, `self.stop` is not safe to interrupt without potentially corrupting the task tree.
 				Thread.handle_interrupt(::SignalException => :never) do
+					Console.debug(self) do |buffer|
+						buffer.puts "Scheduler interrupted: #{interrupt.inspect}"
+						self.print_hierarchy(buffer)
+					end
+					
 					self.stop
 				end
 				
@@ -392,37 +486,54 @@ module Async
 			end
 			
 			# If the event loop was interrupted, and we finished exiting normally (due to the interrupt), we need to re-raise the interrupt so that the caller can handle it too.
-			Kernel.raise interrupt if interrupt
+			if interrupt
+				Kernel.raise(interrupt)
+			end
+		end
+		
+		# Run the reactor until all tasks are finished. Proxies arguments to {#async} immediately before entering the loop, if a block is provided.
+		#
+		# Forwards all parameters to {#async} if a block is given.
+		#
+		# @public Since *Async v1*.
+		#
+		# @yields {|task| ...} The top level task, if a block is given.
+		# @returns [Task] The initial task that was scheduled into the reactor.
+		def run(...)
+			Kernel.raise ClosedError if @selector.nil?
 			
-			return initial_task
-		ensure
-			Console.debug(self) {"Exiting run-loop because #{$! ? $! : 'finished'}."}
+			begin
+				@profiler&.start
+				
+				initial_task = self.async(...) if block_given?
+				
+				self.run_loop do
+					run_once
+				end
+				
+				return initial_task
+			ensure
+				@profiler&.stop
+			end
 		end
 		
-		# Start an asynchronous task within the specified reactor. The task will be
-		# executed until the first blocking call, at which point it will yield and
-		# and this method will return.
+		# Start an asynchronous task within the specified reactor. The task will be executed until the first blocking call, at which point it will yield and and this method will return.
 		#
-		# This is the main entry point for scheduling asynchronus tasks.
+		# @public Since *Async v1*.
+		# @asynchronous May context switch immediately to new task.
+		# @deprecated Use {#run} or {Task#async} instead.
 		#
 		# @yields {|task| ...} Executed within the task.
 		# @returns [Task] The task that was scheduled into the reactor.
-		# @deprecated With no replacement.
 		def async(*arguments, **options, &block)
-			Kernel::raise ClosedError if @selector.nil?
+			# warn "Async::Scheduler#async is deprecated. Use `run` or `Task#async` instead.", uplevel: 1, category: :deprecated
+			
+			Kernel.raise ClosedError if @selector.nil?
 			
 			task = Task.new(Task.current? || self, **options, &block)
 			
-			# I want to take a moment to explain the logic of this.
-			# When calling an async block, we deterministically execute it until the
-			# first blocking operation. We don't *have* to do this - we could schedule
-			# it for later execution, but it's useful to:
-			# - Fail at the point of the method call where possible.
-			# - Execute determinstically where possible.
-			# - Avoid scheduler overhead if no blocking operation is performed.
 			task.run(*arguments)
 			
-			# Console.debug "Initial execution of task #{fiber} complete (#{result} -> #{fiber.alive?})..."
 			return task
 		end
 		
@@ -431,7 +542,14 @@ module Async
 		end
 		
 		# Invoke the block, but after the specified timeout, raise {TimeoutError} in any currenly blocking operation. If the block runs to completion before the timeout occurs or there are no non-blocking operations after the timeout expires, the code will complete without any exception.
+		#
+		# @public Since *Async v1*.
+		# @asynchronous May raise an exception at any interruption point (e.g. blocking operations).
+		#
 		# @parameter duration [Numeric] The time in seconds, in which the task should complete.
+		# @parameter exception [Class] The exception class to raise.
+		# @parameter message [String] The message to pass to the exception.
+		# @yields {|duration| ...} The block to execute with a timeout.
 		def with_timeout(duration, exception = TimeoutError, message = "execution expired", &block)
 			fiber = Fiber.current
 			
@@ -446,6 +564,15 @@ module Async
 			timer&.cancel!
 		end
 		
+		# Invoke the block, but after the specified timeout, raise the specified exception with the given message. If the block runs to completion before the timeout occurs or there are no non-blocking operations after the timeout expires, the code will complete without any exception.
+		#
+		# @public Since *Async v1* and *Ruby v3.1*. May be invoked from `Timeout.timeout`.
+		# @asynchronous May raise an exception at any interruption point (e.g. blocking operations).
+		#
+		# @parameter duration [Numeric] The time in seconds, in which the task should complete.
+		# @parameter exception [Class] The exception class to raise.
+		# @parameter message [String] The message to pass to the exception.
+		# @yields {|duration| ...} The block to execute with a timeout.
 		def timeout_after(duration, exception, message, &block)
 			with_timeout(duration, exception, message) do |timer|
 				yield duration

data/lib/async/semaphore.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
-require_relative 'list'
+require_relative "list"
 
 module Async
 	# A synchronization primitive, which limits access to a given resource.
-	# @public Since `stable-v1`.
+	# @public Since *Async v1*.
 	class Semaphore
 		# @parameter limit [Integer] The maximum number of times the semaphore can be acquired before it blocks.
 		# @parameter parent [Task | Semaphore | Nil] The parent for holding any children tasks.

data/lib/async/task.rb

@@ -7,11 +7,11 @@
 # Copyright, 2020, by Patrik Wenger.
 # Copyright, 2023, by Math Ieu.
 
-require 'fiber'
-require 'console/event/failure'
+require "fiber"
+require "console"
 
-require_relative 'node'
-require_relative 'condition'
+require_relative "node"
+require_relative "condition"
 
 Fiber.attr_accessor :async_task
 
@@ -40,7 +40,7 @@ module Async
 	end
 	
 	# Raised if a timeout occurs on a specific Fiber. Handled gracefully by `Task`.
-	# @public Since `stable-v1`.
+	# @public Since *Async v1*.
 	class TimeoutError < StandardError
 		# Create a new timeout error.
 		#
@@ -50,7 +50,7 @@ module Async
 		end
 	end
 	
-	# @public Since `stable-v1`.
+	# @public Since *Async v1*.
 	class Task < Node
 		# Raised when a child task is created within a task that has finished execution.
 		class FinishedError < RuntimeError
@@ -67,6 +67,13 @@ module Async
 			Fiber.scheduler.transfer
 		end
 		
+		# Run the given block of code in a task, asynchronously, in the given scheduler.
+		def self.run(scheduler, *arguments, **options, &block)
+			self.new(scheduler, **options, &block).tap do |task|
+				task.run(*arguments)
+			end
+		end
+		
 		# Create a new task.
 		# @parameter reactor [Reactor] the reactor this task will run within.
 		# @parameter parent [Task] the parent task.
@@ -174,9 +181,12 @@ module Async
 			@status == :completed
 		end
 		
-		alias complete? completed?
+		# Alias for {#completed?}.
+		def complete?
+			self.completed?
+		end
 		
-		# @attribute [Symbol] The status of the execution of the fiber, one of `:initialized`, `:running`, `:complete`, `:stopped` or `:failed`.
+		# @attribute [Symbol] The status of the execution of the task, one of `:initialized`, `:running`, `:complete`, `:stopped` or `:failed`.
 		attr :status
 		
 		# Begin the execution of the task.
@@ -191,9 +201,7 @@ module Async
 				rescue => error
 					# I'm not completely happy with this overhead, but the alternative is to not log anything which makes debugging extremely difficult. Maybe we can introduce a debug wrapper which adds extra logging.
 					if @finished.nil?
-						Console::Event::Failure.for(error).emit(self, "Task may have ended with unhandled exception.", severity: :warn)
-					# else
-					# 	Console::Event::Failure.for(error).emit(self, severity: :debug)
+						warn(self, "Task may have ended with unhandled exception.", exception: error)
 					end
 					
 					raise
@@ -205,6 +213,10 @@ module Async
 		
 		# Run an asynchronous task as a child of the current task.
 		#
+		# @public Since *Async v1*.
+		# @asynchronous May context switch immediately to the new task.
+		#
+		# @yields {|task| ...} in the context of the new task.
 		# @raises [FinishedError] If the task has already finished.
 		# @returns [Task] The child task.
 		def async(*arguments, **options, &block)
@@ -212,6 +224,13 @@ module Async
 			
 			task = Task.new(self, **options, &block)
 			
+			# When calling an async block, we deterministically execute it until the first blocking operation. We don't *have* to do this - we could schedule it for later execution, but it's useful to:
+			#
+			# - Fail at the point of the method call where possible.
+			# - Execute determinstically where possible.
+			# - Avoid scheduler overhead if no blocking operation is performed.
+			#
+			# There are different strategies (greedy vs non-greedy). We are currently using a greedy strategy.
 			task.run(*arguments)
 			
 			return task
@@ -253,15 +272,18 @@ module Async
 				return stopped!
 			end
 			
-			# If we are deferring stop...
-			if @defer_stop == false
-				# Don't stop now... but update the state so we know we need to stop later.
-				@defer_stop = true
-				return false
-			end
-			
 			# If the fiber is alive, we need to stop it:
 			if @fiber&.alive?
+				# As the task is now exiting, we want to ensure the event loop continues to execute until the task finishes.
+				self.transient = false
+				
+				# If we are deferring stop...
+				if @defer_stop == false
+					# Don't stop now... but update the state so we know we need to stop later.
+					@defer_stop = true
+					return false
+				end
+				
 				if self.current?
 					# If the fiber is current, and later is `true`, we need to schedule the fiber to be stopped later, as it's currently invoking `stop`:
 					if later
@@ -294,26 +316,30 @@ module Async
 		# If stop is invoked a second time, it will be immediately executed.
 		#
 		# @yields {} The block of code to execute.
-		# @public Since `stable-v1`.
+		# @public Since *Async v1*.
 		def defer_stop
 			# Tri-state variable for controlling stop:
 			# - nil: defer_stop has not been called.
 			# - false: defer_stop has been called and we are not stopping.
 			# - true: defer_stop has been called and we will stop when exiting the block.
 			if @defer_stop.nil?
-				# If we are not deferring stop already, we can defer it now:
-				@defer_stop = false
-				
 				begin
+					# If we are not deferring stop already, we can defer it now:
+					@defer_stop = false
+					
 					yield
 				rescue Stop
 					# If we are exiting due to a stop, we shouldn't try to invoke stop again:
 					@defer_stop = nil
 					raise
 				ensure
+					defer_stop = @defer_stop
+					
+					# We need to ensure the state is reset before we exit the block:
+					@defer_stop = nil
+					
 					# If we were asked to stop, we should do so now:
-					if @defer_stop
-						@defer_stop = nil
+					if defer_stop
 						raise Stop, "Stopping current task (was deferred)!"
 					end
 				end
@@ -323,6 +349,11 @@ module Async
 			end
 		end
 		
+		# @returns [Boolean] Whether stop has been deferred.
+		def stop_deferred?
+			@defer_stop
+		end
+		
 		# Lookup the {Task} for the current fiber. Raise `RuntimeError` if none is available.
 		# @returns [Task]
 		# @raises[RuntimeError] If task was not {set!} for the current fiber.
@@ -343,6 +374,10 @@ module Async
 		
 		private
 		
+		def warn(...)
+			Console.warn(...)
+		end
+		
 		# Finish the current task, moving any children to the parent.
 		def finish!
 			# Don't hold references to the fiber or block after the task has finished: