jlbun
    Preparing search index...

    Interface ScopedJulia

    Type for the scoped Julia proxy object.

    interface ScopedJulia {
        Any: JuliaDataType;
        Array: ScopedJuliaArray;
        Base: JuliaModule;
        Bool: JuliaDataType;
        Char: JuliaDataType;
        Core: JuliaModule;
        Dict: ScopedJuliaDict;
        Float16: JuliaDataType;
        Float32: JuliaDataType;
        Float64: JuliaDataType;
        Function: JuliaDataType;
        Int16: JuliaDataType;
        Int32: JuliaDataType;
        Int64: JuliaDataType;
        Int8: JuliaDataType;
        Main: JuliaModule;
        NamedTuple: ScopedJuliaNamedTuple;
        Nothing: JuliaDataType;
        nthreads: number;
        Pkg: JuliaModule;
        Set: ScopedJuliaSet;
        String: JuliaDataType;
        Symbol: JuliaDataType;
        Tuple: ScopedJuliaTuple;
        UInt16: JuliaDataType;
        UInt32: JuliaDataType;
        UInt64: JuliaDataType;
        UInt8: JuliaDataType;
        version: string;
        autoWrap(value: unknown): JuliaValue;
        call(fn: JuliaFunction, ...args: unknown[]): JuliaValue;
        callWithKwargs(
            fn: JuliaFunction,
            kwargs: JuliaNamedTuple | Record<string, unknown>,
            ...args: unknown[],
        ): JuliaValue;
        escape<T extends JuliaValue>(value: T): T;
        eval(code: string): JuliaValue;
        getTypeStr(ptr: JuliaValue | Pointer): string;
        import(name: string): JuliaModule;
        tagEval(strings: TemplateStringsArray, ...values: unknown[]): JuliaValue;
        track<T extends JuliaValue>(value: T): T;
        typeof(value: JuliaValue): JuliaDataType;
        untracked<T>(fn: () => T): T;
        wrapPtr(ptr: Pointer): JuliaValue;
    }
    Index

    Properties

    Proxy for creating auto-tracked JuliaArrays

    Proxy for creating auto-tracked JuliaDicts

    Float16: JuliaDataType
    Float32: JuliaDataType
    Float64: JuliaDataType
    Function: JuliaDataType

    Proxy for creating auto-tracked JuliaNamedTuples

    Nothing: JuliaDataType
    nthreads: number

    Proxy for creating auto-tracked JuliaSets

    Proxy for creating auto-tracked JuliaTuples

    version: string

    Methods

    • Execute a function without auto-tracking returned values.

      Use this when creating many temporary objects that don't need to survive beyond their immediate use. This improves performance by skipping the tracking overhead.

      Warning: Objects created inside untracked() may be garbage collected by Julia if no JS reference exists. Only use for temporary operations.

      Type Parameters

      • T

      Parameters

      • fn: () => T

      Returns T

      Julia.scope((julia) => {
      const arr = julia.Array.from(new Float64Array([1, 2, 3, 4, 5]));
      const range = julia.track(Julia.Base.UnitRange(2, 4));

      // Create many temporary SubArrays without tracking overhead
      let sum = 0;
      julia.untracked(() => {
      for (let i = 0; i < 10000; i++) {
      const sub = julia.Base.view(arr, range);
      sum += Julia.Base.sum(sub).value as number;
      }
      });
      return sum;
      });