I think it would be good if you could demonstrate this approach in a repo, although I don't think it's a good default for purescript-eff necessarily, which is supposed to be as lightweight and low-level as possible.

Here it is, it's stacksafe, and should be fast, (haven't done benchmarks, yet)
https://gist.github.com/safareli/ca3c3b066d4fe0ed5917bcdd0dcebf56

I could have made port of ps-catlist to js, but uncons might still have O(n) performance (if i understand it correctly), which would not be useful, tho having cat list with 0(1) uncons would be pretty useful (will take a look at okasaki) and will avoid need to go down to the leaf nodes in unsafeRun.

Looks interesting, but I'll need to study it more. Perhaps you could make a repo and package it up as a PureScript library on top of eff. It might be very useful for certain tasks.

Currently this is what results look like:

This is how test structures are generated:

applyLoop :: Monad m => (Int -> m Unit) -> Int -> m Unit
applyLoop eff max = go (pure unit) 0
  where 
  go acc n | n == max = acc
  go acc n = go (acc <* eff n) (n + 1)

bindRightLoop :: Monad m => (Int -> m Unit)  -> Int -> m Unit
bindRightLoop eff max = go (pure unit) 0
  where 
  go acc n | n == max = acc
  go acc n = go (eff (max - n - 1) >>= const acc) (n + 1)

bindLeftLoop :: Monad m => (Int -> m Unit)  -> Int -> m Unit
bindLeftLoop eff max = go (pure unit) 0
  where 
  go acc n | n == max = acc
  go acc n = go (acc >>= const (eff n)) (n + 1)

mapLoop :: Monad m => Int -> m Int -> m Int
mapLoop max i = 
  if max == 0 
    then i 
    else mapLoop (max - 1) (map (_ + 1) i)

Note that generations must be tail call optimized so stack is not overflowed during generation.

Max numbers for particular test type is restricted because of Eff, proposed implementation could handle:

• 10000000 right associated binds in around 10 sec (on 100000000 heap out of memory)
• 40000 left associated binds in around 2 sec
• 80000 left associated binds in around 20 sec
• 40000 map in around 200 msec
• 80000 map in around 20 sec
• 40000 apply in around 27 sec
• 80000 apply in around 2 min

So now there is heap memory and time constraints only.

Right associated binds perform extremely well, my guess is that operations array is smaller in that case. I used bind based implementations of map and apply but they performed badly than normal implementation.

Need to do a bit more testing & benchmarking. but here is the code safareli/purescript-ef#1
Would love to if you can take a look.

I think it looks great! It would be interesting to compare it to Coyoneda or Codensity over Eff too.

This is really cool, but just an FYI wrt minibench. You have to be sure to initiate a manual GC between each test. GC from previous runs will most definitely affect subsequent runs. I hit this problem when benching purescript-run.

initiate a manual GC between each test

have you done similar thing somewhere, can you link that?

For v8 you just call global.gc().

And call node with --expose-gc.

GC already gets run once inside minibench. Maybe this would make a good PR there.

@paf31 Maybe I was using an old version?

Thanks! I created an initial PR if you wanna review
safareli/purescript-ef#1

This is too fast :D