pub struct GXHandle<X: GXExt>(/* private fields */);Expand description
A handle to a running GX instance.
Drop the handle to shutdown the associated background tasks.
Implementations§
Source§impl<X: GXExt> GXHandle<X>
impl<X: GXExt> GXHandle<X>
Sourcepub fn subscriber(&self) -> Subscriber
pub fn subscriber(&self) -> Subscriber
Get a clone of the netidx subscriber used by this runtime.
Sourcepub async fn check(
&self,
path: Source,
initial_scope: Option<ArcStr>,
) -> Result<CheckResult>
pub async fn check( &self, path: Source, initial_scope: Option<ArcStr>, ) -> Result<CheckResult>
Check that a graphix module compiles and type-checks.
If path starts with netidx: the module is loaded from
netidx; otherwise it is loaded from the filesystem (or read
directly if Source::Internal). On success returns a
CheckResult containing both an env snapshot (as it would be
after the module was compiled) and the set of resolved name
references the compiler observed — useful for IDE tooling
(textDocument/references). The runtime’s live environment
is not altered — to keep the bindings live, use compile or
load.
§Error position info
Compile and parse failures attach a structured context to the
returned anyhow::Error carrying the originating Origin and
SourcePosition. IDE tooling and other consumers should
downcast_ref the error rather than scraping the chain’s
message strings:
graphix_compiler::expr::ErrorContext— wraps compile-time failures (bailat!-style bails andwrap!-attached typecheck errors). Carries the failingExpr, from whichposandoriare read.graphix_compiler::expr::ParserContext— wraps combine parser failures withOrigin+SourcePositionfields.
anyhow::Error::downcast_ref walks the context chain via
anyhow’s vtable and returns the outermost match, which for the
runtime’s compile path is the right one.
§IDE / LSP usage
CheckResult carries IDE side-channels populated only when
env.lsp_mode is set: references, module_references,
type_references, scope_map, sig_links, and
module_internals. The first four record where the compiler saw
each name and where it resolved; sig_links ties val foo in a
.gxi to its let foo = … impl in the paired .gx;
module_internals carries each module’s impl-side env so IDE
queries inside a module body can chase impl bind metadata that
isn’t visible from the project’s external view.
To check editor buffers without saving, layer a
[ModuleResolver::BufferOverride] into the resolver chain — its
override map shadows the on-disk version per path while
preserving Source::File origins, so reference matching and
goto-def land on the same file paths as a disk check would.
Sourcepub async fn check_with_resolvers(
&self,
path: Source,
resolvers: Vec<ModuleResolver>,
initial_scope: Option<ArcStr>,
) -> Result<CheckResult>
pub async fn check_with_resolvers( &self, path: Source, resolvers: Vec<ModuleResolver>, initial_scope: Option<ArcStr>, ) -> Result<CheckResult>
Like check but overrides the runtime’s resolver chain for
this call only. Used by IDE tooling to compile a project
against a project-scoped resolver chain (e.g. Files(<root>))
without having to rebuild the runtime.
initial_scope, when set, scopes the entire compilation under
the given module path (as if the source were the body of a
mod <scope> { ... } block). Used by the LSP when editing a
graphix package crate so its modules register under the
package’s namespace.
Sourcepub async fn compile(&self, text: ArcStr) -> Result<CompRes<X>>
pub async fn compile(&self, text: ArcStr) -> Result<CompRes<X>>
Compile and execute a graphix expression
If it generates results, they will be sent to all the channels that are
subscribed. When the CompExp objects contained in the CompRes are
dropped their corresponding expressions will be deleted. Therefore, you
can stop execution of the whole expression by dropping the returned
CompRes.
Sourcepub async fn load(&self, path: Source) -> Result<CompRes<X>>
pub async fn load(&self, path: Source) -> Result<CompRes<X>>
Load and execute a file or netidx value
When the CompExp objects contained in the CompRes are
dropped their corresponding expressions will be
deleted. Therefore, you can stop execution of the whole file
by dropping the returned CompRes.
Sourcepub async fn compile_callable(&self, id: Value) -> Result<Callable<X>>
pub async fn compile_callable(&self, id: Value) -> Result<Callable<X>>
Compile a callable interface to a lambda id
This is how you call a lambda directly from rust. When the returned
Callable is dropped the associated callsite will be delete.
Sourcepub async fn compile_callable_by_name(
&self,
env: &Env,
scope: &Scope,
name: &ModPath,
) -> Result<NamedCallable<X>>
pub async fn compile_callable_by_name( &self, env: &Env, scope: &Scope, name: &ModPath, ) -> Result<NamedCallable<X>>
Compile a callable interface to a late bound function by name
This allows you to call a function by name. Because of late binding it
has some additional complexity (though less than implementing it
yourself). You must call update on NamedCallable when you recieve
updates from the runtime in order to drive late binding. update will
also return Some when one of your function calls returns.
Sourcepub async fn compile_ref(&self, id: impl Into<BindId>) -> Result<Ref<X>>
pub async fn compile_ref(&self, id: impl Into<BindId>) -> Result<Ref<X>>
Compile a ref to a bind id
This will NOT return an error if the id isn’t in the environment.
Sourcepub async fn compile_ref_by_name(
&self,
env: &Env,
scope: &Scope,
name: &ModPath,
) -> Result<Ref<X>>
pub async fn compile_ref_by_name( &self, env: &Env, scope: &Scope, name: &ModPath, ) -> Result<Ref<X>>
Compile a ref to a name
Return an error if the name does not exist in the environment