LazyStartup.jl

A simple package provides a way to delay the execution of startup code until it is needed by REPL. It might be useful if loading startup.jl will take a long time.

Usage

For a startup.jl file like this:

using Revise

function f()
    # do something
end

This code will be executed before start the REPL, and can be delayed by @lazy_startup:

using LazyStartup # NOTE: this package must be loaded in startup.jl

atreplinit() do repl
  lazy_startup_init!() # NOTE: this function must be called in atreplinit and after `REPL.numbered_prompt!`
end

@lazy_startup using Revise import * using * include(*)

@lazy_startup function f()
    # do something
end

The first argument of @lazy_startup is the expression to be evaluated, and rest of the arguments are patterns to match expressions input in the REPL, where * is a wildcard to match anything; if pattern is not provided, it will be generated automatically (rules for generating patterns see below). Here, the expression using Revise will be evaluated when import, using any module or include any file; and the expression function f() ... will be evaluated when it's used.

julia> isdefined(Main, :Revise)
false

julia> using Test

julia> isdefined(Main, :Revise)
true

julia> isdefined(Main, :f)
false

julia> f()

julia> isdefined(Main, :f)
true

Limitation: Using this package may increase startup time by about 0.1-0.5 seconds (compile time). Therefore this package is only recommended for code that significantly affects startup time, such as loading packages.

Define Pattern

There are some examples for how to define patterns:

using LazyStartup

# match import, using, and function call
@lazy_startup using Revise import * using * include(*)
# match symbol
@lazy_startup begin
  const FOO = 1
  foo(::Any) = FOO + 1
end foo
# match function call, the brackets are required
# without brackets, the pattern will be a symbol
@lazy_startup begin
  bar(::Any) = 1
  bar(::Int) = 2
end bar()
# match macro call, the brackets are optional for single pattern
# but required for multiple patterns
@lazy_startup using Test @test
@lazy_startup using BenchmarkTools @btime() @benchmark()

NOTE: The pattern matching is not sensitive for order and number of arguments. Thus, bar() will match bar(), bar(x), bar(x, y), and with more arguments. Similarly, @test will match @test, @test x, @test x y, and with more arguments.

Default Pattern

If pattern is not provided, patterns will be generated automatically.

Expression	Pattern
Declare variable: v = 1 or const v = 1	Variable name v
Function definition: f() = 1 or function f(); end	Function name f
macro definition: macro f(); end	Macro name @f
Import modules: import A	Module name A
Import submodule: import A.B	Submodule name B
Import function: import A.f	Function name f
Import and rename module: import A as B	Renamed module name B
Import and rename function: import A.f as g or import A: f as g	Renamed function name g
Others	A wildcard *

For other expressions, the pattern wildcard * will match anything, which means that the expression will evaluate after any input in the REPL. To avoid confusion, those expressions will show an info message, which can be silenced by set environment variable JULIA_LAZY_STARTUP_SILENT to true.

Besides, most of overhead causes by automatical parttern. Thus, specify all pattern manually may be helpful for startup time.