Struct jlrs::wrappers::ptr::module::Module

#[repr(transparent)]
pub struct Module<'scope>(_, _);

Functionality in Julia can be accessed through its module system. You can get a handle to the three standard modules, Main, Base, and Core and access their submodules through them. If you include your own Julia code with Julia::include, AsyncJulia::include, or AsyncJulia::try_include its contents are made available relative to Main.

The most important methods offered by this wrapper are those that let you access submodules, functions, and other global values defined in the module. These come in two variants: one that roots the result and one that doesn’t. If you never redefine the module, it’s safe to leave named functions, constants and submodules unrooted when you use them from Rust. The same holds true for other global values that are never redefined to point at another value.

Implementations

impl<'scope> Module<'scope>

pub fn name(self) -> Symbol<'scope>

Returns the name of this module.

pub fn parent<'target, S>(self, scope: S) -> JlrsResult<Module<'target>> where
    S: PartialScope<'target>, 

Returns the parent of this module.

pub fn parent_ref(self) -> ModuleRef<'scope>

Returns the parent of this module without rooting it.

pub unsafe fn extend<'global>(self, _: Global<'global>) -> Module<'global>

Extend the lifetime of this module. This is safe as long as the module is never redefined.

pub fn main(_: Global<'scope>) -> Self

Returns a handle to Julia’s Main-module. If you include your own Julia code with Julia::include, AsyncJulia::include, or AsyncJulia::try_include its contents are made available relative to Main.

pub fn core(_: Global<'scope>) -> Self

Returns a handle to Julia’s Core-module.

pub fn base(_: Global<'scope>) -> Self

Returns a handle to Julia’s Base-module.

pub fn is_imported<N: ToSymbol>(self, sym: N) -> bool

Returns true if self has imported sym.

pub fn submodule<'target, N, S>(
    self,
    scope: S,
    name: N
) -> JlrsResult<Module<'target>> where
    N: ToSymbol,
    S: PartialScope<'target>, 

Returns the submodule named name relative to this module. You have to visit this level by level: you can’t access Main.A.B by calling this function with "A.B", but have to access A first and then B.

Returns an error if the submodule doesn’t exist.

pub fn submodule_ref<N>(self, name: N) -> JlrsResult<ModuleRef<'scope>> where
    N: ToSymbol, 

Returns the submodule named name relative to this module without rooting it. You have to access this level by level: you can’t access Main.A.B by calling this function with "A.B", but have to access A first and then B.

Returns an error if the submodule doesn’t exist.

pub unsafe fn set_global<'frame, N, S>(
    self,
    scope: S,
    name: N,
    value: Value<'_, 'static>
) -> JlrsResult<JuliaResult<'frame, 'static, ()>> where
    N: ToSymbol,
    S: PartialScope<'frame>, 

Set a global value in this module. Note that if this global already exists, this can make the old value unreachable. If an excection is thrown, it’s caught, rooted and returned.

Safety: Mutating Julia data is generally unsafe because it can’t be guaranteed mutating this value is allowed.

pub unsafe fn set_global_unrooted<N>(
    self,
    name: N,
    value: Value<'_, 'static>
) -> JlrsResult<JuliaResultRef<'scope, 'static, ()>> where
    N: ToSymbol, 

Set a global value in this module. Note that if this global already exists, this can make the old value unreachable. If an exception is thrown it’s caught but not rooted and returned.

Safety: Mutating Julia data is generally unsafe because it can’t be guaranteed mutating this value is allowed.

pub unsafe fn set_global_unchecked<N>(self, name: N, value: Value<'_, 'static>) where
    N: ToSymbol, 

Set a global value in this module. Note that if this global already exists, this can make the old value unreachable.

Safety: Mutating Julia data is generally unsafe because it can’t be guaranteed mutating this value is allowed.

pub fn set_const<'frame, N, S>(
    self,
    scope: S,
    name: N,
    value: Value<'_, 'static>
) -> JlrsResult<JuliaResult<'frame, 'static, ()>> where
    N: ToSymbol,
    S: PartialScope<'frame>, 

