Julia Module calling User Defined Function

I have a module which builds up some levels of abstraction for a simulation I'd like to perform. Let's say the lowest level of abstraction is a node (which we build into systems, if we truncate this at two levels of abstraction), which is a subtype of an abstract type I define in the module. The nodes are updated with a user-defined update! function.

I want the user to be able to define a new node and update! function, but the update! function should be callable from the module's system_update! function. An example is provided below:

module test_pack
abstract type Node end

struct System{N<:Node}
    nodes::Array{N,1}
end

function system_update!(s::System)
   update!.(s.nodes) 
end

export Node, System, system_update!
end


# import module
using Main.test_pack


# User-defined types and functions
mutable struct My_Node<:Node
    state
end
function update!(n::My_Node)
   n.state *= 2 
end


# Define system of user defined nodes
sys = System([My_Node(1), My_Node(2)])

# Run the system
system_update!(sys)

Running this code gives

ERROR: LoadError: UndefVarError: update! not defined

However, if I move the definition of My_Node and update! to within the module and then export My_Node, the code executes and return the appropriate 2,4 output.

Is there a way I can enable the type of behavior I expect, where the user defines the type and update! function, but the module-defined System can call those functions?

One way of doing what you want would be to set things up in such a way that the update! function is defined by the module, and the code which defines the My_Node type (deriving from Node) also defines a specific method extending the update! function.

Here, since there is no default implementation for update! working on an argument of abstract type Node, an empty generic function can be defined to only mark the function as "belonging" to the module, without providing any implementation.<br/>
The implementation of the TestPack.update!(::My_Node) method explicitly extends this function, referring to it via a fully qualified name.

module TestPack
abstract type Node end

struct System{N<:Node}
    nodes::Array{N,1}
end

function update! end

function system_update!(s::System)
    update!.(s.nodes)
end

export Node, System, system_update!
end


# import module
using .TestPack


# User-defined types and functions
mutable struct My_Node<:Node
    state
end

function TestPack.update!(n::My_Node)
    n.state *= 2
end


sys = System([My_Node(1), My_Node(2)])

# Run the system
system_update!(sys)

The code above runs without problem and yields:

julia> sys
System{My_Node}(My_Node[My_Node(2), My_Node(4)])

As an aside, note that it is customary in Julia to use CamelCase notations for the name of modules; in the example above, I renamed your module to TestPack to follow this stylistic convention.

The module can also be referred to as using .TestPack instead of using Main.TestPack; this is called a relative module path.