Update Signal.lua

Author: lucasmz-dev

src/ReplicatedStorage/Signal.lua

@@ -78,11 +78,6 @@
 			
 ]]
 
-local c_running = coroutine.running
-local c_yield = coroutine.yield
-local t_defer = task.defer
-local t_desynchronize = task.desynchronize
-
 local ERROR_ON_ALREADY_DISCONNECTED = false
 
 local Signal = {}
@@ -91,64 +86,66 @@ Signal.__index = Signal
 local Connection = {}
 Connection.__index = Connection
 
+function Signal:__call(_, ...)
+	if not self:IsActive() then
+		return
+	end
+
+	return self:Connect(...)
+end
+
 function Signal.new()
 	local self = setmetatable({
-		[1] = nil, -- _head
-		[2] = true -- _active
+		_active = true,
+		_head = nil
 	}, Signal)
 
 	return self
 end
 
 function Signal:IsActive()
-	return self[2] == true
+	return self._active == true
 end
 
-local function Connect(self, func, self_disconnects)
+function Signal:Connect(func)
+	assert(
+		typeof(func) == 'function',
+		":Connect must be called with a function"
+	)
+
 	if not self:IsActive() then
 		return setmetatable({
 			Connected = false
 		}, Connection)
 	end
 
-	local _head = self[1]
-
 	local connection = setmetatable({
 		Connected = true,
-		[1] = func, -- _func
-		[2] = self, -- _signal
-		[3] = _head, -- _next
-		[4] = nil, -- _prev
-		[5] = self_disconnects -- _self_disconnects
+		_func = func,
+		_signal = self,
+		_next = nil,
+		_prev = nil
 	}, Connection)
 
+	local _head = self._head
 	if _head ~= nil then
-		_head[4] = connection -- _head._prev = connection
-		connection[3] = _head -- connection._next = _head
+		_head._prev = connection
+		connection._next = _head
 	end
 
-	self[1] = connection -- _head = connection
+	self._head = connection
 
 	return connection
 end
 
-function Signal:Connect(func)
-	assert(
-		typeof(func) == 'function',
-		":Connect must be called with a function"
-	)
-
-	return Connect(self, func)
-end
-
 function Signal:ConnectParallel(func)
 	assert(
 		typeof(func) == 'function',
 		":ConnectParallel must be called with a function"
 	)
 
-	return Connect(self, function(...)
-		t_desynchronize()
+	return self:Connect(function(...)
+		task.desynchronize()
 		func(...)
 	end)
 end
@@ -164,37 +161,48 @@ function Connection:Disconnect()
 
 	self.Connected = false
 
-	local _next = self[3]
-	local _prev = self[4]
+	local _next = self._next
+	local _prev = self._prev
 
 	if _next ~= nil then
-		_next[4] = _prev -- _next._prev = _prev
+		_next._prev = _prev
 	end
 
 	if _prev ~= nil then
-		_prev[3] = _next -- _prev._next = _next
+		_prev._next = _next
 	else
 		--\\ This connection was the _head,
 		--   therefore we need to update the head
 		--   to the connection after this one.
 
-		self[2][1] = _next -- self._signal._head = _next
+		self._signal._head = _next
 	end
 
 	--\\ Safe to wipe references to:
 
-	self[2] = nil
-	self[4] = nil
+	self._signal = nil
+	self._prev = nil
 end
 
 function Signal:Wait()
-	Connect(
-		self,
-		c_running(),
-		true
-	)
+	if not self:IsActive() then
+		warn("Tried to :Wait on destroyed signal")
+		return
+	end
+	
+	local thread = coroutine.running()
+
+	local connection
+	connection = self:Connect(function(...)
+		connection:Disconnect()
 
-	return c_yield()
+		task.spawn(
+			thread,
+			...
+		)
+	end)
+
+	return coroutine.yield()
 end
 
 function Signal:Fire(...)
@@ -203,54 +211,38 @@ function Signal:Fire(...)
 		return
 	end
 
-	local connection = self[1]
+	local connection = self._head
 	while connection ~= nil do
-		t_defer(
-			connection[1],
+		task.defer(
+			connection._func,
 			...
 		)
-		
-		if connection[5] then
-			-- If connection is one-fire only:
-			connection:Disconnect()
-		end
 
-		connection = connection[3] --> _next
+		connection = connection._next
 	end
 end
 
 function Signal:DisconnectAll()
-	local connection = self[1] -- _head
+	local connection = self._head
 	while connection ~= nil do
+		--connection:Disconnect()
+
 		connection.Connected = false
-		connection[2] = nil -- _signal = nil
-		connection[4] = nil -- _prev = nil
+		connection._prev = nil
+		connection._signal = nil
 
-		connection = connection[3] --> _next
+		connection = connection._next
 	end
-	self[1] = nil -- _head = nil
+	self._head = nil
 end
 
 function Signal:Destroy()
 	if not self:IsActive() then
 		return
 	end
 
-	self[2] = false
+	self._active = false
 	self:DisconnectAll()
 end
 
-function Signal:__call(_, func)
-	if not self:IsActive() then
-		return
-	end
-
-	assert(
-		typeof(func) == 'function',
-		":Connect must be called with a function"
-	)
-
-	return Connect(self, func)
-end
-
 return Signal