Remove assume_effects and use StableTasks.jl in apply[reduce]

StableTasks.jl allows type stable tasks (previously type unstable), so it's significantly easier to multithread.  This commit also shows how you could implement another "execution engine" a la what JuliaFolds2 does (maybe work stealing, etc) if you wanted.

In benchmarking, StableTasks does decrease the number of allocations which can only be a good thing.

Author: asinghvi17

GeometryOpsCore/Project.toml

@@ -6,10 +6,12 @@ version = "0.1.2"
 [deps]
 DataAPI = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
 GeoInterface = "cf35fbd7-0cd7-5166-be24-54bfbe79505f"
+StableTasks = "91464d47-22a1-43fe-8b7f-2d57ee82463f"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 
 [compat]
-julia = "1.9"
 DataAPI = "1"
 GeoInterface = "1.2"
+StableTasks = "0.1.5"
 Tables = "1"
+julia = "1.9"

GeometryOpsCore/src/GeometryOpsCore.jl

@@ -16,6 +16,7 @@ end
 
 using Tables
 using DataAPI
+import StableTasks
 
 include("keyword_docs.jl")
 include("types.jl")

GeometryOpsCore/src/apply.jl

@@ -319,6 +319,18 @@ end
 
 using Base.Threads: nthreads, @threads, @spawn
 
+#=
+Here we used to use the compiler directive `@assume_effects :foldable` to force the compiler
+to lookup through the closure. This alone makes e.g. `flip` 2.5x faster!
+
+But it caused inference to fail, so we've removed it.  No effect on runtime so far as we can tell, 
+at least in Julia 1.11.
+=#
+@inline function _maptasks(f::F, taskrange, threaded::False)::Vector where F
+    map(f, taskrange)
+end
+
+
 # Threading utility, modified Mason Protters threading PSA
 # run `f` over ntasks, where f receives an AbstractArray/range
 # of linear indices
@@ -333,22 +345,12 @@ using Base.Threads: nthreads, @threads, @spawn
     # Map over the chunks
     tasks = map(task_chunks) do chunk
         # Spawn a task to process this chunk
-        @spawn begin
+        StableTasks.@spawn begin
             # Where we map `f` over the chunk indices
             map(f, chunk)
         end
     end
 
     # Finally we join the results into a new vector
     return mapreduce(fetch, vcat, tasks)
-end
-#=
-Here we used to use the compiler directive `@assume_effects :foldable` to force the compiler
-to lookup through the closure. This alone makes e.g. `flip` 2.5x faster!
-
-But it caused inference to fail, so we've removed it.  No effect on runtime so far as we can tell, 
-at least in Julia 1.11.
-=#
-@inline function _maptasks(f::F, taskrange, threaded::False)::Vector where F
-    map(f, taskrange)
 end

GeometryOpsCore/src/applyreduce.jl

@@ -135,7 +135,7 @@ import Base.Threads: nthreads, @threads, @spawn
     # Map over the chunks
     tasks = map(task_chunks) do chunk
         # Spawn a task to process this chunk
-        @spawn begin
+        StableTasks.@spawn begin
             # Where we map `f` over the chunk indices
             mapreduce(f, op, chunk; init)
         end
@@ -144,6 +144,7 @@ import Base.Threads: nthreads, @threads, @spawn
     # Finally we join the results into a new vector
     return mapreduce(fetch, op, tasks; init)
 end
-Base.@assume_effects :foldable function _mapreducetasks(f::F, op, taskrange, threaded::False; init) where F
+
+function _mapreducetasks(f::F, op, taskrange, threaded::False; init) where F
     mapreduce(f, op, taskrange; init)
 end