Set a constant in this module. If Julia throws an exception it’s caught and rooted in the current frame, if the exception can’t be rooted a JlrsError::AllocError is returned. If no exception is thrown an unrooted reference to the constant is returned.

pub fn set_const_unrooted<N>(
    self,
    name: N,
    value: Value<'_, 'static>
) -> JlrsResult<JuliaResultRef<'scope, 'static, ()>> where
    N: ToSymbol, 

Set a constant in this module. If Julia throws an exception it’s caught. Otherwise an unrooted reference to the constant is returned.

pub unsafe fn set_const_unchecked<N>(
    self,
    name: N,
    value: Value<'_, 'static>
) -> ValueRef<'scope, 'static> where
    N: ToSymbol, 

Set a constant in this module. If the constant already exists the process aborts, otherwise an unrooted reference to the constant is returned.

Safety: This method must not throw an error if called from a ccalled function.

pub fn global<'target, N, S>(
    self,
    scope: S,
    name: N
) -> JlrsResult<Value<'target, 'static>> where
    N: ToSymbol,
    S: PartialScope<'target>, 

Returns the global named name in this module. Returns an error if the global doesn’t exist.

pub fn global_ref<N>(self, name: N) -> JlrsResult<ValueRef<'scope, 'static>> where
    N: ToSymbol, 

Returns the global named name in this module without rooting it. Returns an error if the global doesn’t exist.

pub fn leaked_global<N>(self, name: N) -> JlrsResult<LeakedValue> where
    N: ToSymbol, 

Returns the global named name in this module as a LeakedValue. Returns an error if the global doesn’t exist.

pub fn function<'target, N, S>(
    self,
    scope: S,
    name: N
) -> JlrsResult<Function<'target, 'static>> where
    N: ToSymbol,
    S: PartialScope<'target>, 

Returns the function named name in this module. Returns an error if the function doesn’t exist or if it’s not a subtype of Function.

pub fn function_ref<N>(self, name: N) -> JlrsResult<FunctionRef<'scope, 'static>> where
    N: ToSymbol, 

Returns the function named name in this module without rooting it. Returns an error if the function doesn’t exist or if it’s not a subtype of Function.

pub fn as_leaked(self) -> LeakedValue

Convert self to a LeakedValue.

pub unsafe fn require<'target, S, N>(
    self,
    scope: S,
    module: N
) -> JlrsResult<JuliaResult<'target, 'static>> where
    S: PartialScope<'target>,
    N: ToSymbol, 

Load a module by calling Base.require and return this module if it has been loaded successfully. This method can be used to load parts of the standard library like LinearAlgebra. This requires one slot on the GC stack. Note that the loaded module is not made available in the module used to call this method, you can use Module::set_global to do so.

Note that when you want to call using Submodule in the Main module, you can do so by evaluating the using-statement with Value::eval_string.

Safety: This method can execute arbitrary Julia code depending on the module that is loaded.

pub unsafe fn require_unrooted<S>(
    self,
    global: Global<'scope>,
    module: S
) -> ModuleRef<'scope> where
    S: ToSymbol, 

Load a module by calling Base.require and return this module if it has been loaded successfully. This method can be used to load parts of the standard library like LinearAlgebra. Unlike Module::require, this method will panic if the module cannot be loaded. Note that the loaded module is not made available in the module used to call this method, you can use Module::set_global to do so.

Note that when you want to call using Submodule in the Main module, you can do so by evaluating the using-statement with Value::eval_string.

Safety: This method can execute arbitrary Julia code depending on the module that is loaded.

pub fn root<'target>(self, output: Output<'target>) -> Module<'target>

Use the Output to extend the lifetime of this data.

Trait Implementations

impl<'scope> AccessPlotsModule for Module<'scope>

fn plots<'global>(global: Global<'global>) -> Module<'global>

Returns the Plots module.

impl<'scope> Clone for Module<'scope>

fn clone(&self) -> Module<'scope>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Module<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'scope> PartialEq<Module<'scope>> for Module<'scope>

fn eq(&self, other: &Module<'scope>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Module<'scope>) -> bool

This method tests for !=.

impl<'scope> Copy for Module<'scope>

impl<'scope> StructuralPartialEq for Module<'scope>

impl<'target> Typecheck for Module<'target>