feat: Phase 8.2, 8.4, 8.5, 9.1 + C backend fixes
Phase 8.2 — Gradual Ownership: - Add tkRef/tkMutRef types and `mut` keyword - Add @[Checked] attribute for opt-in borrow checking - Reject assignment through &T in checked functions - examples/ownership.bux Phase 8.4 — CTFE: - Evaluate const func at compile-time via evalExpr/evalBlock - Fold const declarations to literals; emit #define in C - examples/ctfe.bux (Factorial(10) → 3628800) Phase 8.5 — Trait Bounds: - Change declFuncTypeParams from seq[string] to seq[TypeParam] (name + bound) - Parser handles <T: Comparable> - Sema checks typeImplements at call sites - Fix C backend: generic receivers + pointer self field access - examples/trait_bounds.bux Phase 9.1 — Package Manager: - Inline tables/arrays in TOML parser - bux add, bux install, bux.lock generation - Dependency resolution with git/path sources - Build pipeline merges dependency .bux sources C Backend Fixes: - resolveExprType(ekIdent) now applies typeSubst for generic params - Method desugaring works for monomorphized generic receivers - Pointer checks use isPointer (covers tkRef/tkMutRef) - Field access on &T emits -> instead of . Remove accidentally committed test binaries from tracking
This commit is contained in:
+59
-10
@@ -353,14 +353,14 @@ func Main() -> int {
|
||||
|
||||
---
|
||||
|
||||
## Gradual Ownership (Phase 8.2)
|
||||
## Gradual Ownership (Phase 8.2) ✅ Implemented
|
||||
|
||||
Bux introduces **gradual ownership** — the first language to offer opt-in borrow checking.
|
||||
Bux introduces **gradual ownership** — opt-in borrow checking. By default, Bux is permissive like C. With `@[Checked]`, the borrow checker enforces memory safety rules.
|
||||
|
||||
### Syntax
|
||||
|
||||
```bux
|
||||
// Default: permissive mode (like C/Nim)
|
||||
// Default: permissive mode (like C/Nim) — raw pointers, no checks
|
||||
func QuickSort(arr: *int, len: int) {
|
||||
for i in 0..len {
|
||||
arr[i] = arr[i] * 2;
|
||||
@@ -369,10 +369,18 @@ func QuickSort(arr: *int, len: int) {
|
||||
|
||||
// Opt-in: @[Checked] enables borrow checking
|
||||
@[Checked]
|
||||
func SafeMerge(a: &[int], b: &[int]) -> Vec<int> {
|
||||
// &T = shared reference (borrow checker enforced)
|
||||
// &mut T = mutable reference (exclusive)
|
||||
// own T = ownership transfer
|
||||
func Scale(val: &mut int) {
|
||||
*val = *val * 2; // OK: &mut T allows mutation
|
||||
}
|
||||
|
||||
@[Checked]
|
||||
func Read(val: &int) -> int {
|
||||
return *val; // OK: &T allows reading
|
||||
}
|
||||
|
||||
@[Checked]
|
||||
func BadWrite(val: &int) {
|
||||
*val = 42; // ERROR: cannot write through shared reference '&T'
|
||||
}
|
||||
```
|
||||
|
||||
@@ -381,9 +389,50 @@ func SafeMerge(a: &[int], b: &[int]) -> Vec<int> {
|
||||
| Type | Syntax | Description |
|
||||
|------|--------|-------------|
|
||||
| Raw pointer | `*T` | C-style pointer, no checks |
|
||||
| Shared ref | `&T` | Borrowed reference (checked) |
|
||||
| Mutable ref | `&mut T` | Exclusive mutable borrow |
|
||||
| Owned | `own T` | Ownership transfer |
|
||||
| Shared ref | `&T` | Borrowed reference (read-only in checked functions) |
|
||||
| Mutable ref | `&mut T` | Exclusive mutable borrow (allows mutation) |
|
||||
| Owned | `own T` | Ownership transfer (syntax parsed, not yet enforced) |
|
||||
|
||||
### Rules in @[Checked] functions
|
||||
|
||||
- `&T` cannot be used to mutate data (compile-time error)
|
||||
- `&mut T` allows mutation
|
||||
- `*T` pointers are unrestricted (escape hatch)
|
||||
- `&mut T` coerces to `&T` and `*T`
|
||||
|
||||
---
|
||||
|
||||
## Compile-Time Function Execution (CTFE) ✅ Implemented
|
||||
|
||||
`const func` functions are evaluated at compile time. Their results can be used in type sizes, array lengths, or other constant contexts.
|
||||
|
||||
```bux
|
||||
const func Factorial(n: int) -> int {
|
||||
if n <= 1 {
|
||||
return 1;
|
||||
}
|
||||
return n * Factorial(n - 1);
|
||||
}
|
||||
|
||||
const TABLE_SIZE = Factorial(10); // 3628800 — computed at compile time
|
||||
|
||||
func Main() -> int {
|
||||
let arr: [TABLE_SIZE]int; // Array size from compile-time value
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
### Supported in CTFE
|
||||
- Integer, boolean, and string literals
|
||||
- Arithmetic (`+`, `-`, `*`, `/`, `%`)
|
||||
- Comparisons and logical operators
|
||||
- `if` / `else` with constant conditions
|
||||
- Calls to other `const func` functions (including recursion)
|
||||
|
||||
### Limitations
|
||||
- No `while` / `for` loops (use recursion)
|
||||
- No `mut` references or heap allocation
|
||||
- No non-const function calls
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -0,0 +1,347 @@
|
||||
# Фаза 8 — Стратегия: Как Bux печели, без да бие пряко Rust/Nim/Zig
|
||||
|
||||
> **Дата:** 2026-05-31 | **Статус:** Фаза 8.1 ✅, 8.2-8.6 🔄
|
||||
> **Правило #1:** Не се биеш с някого там, където той е най-силен.
|
||||
|
||||
---
|
||||
|
||||
## 1. Проблемът с "да бием Rust"
|
||||
|
||||
Ако целта е "по-добър Rust", Bux губи още преди да започне. Rust има:
|
||||
- 10+ години ecosystem (crates.io → 150,000+ пакета)
|
||||
- Corporate backing (Amazon, Google, Microsoft, Mozilla)
|
||||
- LLVM backend с 30 години оптимизации
|
||||
- Стотици хиляди програмисти, които вече са преживели borrow checker-a
|
||||
|
||||
**Опитът да биеш Rust по безопасност е самоубийство.**
|
||||
|
||||
---
|
||||
|
||||
## 2. Умната стратегия: Не бий конкурентите — бий празното място между тях
|
||||
|
||||
Картата на пазара изглежда така:
|
||||
|
||||
```
|
||||
Безопасност
|
||||
▲
|
||||
│
|
||||
Rust ─────────┼───────── ■■■■■■■■■■■ (висока, но трябва да платиш за нея)
|
||||
│
|
||||
Bux ──────────┼──── ■■■■■■□□□□□□ (gradual — по избор)
|
||||
│
|
||||
Nim ──────────┼────── ■■■■■■□□□□ (GC — "достатъчно" безопасен)
|
||||
│
|
||||
C / Zig ──────┼── ■■■□□□□□□□□□ (ти си отговорен)
|
||||
│
|
||||
└─────────────────────> Скорост на писане
|
||||
```
|
||||
|
||||
**Никой не стои между "C-скорост на писане" и "Rust-безопасност" с опцията да избираш.**
|
||||
|
||||
Bux е единственият език, който позволява:
|
||||
- Да пишеш като C (raw pointers, без checks) за MVP
|
||||
- Да добавяш `@[Checked]` после, където е критично
|
||||
- Да имаш `Result`/`Option`/`?` без lifetime annotations в 90% от кода
|
||||
|
||||
**Това е нишата.** Не "по-добър Rust", ами "Rust-лекота, когато искаш; C-свобода, когато бързаш".
|
||||
|
||||
---
|
||||
|
||||
## 3. Какво означава това за фаза 8 — конкретно
|
||||
|
||||
### 3.1 Фаза 8.2 — Gradual Ownership (The Killer Feature)
|
||||
|
||||
**Статус сега:** Синтаксисът е парсен, но borrow checker-ът не работи.
|
||||
|
||||
**Защо е критично:** Без работещ `@[Checked]`, Bux е просто "Rux с по-добър stdlib". С него — ставаме единствени на пазара.
|
||||
|
||||
**Как да го имплементираме умно (не като Rust):**
|
||||
|
||||
```bux
|
||||
// Ниво 1: Без проверки — като C
|
||||
func ParseJson(data: *char8) -> *Value { ... }
|
||||
|
||||
// Ниво 2: Bounds checking, но без ownership
|
||||
func SafeAccess(arr: *int, len: int, idx: int) -> int { ... }
|
||||
|
||||
// Ниво 3: Пълен borrow checker — само където си решил
|
||||
@[Checked]
|
||||
func MergeSorted(a: &[int], b: &[int]) -> Vec<int> { ... }
|
||||
```
|
||||
|
||||
**Ключова разлика от Rust:**
|
||||
- Rust: `&T` е *всичко*. Ако искаш pointer, се бориш с компилатора.
|
||||
- Bux: `*T` е default. `&T` е upgrade.
|
||||
|
||||
**Имплементационен план (прагматичен):**
|
||||
|
||||
| Етап | Фичър | За какво е | Priority |
|
||||
|------|-------|-----------|----------|
|
||||
| 8.2.1 | `@[Checked]` атрибут — вкл/изкл на checker | Да знаем кога да проверяваме | **P0 — критично** |
|
||||
| 8.2.2 | `&T` shared reference + lifetime elision | Basic borrow без annotations | **P0** |
|
||||
| 8.2.3 | `&mut T` exclusive mutable | Да няма data races | **P0** |
|
||||
| 8.2.4 | Bounds checking на slices | Да няма buffer overflows | **P1** |
|
||||
| 8.2.5 | Explicit lifetimes `'a` | Само за сложни случаи | **P2** |
|
||||
| 8.2.6 | `own T` + move semantics | RAII без GC | **P2** |
|
||||
|
||||
**Какво ПРОПУСКАМЕ (за да не стане Rust #2):**
|
||||
- ❌ Няма да правим lifetime annotations задължителни
|
||||
- ❌ Няма да имаме `borrowck` грешки във всяка функция
|
||||
- ❌ Няма да правим NLL (non-lexical lifetimes) в първата версия
|
||||
|
||||
**Правило:** Първият `@[Checked]` да хване 80% от бъговете с 20% от сложността на Rust.
|
||||
|
||||
---
|
||||
|
||||
### 3.2 Фаза 8.3 — Concurrency
|
||||
|
||||
**Конкуренция:**
|
||||
- Go → goroutines + channels (прости, но с GC runtime)
|
||||
- Rust → async/await (сложен, но zero-cost)
|
||||
- Zig → няма built-in runtime (ти си го пишеш)
|
||||
|
||||
**Bux стратегия:** "Go-простота, но без GC"
|
||||
|
||||
```bux
|
||||
import Std::Task;
|
||||
import Std::Channel;
|
||||
|
||||
// Go-style, но compile-time проверка за Send/Sync
|
||||
func Worker(rx: Channel<int>) {
|
||||
for msg in rx {
|
||||
Process(msg);
|
||||
}
|
||||
}
|
||||
|
||||
func Main() -> int {
|
||||
let (tx, rx) = Channel::New<int>();
|
||||
Task::Spawn(Worker, rx); // Зелени нишки (M:N scheduler)
|
||||
tx.Send(42);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
**Защо това печели:**
|
||||
- Програмистите харесват Go concurrency, но мразят GC паузите
|
||||
- Rust async е прекалено сложен за средния екип
|
||||
- Bux дава goroutines без GC → уникална позиция
|
||||
|
||||
**Приоритет:** P1 (важно за привличане на Go екипи, но не спира shipping)
|
||||
|
||||
---
|
||||
|
||||
### 3.3 Фаза 8.4 — CTFE (Compile-Time Function Execution)
|
||||
|
||||
**Конкуренция:**
|
||||
- Zig → `comptime` е best-in-class
|
||||
- Nim → има CTFE, но с ограничения
|
||||
- Rust → `const fn` е силно ограничен (no loops, no heap)
|
||||
|
||||
**Bux стратегия:** "Nim-лесен синтаксис, Zig-мощност"
|
||||
|
||||
```bux
|
||||
const func Fib(n: int) -> int {
|
||||
if n <= 1 { return n; }
|
||||
return Fib(n-1) + Fib(n-2);
|
||||
}
|
||||
|
||||
const TABLE_SIZE = Fib(20); // Computed at compile time
|
||||
|
||||
// Use case: embedded / kernel development
|
||||
const func CrcTable() -> [256]uint32 { ... }
|
||||
const CRC_TABLE = CrcTable(); // Precomputed, zero runtime cost
|
||||
```
|
||||
|
||||
**Защо това печели:**
|
||||
- Embedded програмистите (където Rust доминира) обичат precomputed tables
|
||||
- Nim програмистите вече знаят този модел
|
||||
- Rust не може да го прави пълноценно
|
||||
|
||||
**Приоритет:** P1 — спира Rust програмисти, които се оплакват от `const fn` ограниченията.
|
||||
|
||||
---
|
||||
|
||||
### 3.4 Фаза 8.5 — Trait System
|
||||
|
||||
**Сега имаме:** `interface` + `extend` (като Go interfaces / basic Rust traits)
|
||||
|
||||
**Какво трябва:**
|
||||
- Trait bounds: `func Sort<T: Comparable>(arr: &mut Array<T>)`
|
||||
- Associated types: `type Output` inside trait
|
||||
- Blanket impls: `impl<T: Display> Printable for T`
|
||||
|
||||
**Защо е важно:** Без trait bounds, generics са ограничени. Не можеш да напишеш `Max<T: Ord>`.
|
||||
|
||||
**Но:** Да не правим Haskell. Само това, което Rust има и се ползва всеки ден.
|
||||
|
||||
**Приоритет:** P1 — без това stdlib-ът е куц.
|
||||
|
||||
---
|
||||
|
||||
### 3.5 Фаза 8.6 — Metaprogramming
|
||||
|
||||
**Конкуренция:**
|
||||
- Rust → proc macros са мощни, но болезнени (syn, quote crates)
|
||||
- Nim → макросите са лесни, но са на Nim-AST (труден за научаване модел)
|
||||
- Zig → `comptime` е мощен, но изисква да мислиш като компилатор
|
||||
|
||||
**Bux стратегия:** Два слоя:
|
||||
|
||||
**Слой 1 — Declarative macros (easy):**
|
||||
```bux
|
||||
macro! vec {
|
||||
[$($item:expr),*] => {
|
||||
{
|
||||
let mut arr = Array_New();
|
||||
$(Array_Push(&mut arr, $item);)*
|
||||
arr
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let v = vec![1, 2, 3]; // Expands at compile time
|
||||
```
|
||||
|
||||
**Слой 2 — Derive macros (medium):**
|
||||
```bux
|
||||
#[derive(Clone, Debug)]
|
||||
struct Point { x: int, y: int }
|
||||
// Auto-generates Clone_Point and Debug_Point
|
||||
```
|
||||
|
||||
**Защо не procedural macros (като Rust)?**
|
||||
Защото трябва да пишеш parser. Declarative + derive са 95% от use case-овете.
|
||||
|
||||
**Приоритет:** P2 (добре е за ecosystem, но не блокира v1.0)
|
||||
|
||||
---
|
||||
|
||||
## 4. Стратегическа матрица: Кого целим и с какво
|
||||
|
||||
### 4.1 Primary Target: Програмисти, които мразят borrow checker-a, но искат safety
|
||||
|
||||
| Те казват | Bux отговаря |
|
||||
|-----------|-------------|
|
||||
| "Rust е страхотен, но 6 месеца за MVP е смешно" | `*T` по default, `&T` само където искаш |
|
||||
| "Не искам да се бия с компилатора за linked list" | Без borrow checker за прототипи |
|
||||
| "Искам safety, но само на критичните 20% от кода" | `@[Checked]` на точните функции |
|
||||
|
||||
**Това са програмисти от:**
|
||||
- Game dev (Unity → custom engine, C++ → нещо по-добро)
|
||||
- Embedded (C → Rust опитали се, отказали се)
|
||||
- Startups (Go → искат performance без GC)
|
||||
|
||||
### 4.2 Secondary Target: Nim програмисти, които искат по-добър tooling
|
||||
|
||||
Nim е страхотен, но:
|
||||
- Няма algebraic enums (трябват макроси)
|
||||
- Exception-based error handling е остарял модел
|
||||
- Ecosystem е фрагментиран
|
||||
|
||||
Bux предлага:
|
||||
- Същата скорост на компилация
|
||||
- Същият C backend
|
||||
- Algebraic enums + Result/Option
|
||||
- Без GC (за системно програмиране)
|
||||
|
||||
### 4.3 Tertiary Target: C програмисти, които искат модерен език без отказ от контрол
|
||||
|
||||
Zig е пряк конкурент тук. Но Zig е *твърде* минималистичен.
|
||||
|
||||
Bux дава на C програмиста:
|
||||
- Generics (без `#define` магии)
|
||||
- Pattern matching
|
||||
- Modules (без header guards)
|
||||
- Но пак има `*T` и може да прави `*(int*)0x1234 = 42` ако иска
|
||||
|
||||
---
|
||||
|
||||
## 5. Какво НЕ правим (убийствено важно)
|
||||
|
||||
### ❌ Не правим LLVM backend сега
|
||||
C transpiler-ът е предимство, не слабост:
|
||||
- Компилира за <1 секунда
|
||||
- Работи навсякъде (gcc, clang, msvc)
|
||||
- Cross-compilation е безплатен (`--target` чрез C компилатора)
|
||||
|
||||
LLVM може да дойде Phase 10+ като опция.
|
||||
|
||||
### ❌ Не правим perfect borrow checker
|
||||
Rust-ският borrow checker е титаничен труд (10 години, стотици хора).
|
||||
Нашият цели 80% от ползата с 20% от кода:
|
||||
- Само `&T` и `&mut T`
|
||||
- Lifetime elision по default (без annotations в 90% от случаите)
|
||||
- Без higher-ranked lifetime traits (HRTB) — твърде сложно
|
||||
|
||||
### ❌ Не се конкурираме с Rust по ecosystem
|
||||
Crates.io е непреодолимо предимство. Ние се конкурираме с:
|
||||
- Лесен FFI към C (всички C библиотеки са твои)
|
||||
- По-малки програми, които не се нуждаят от 1000 dependencies
|
||||
|
||||
### ❌ Не правим ООП
|
||||
Няма класове, inheritance, virtual functions. Interface-ите са за trait-like поведение, не за ООП.
|
||||
|
||||
---
|
||||
|
||||
## 6. Пътна карта за победа (реалистична)
|
||||
|
||||
### Milestone A: "Използваем за CLI tools" (2-3 седмици)
|
||||
- ✅ Generics, Result/Option, pattern matching — готово
|
||||
- 🔄 Fix `buxc2` bootstrap loop (14/14 modules)
|
||||
- 🔄 File I/O, path ops, process spawn в stdlib
|
||||
- 🎯 Target: Можеш да напишеш `bux` package manager на Bux
|
||||
|
||||
### Milestone B: "Използваем за systems programming" (2 месеца)
|
||||
- 🔄 Working `@[Checked]` с basic borrow checking
|
||||
- 🔄 CTFE за precomputed tables
|
||||
- 🔄 Trait bounds (`T: Comparable`)
|
||||
- 🎯 Target: Можеш да напишеш game engine или embedded firmware
|
||||
|
||||
### Milestone C: "Екосистема" (6 месеца)
|
||||
- 🔄 Package manager (`bux add`, registry)
|
||||
- 🔄 LSP (autocomplete, hover)
|
||||
- 🔄 Formatter (`bux fmt`)
|
||||
- 🔄 Green threads + channels
|
||||
- 🎯 Target: Екип от 3 човека може да продуцира shipping продукт
|
||||
|
||||
### Milestone D: "Критична маса" (1-2 години)
|
||||
- 🔄 1000+ пакета в registry
|
||||
- 🔄 Първи corporate user (startup или game studio)
|
||||
- 🔄 Self-hosted compiler стабилен
|
||||
- 🎯 Target: "Знаеш ли Rust? Пробвай Bux ако трябва бързо."
|
||||
|
||||
---
|
||||
|
||||
## 7. Пазарно позициониране — как да говорим за Bux
|
||||
|
||||
### Грешно (никога не казваме това):
|
||||
- "Bux е по-добър Rust" → хората се смеят и затварят таба
|
||||
- "Bux е по-бърз от C" → лъжа, C backend сме
|
||||
- "Bux е новият C++" → твърде голяма хапка
|
||||
|
||||
### Правилно (казваме това):
|
||||
- "Bux е C с модерни типове и безопасност по избор"
|
||||
- "Пиши като Go, контролирай като C, проверявай като Rust — когато решиш"
|
||||
- "Единственият език, където safety е opt-in, не tax"
|
||||
|
||||
### Едно изречение:
|
||||
> "Bux gives you Rust's safety when you want it, C's freedom when you need it, and Go's simplicity all the time."
|
||||
|
||||
---
|
||||
|
||||
## 8. Заключение
|
||||
|
||||
Bux не печели като бие Rust, Nim или Zig.
|
||||
Bux печели като **запълва празното място между тях**.
|
||||
|
||||
| Ако искаш... | Избираш |
|
||||
|--------------|---------|
|
||||
| Максимална безопасност на всяка цена | Rust |
|
||||
| Максимална скорост на прототипиране с GC | Nim |
|
||||
| Максимален контрол и прозрачност | Zig |
|
||||
| **Баланс — бързо писане + безопасност по избор** | **Bux** |
|
||||
|
||||
**Фаза 8 е оръжейната:** Gradual ownership + CTFE + Traits + Concurrency.
|
||||
Ако имплементираме 8.2 (ownership) правилно — като opt-in upgrade, не като данък — Bux става единствен на пазара.
|
||||
|
||||
Ако го объркаме и стане "Rust-lite" — сме мъртви.
|
||||
@@ -0,0 +1,130 @@
|
||||
# Bux Package Manager
|
||||
|
||||
> **Status:** Implemented (Phase 9.1) | **Format:** Compatible with Rux.toml spec
|
||||
|
||||
---
|
||||
|
||||
## Manifest (`bux.toml`)
|
||||
|
||||
Every Bux package has a `bux.toml` at the project root.
|
||||
|
||||
```toml
|
||||
[Package]
|
||||
Name = "MyApp"
|
||||
Version = "0.1.0"
|
||||
Type = "bin" # bin | lib | shared | static
|
||||
Authors = ["Your Name <you@example.com>"]
|
||||
License = "MIT"
|
||||
|
||||
[Build]
|
||||
Output = "Bin"
|
||||
|
||||
[Dependencies]
|
||||
Std = "1.0"
|
||||
Json = { Version = "2.1", Source = "https://github.com/bux-lang/json" }
|
||||
Utils = { Path = "../Utils" }
|
||||
```
|
||||
|
||||
### Dependency Forms
|
||||
|
||||
| Form | Example | Description |
|
||||
|------|---------|-------------|
|
||||
| Version string | `Std = "1.0"` | Registry dependency |
|
||||
| Wildcard | `Std = "*"` | Latest version |
|
||||
| Inline table (git) | `{ Version = "1.4", Source = "https://..." }` | Git URL + version |
|
||||
| Inline table (path) | `{ Path = "../Lib" }` | Local path dependency |
|
||||
|
||||
---
|
||||
|
||||
## CLI Commands
|
||||
|
||||
### `bux add <name> [version]`
|
||||
|
||||
Add a dependency to `bux.toml`.
|
||||
|
||||
```bash
|
||||
# Add registry dependency
|
||||
bux add json "2.1"
|
||||
|
||||
# Add path-based dependency
|
||||
bux add utils --path "../utils"
|
||||
|
||||
# Add git dependency
|
||||
bux add network --git "https://github.com/bux-lang/network"
|
||||
```
|
||||
|
||||
### `bux install`
|
||||
|
||||
Resolve dependencies and generate `bux.lock`.
|
||||
|
||||
```bash
|
||||
bux install
|
||||
```
|
||||
|
||||
What it does:
|
||||
1. Reads `[Dependencies]` from `bux.toml`
|
||||
2. Resolves path-based deps (verifies directory exists)
|
||||
3. Clones/pulls git-based deps to `~/.bux/packages/<name>/`
|
||||
4. Generates `bux.lock` with exact versions and sources
|
||||
|
||||
### `bux build` / `bux run`
|
||||
|
||||
Automatically reads `bux.lock` and merges dependency source files into the build.
|
||||
|
||||
```bash
|
||||
bux build # Compile with all dependencies
|
||||
bux run # Build and run
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Lockfile (`bux.lock`)
|
||||
|
||||
Auto-generated. **Do not edit manually.**
|
||||
|
||||
```toml
|
||||
[[Package]]
|
||||
Name = "json"
|
||||
Version = "2.1.3"
|
||||
Source = "https://github.com/bux-lang/json"
|
||||
Checksum = "8dcb2a7f..."
|
||||
|
||||
[[Package]]
|
||||
Name = "utils"
|
||||
Version = "0.1.0"
|
||||
Source = "/home/user/projects/utils"
|
||||
```
|
||||
|
||||
The lockfile ensures **reproducible builds** — every developer gets the exact same dependency versions.
|
||||
|
||||
---
|
||||
|
||||
## Dependency Resolution Rules
|
||||
|
||||
1. **Path-based** deps are resolved relative to the manifest directory
|
||||
2. **Git-based** deps are cloned to `~/.bux/packages/<name>/`
|
||||
3. **Version-based** deps (without Source) require a registry (future feature)
|
||||
4. Dependencies are loaded from `<dep>/src/*.bux` at build time
|
||||
5. Later declarations shadow earlier ones (project > deps > stdlib)
|
||||
|
||||
---
|
||||
|
||||
## Example: Creating a Library
|
||||
|
||||
```bash
|
||||
bux new mylib
|
||||
cd mylib
|
||||
# Edit src/Main.bux → module MyLib { pub func Add(...) }
|
||||
bux build # Builds as library (Type = "lib")
|
||||
```
|
||||
|
||||
## Example: Using a Library
|
||||
|
||||
```bash
|
||||
bux new myapp
|
||||
cd myapp
|
||||
bux add mylib --path "../mylib"
|
||||
bux install
|
||||
# Edit src/Main.bux → import MyLib::Add;
|
||||
bux run
|
||||
```
|
||||
Reference in New Issue
Block a user