Enum ModulePath 

pub enum ModulePath {
    Std,
    ExplicitRue {
        path: String,
    },
    Simple {
        path: String,
    },
}

Represents a parsed import path with its resolution strategy.

This enum categorizes import paths to determine how they should be resolved. Each variant corresponds to a different resolution strategy.

Variants

Std

Standard library import: @import("std")

This is a special case that is currently not supported during const eval.

ExplicitRue

Import with explicit .gruel extension: @import("foo.gruel")

The path is taken as-is and matched against loaded file paths.

Fields

path: String

Simple

Simple module import: @import("foo") or @import("utils/strings")

Resolution tries:

1. {path}.gruel - standard file
2. _{basename}.gruel - facade file for directory modules

For nested paths like utils/strings, we look for utils/strings.gruel.

Fields

path: String

Implementations

impl ModulePath

pub fn parse(import_path: &str) -> Self

Parse an import path string into a structured ModulePath.

This determines the kind of import based on the path format.

Examples

ModulePath::parse("std") => ModulePath::Std
ModulePath::parse("foo.gruel") => ModulePath::ExplicitRue { path: "foo.gruel" }
ModulePath::parse("foo") => ModulePath::Simple { path: "foo" }
ModulePath::parse("utils/strings") => ModulePath::Simple { path: "utils/strings" }

pub fn resolve<'a, I>(&self, loaded_paths: I) -> Option<String>

where I: Iterator<Item = &'a String>,

Resolve this import path against a collection of loaded file paths.

Returns Some(resolved_path) if a match is found, or None if the module cannot be found.

The resolution order is:

1. Exact match (for ExplicitRue)
2. Standard file match ({path}.gruel)
3. Path suffix match (for nested paths)
4. Facade file match (_{basename}.gruel)

Trait Implementations

impl Clone for ModulePath

fn clone(&self) -> ModulePath

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModulePath

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

Formats the value using the given formatter.

impl PartialEq for ModulePath

fn eq(&self, other: &ModulePath) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ModulePath

impl StructuralPartialEq for ModulePath