recommended way to pass functions from the environment into a mirai?

[agilly]

As detailed in this issue, the following patterns are problematic because they end up discovering/passing too much from the environment, which causes invoke-ation to take a large amount of time (4-10 seconds):

## pattern 1
my_func=function(x,y) { [...] }

  m_task = ExtendedTask$new(
    function(...) mirai(myfunc(x, y), ...)
  ) |> bind_task_button("m_btn")

observeEvent(input$m_btn, m_task$invoke(myfunc = my_func, x = input$n, y = input$delay))

## pattern 2
# this is in the server of a module
my_func=function(x,y) { [...] }

  m_task = ExtendedTask$new(
    function(...) mirai(myfunc(x, y), ...)
  ) |> bind_task_button("m_btn")

observeEvent(input$m_btn, m_task$invoke(x = input$n, y = input$delay))

## pattern 3
# this is in the server of a module
 m_task = ExtendedTask$new(
    function(...) mirai({
                              myfunc=function(x,y) { [...] }
                              myfunc(x, y)
                                   }, ...)
  ) |> bind_task_button("m_btn")

observeEvent(input$m_btn, m_task$invoke(myfunc = my_func, x = input$n, y = input$delay))

The only pattern that works (the other one I describe in the issue does not), is pattern 3:

ExtendedTask$new(
      function(a, b, c){
      	mirai({
      		myfunc=function(a,b,c){ ... defined here ...}
      		myfunc(a,b,c)
      	}, a=a, b=b, c=c)
      }
    )

I am keeping ExtendedTask here because I tried this in a Shiny context only.

The recommendation from that thread is to use crate:

myfunc=carrier::crate(function(a,b,c){
	...	
})
ExtendedTask$new(
      function(a, b, c){
      	mirai({
      		workfun(a,b,c)
      	}, a=a, b=b, c=c, workfun=myfunc)
      }
    )

This kind of works, but has the major hindrance that the function needs to be defined within the crate, and has other restrictions: notably, function calls have to be referenced by package name, even when it is extremely cumbersome, like with the data.table package.

It is possible to crate an existing function by doing crate(rlang::set_env(myfunc))), but this does not remove the restrictions above.

In practice, crate is so constraining that I never end up using it and always use pattern 3. However, this tends to produce very ugly code, and in particular, code duplication, because I need to redefine every function that I want to call inside a mirai separately.

My argument is that this severely limits the practical useability of mirai in a scenario that is perhaps not ideal, but that I can't imagine is uncommon: one where functions are defined in the environment and need to be used in a task.

In such a world, there would need to make this kind of pattern not take extra seconds or pass too much data, but the body of the functions only and its dependencies:

### somewhere, loaded at startup, e.g. in the R/ folder
myotherfunc=function(){...}

### somewhere else...
myfunc=function(a,b,c){
	dt=myotherfunc()
	setorder(dt, "col1") # data.table::setorder
	...
}

ExtendedTask$new(
      function(a, b, c){
      	mirai({
      		workfun(a,b,c)
      	}, a=a, b=b, c=c, workfun=myfunc, myotherfunc=myotherfunc)
      }
    )

Is there a way to reach such a goal? I ensure separately that all packages needed by the functions are loaded through everywhere.

[shikokuchuo]

Thanks for raising this. I wonder if you've tried the new carrier (0.3.0) - we've now made this easier to use.

That would let you do:

fn <- crate(\(a, b, c) myfunc(a, b, c), myfunc = myfunc, myotherfunc = myotherfunc)

Also as you mentioned, passing this once using everywhere() will be more efficient than passing it every time an ExtendedTask is invoked.