developing-julia-package
/developing-julia-package
Wspiera pracę nad kodem istniejącego pakietu Julia: układ modułów i include, multiple dispatch, adnotacje i stabilność typów, formatowanie oraz docstringi.
- Autor
- atelierarith ↗
- Repozytorium
- atelier-arith-julia-development-skills ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 26.09.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 26.09.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Wspiera pracę nad kodem istniejącego pakietu Julia: układ modułów i include, multiple dispatch, adnotacje i stabilność typów, formatowanie oraz docstringi.
Oryginalny opis (EN)
Use when you implement or edit code inside an existing Julia package: module/`include` layout, multiple dispatch, type annotations and stability, formatting, and docstrings
Jak działa
- Avoid excessive exports
- Julia-idiomatic style
- Code formatting (JuliaFormatter)
- Performance and allocations
- Errors and documentation
Podgląd SKILL.md
---
name: developing-julia-package
description: Use when you implement or edit code inside an existing Julia package: module/`include` layout, multiple dispatch, type annotations and stability, formatting, and docstrings
---
# Developing a Julia package
Notes on developing Julia packages.
Assume the package is named `MyPkg`. Substitute your actual package name wherever `MyPkg` appears.
Use `src/MyPkg.jl` as the package entry point. Keep the module declaration, exports, and `include` list there; put substantial implementation in focused files under `src/`.
```julia
module MyPkg
export fit_model, FitResult, GaussianModel
include("models.jl")
include("fit.jl")
include("preprocess.jl")
end
```
Split files to improve readability, not to recreate Python-style class or submodule hierarchies. Prefer one public module unless there is a real user-facing namespace boundary.
Guidelines below.
## Avoid excessive `export`s
To audit and clean up an existing package's exports (for example, helpers
exported only so `Pkg.test` can reach them), see [[fixing-julia-exports]].
- Do not `export` helpers that are only used internally just so tests can reach them. Prefer importing explicitly in tests:
```julia
# test/runtests.jl
using Test
using MyPkg: <internal-only helper>
```
Test public behavior through the public API first. Import internals only when the helper has meaningful behavior that is hard to exercise through the public path:
```julia
using Test
using MyPkg
using MyPkg: initial_guess
@testset "fit_model" begin
result = fit_model(x, y; model = GaussianModel())
@test result isa FitResult
end
@testset "initial_guess" begin
@test initial_guess(x, y, GaussianModel()) isa NamedTuple
end
```
## Julia-idiomatic style
### Multiple dispatch
Prefer splitting behavior across methods instead of a large `if`/`elseif` chain on `isa`, unlike typical Python style.
```julia
# Do not write if else end
function f(x)
if x isa Integer
return 2x
else
return x
end
end
```
Instead, use multiple dispatch:
```julia
f(x) = x # generic implementation
f(x::Integer) = 2x # specialized implementation for x::Integer
```
For package APIs, make the dispatch object explicit and keep symbol options as a thin compatibility layer if needed:
```julia
abstract type AbstractModel end
struct GaussianModel <: AbstractModel
baseline::Bool
end
GaussianModel(; baseline = true) = GaussianModel(baseline)
fit_model(x, y; model::AbstractModel = GaussianModel()) =
fit_model(model, x, y)
function fit_model(model::GaussianModel, x, y)
guess = initial_guess(x, y, model)
# gaussian-specific implementation
end
```
Use a marker or configuration struct for the model choice, and use a separate result struct for fitted values. Do not mutate a model type into a mixed "algorithm plus fitted state" object unless that is clearly the public contract.
```julia
struct FitResult{P,T}
params::P
residuals::Vector{T}
converged::Bool
end
```
This keeps `GaussianModel()` as the method-selection/configuration value and `FitResult` as the returned fitted state.
### Type annotations
- On **public** APIs, narrow signatures when it prevents misuse or clarifies the contract.
- Inside the package, avoid over-constraining types everywhere; leave room for the compiler and for generic code.
### Type stability
- On hot paths, avoid return types that vary unpredictably across inputs; type instability prevents specialization and shows up as dynamic dispatch.
- Diagnose and fix it with the tools in [[profiling-julia-performance]] (Profile, JET.jl, AllocCheck.jl) instead of guessing.
## Code formatting (JuliaFormatter)
- Format package sources with **[JuliaFormatter.jl](https://github.com/domluna/JuliaFormatter.jl)** so layout and whitespace stay consistent across contributors and CI.
- Optionally commit a **`.JuliaFormatter.toml`** at the repository root (or rely on defaults) so everyone applies the same rules.
From the package root:
```julia
using JuliaFormatter
format(".") # formats src/, test/, etc. under the current directory
```
Run formatting before merging substantive edits; wire the same command into CI or pre-commit hooks if the team wants enforcement.
## Performance and allocations
- Confirm bottlenecks by profiling before optimizing; see [[profiling-julia-performance]] for the full workflow (Profile, JET.jl, AllocCheck.jl).
- For micro-benchmarks, use **`@benchmark` / `@btime`** from BenchmarkTools.jl rather than a single `@time`, which is dominated by variance and one-time effects.
- Watch unnecessary array copies from slicing and broadcasting; when an in-place API is needed, expose it explicitly (separate function name or keyword argument) so callers opt in.
## Errors and documentation
- Raise **`ArgumentError`**, **`DomainError`**, or other appropriate exceptions; messages should tell the caller what to fix.
- Give **docstrings** to exported/public functions—ordinary docstrings above definitions integrate cleanly with Documenter.jl; use `@doc` when you attach documentation programmatically.
Wersje
W bazie nie ma innych skilli o nazwie developing-julia-package.
Migawka bazy z 13.11.2026 · wersja paczki 2e2f365e5531 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100julia-pro
Pisze i optymalizuje programy w Julii 1.10+, z wielokrotnym dyspozytorowaniem, zarządzaniem pakietami i kodem do obliczeń numerycznych. - 100julia-expert
Wspiera pracę w Julii w obliczeniach naukowych, optymalizacji wydajności i analizie numerycznej, z systemem typów i programowaniem tablicowym. - 100generating-julia-package
Prowadzi przez tworzenie nowego pakietu lub środowiska projektu w Julii: układ katalogów, Project.toml, src, UUID, zależności i przygotowanie do rejestracji. - 95testing-julia-package
Konfiguruje i uruchamia testy pakietów Julia, w tym zależności testowe w workspace, Pkg.test() i równoległe pliki testów. - 100julia
Pomaga w pracy z językiem Julia: obliczenia numeryczne, wielokrotne wysyłanie, broadcasting i obliczenia równoległe w modelach naukowych i symulacjach. - 85julia-evaluation
Uruchamia i testuje kod Julia w trwałej sesji REPL oraz przeładowuje zmiany bez restartu.