1 files changed, 53 insertions, 35 deletions

diff --git a/src/lanes.lua b/src/lanes.lua
index 1286099..86dbe47 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -585,13 +585,25 @@ end
 
 end -- settings.with_timers
 
+-- avoid pulling the whole core module as upvalue when cancel_error is enough
+local cancel_error = assert( core.cancel_error)
+
 ---=== Lock & atomic generators ===---
 
 -- These functions are just surface sugar, but make solutions easier to read.
 -- Not many applications should even need explicit locks or atomic counters.
 
 --
--- lock_f= lanes.genlock( linda_h, key [,N_uint=1] )
+-- [true [, ...]= trues(uint)
+--
+local function trues( n)
+        if n > 0 then
+                return true, trues( n - 1)
+        end
+end
+
+--
+-- lock_f = lanes.genlock( linda_h, key [,N_uint=1] )
 --
 -- = lock_f( +M )   -- acquire M
 --      ...locked...
@@ -602,16 +614,10 @@ end -- settings.with_timers
 --
 -- PUBLIC LANES API
 local genlock = function( linda, key, N)
-        linda:set( key) -- clears existing data
-        linda:limit( key, N)
-
-        --
-        -- [true [, ...]= trues(uint)
-        --
-        local function trues( n)
-                if n > 0 then
-                        return true, trues( n - 1)
-                end
+        -- clear existing data and set the limit
+        N = N or 1
+        if linda:set( key) == cancel_error or linda:limit( key, N) == cancel_error then
+                return cancel_error
         end
 
         -- use an optimized version for case N == 1
@@ -623,7 +629,8 @@ local genlock = function( linda, key, N)
                         return linda:send( timeout, key, true)    -- suspends until been able to push them
                 else
                         local k = linda:receive( nil, key)
-                        return k and true or false
+                        -- propagate cancel_error if we got it, else return true or false
+                        return k and ((k ~= cancel_error) and true or k) or false
                 end
         end
         or
@@ -634,34 +641,45 @@ local genlock = function( linda, key, N)
                         return linda:send( timeout, key, trues(M))    -- suspends until been able to push them
                 else
                         local k = linda:receive( nil, linda.batched, key, -M)
-                        return k and true or false
+                        -- propagate cancel_error if we got it, else return true or false
+                        return k and ((k ~= cancel_error) and true or k) or false
                 end
         end
 end
 
 
---
--- atomic_f= lanes.genatomic( linda_h, key [,initial_num=0.0] )
---
--- int= atomic_f( [diff_num=1.0] )
---
--- Returns an access function that allows atomic increment/decrement of the
--- number in 'key'.
---
--- PUBLIC LANES API
-local function genatomic( linda, key, initial_val )
-    linda:limit(key,2)          -- value [,true]
-    linda:set(key,initial_val or 0.0)   -- clears existing data (also queue)
-
-    return
-    function(diff)
-        -- 'nil' allows 'key' to be numeric
-        linda:send( nil, key, true )    -- suspends until our 'true' is in
-        local val= linda:get(key) + (diff or 1.0)
-        linda:set( key, val )   -- releases the lock, by emptying queue
-        return val
-    end
-end
+        --
+        -- atomic_f = lanes.genatomic( linda_h, key [,initial_num=0.0])
+        --
+        -- int|cancel_error = atomic_f( [diff_num = 1.0])
+        --
+        -- Returns an access function that allows atomic increment/decrement of the
+        -- number in 'key'.
+        --
+        -- PUBLIC LANES API
+        local genatomic = function( linda, key, initial_val)
+                -- clears existing data (also queue). the slot may contain the stored value, and an additional boolean value
+                if linda:limit( key, 2) == cancel_error or linda:set( key, initial_val or 0.0) == cancel_error then
+                        return cancel_error
+                end
+
+                return function( diff)
+                        -- 'nil' allows 'key' to be numeric
+                        -- suspends until our 'true' is in
+                        if linda:send( nil, key, true) == cancel_error then
+                                return cancel_error
+                        end
+                        local val = linda:get( key)
+                        if val ~= cancel_error then
+                                val = val + (diff or 1.0)
+                                -- set() releases the lock by emptying queue
+                                if linda:set( key, val) == cancel_error then
+                                        val = cancel_error
+                                end
+                        end
+                        return val
+                end
+        end
 
         -- activate full interface
         lanes.require = core.require