tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(plugin): Fix plugin BoxRef return and Box argument support

Browse Source 
- Fixed deadlock in FileBox plugin copyFrom implementation (single lock)
- Added TLV Handle (tag=8) parsing in calls.rs for returned BoxRefs
- Improved plugin loader with config path consistency and detailed logging
- Fixed loader routing for proper Handle type_id/fini_method_id resolution
- Added detailed logging for TLV encoding/decoding in plugin_loader_v2

Test docs/examples/plugin_boxref_return.nyash now works correctly:
- cloneSelf() returns FileBox Handle properly
- copyFrom(Box) accepts plugin Box arguments
- Both FileBox instances close and fini correctly

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Moe Charm
2025-08-21 00:41:26 +09:00
parent af32896574
commit cc2a820af7
274 changed files with 7244 additions and 4608 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
docs/development/proposals/nyash.link/README.md Normal file
View File

@ -0,0 +1,267 @@
# nyash.linkシステム設計 - モジュール・依存関係管理革命
## 🎯 設計背景
### 📊 現状調査結果
- **include使用状況**: 主にexamples/text_adventureで10件程度、実用性は限定的
- **usingキーワード**: **未実装**（トークナイザーにも存在しない）
- **namespace設計**: Phase 9.75eで仕様完成、実装待ち
### 🌟 Gemini先生の推奨
> 「技術的に非常に妥当であり、現代的なプログラミング言語の設計として強く推奨される」
**結論**: includeほぼ未使用 + using未実装 = 完全に新設計で進められる！🎉
## 🚀 設計方針
### 💡 基本コンセプト
```
依存関係管理（nyash.link） + モジュールインポート（using） = 完璧な統合
```
### 🎯 他言語成功モデル
- **Rust**: `Cargo.toml + mod/use` - 厳格で分かりやすい
- **Node.js**: `package.json + import/export` - エコシステム成功
- **Python**: `pyproject.toml + import` - 依存関係分離
## 📋 nyash.linkファイル仕様
### 基本フォーマット
```toml
# nyash.link (プロジェクトルート)
[project]
name = "my-nyash-project"
version = "0.1.0"
description = "素晴らしいNyashプロジェクト"
[dependencies]
# 標準ライブラリ
nyashstd = { path = "./stdlib/nyashstd.nyash" }
# ユーザーライブラリ
mylib = { path = "./libs/mylib.nyash" }
utils = { path = "./src/utils.nyash" }
# 将来の外部パッケージ（例）
# http_client = { version = "1.0.0", registry = "nyash-pkg" }
[search_paths]
stdlib = "./stdlib/"
libs = "./libs/"
src = "./src/"
[build]
entry_point = "./src/main.nyash"
```
### 依存関係タイプ
#### 1. **ローカル依存**
```toml
[dependencies]
my_module = { path = "./src/my_module.nyash" }
```
#### 2. **標準ライブラリ**
```toml
[dependencies]
nyashstd = { stdlib = true } # 特別扱い
```
#### 3. **将来の外部パッケージ**
```toml
[dependencies]
awesome_lib = { version = "^1.2.0", registry = "nyash-pkg" }
```
## 🔧 usingシステム設計
### 1. トークナイザー拡張
```rust
// src/tokenizer.rs に追加
pub enum TokenType {
// 既存...
USING, // using (モジュールインポート)
NAMESPACE, // namespace (名前空間宣言)
}
```
### 2. パーサー拡張
```rust
// AST拡張
pub enum Statement {
// 既存...
UsingStatement {
module_path: Vec<String>, // ["nyashstd", "string"]
alias: Option<String>, // using nyashstd.string as str
},
NamespaceDeclaration {
name: String,
body: Vec<Statement>,
},
}
```
### 3. 基本構文
```nyash
// ===== using構文パターン =====
// パターンA: 名前空間全体
using nyashstd
string.upper("hello") // nyashstd.string.upper
math.sin(3.14) // nyashstd.math.sin
// パターンB: 特定機能（将来拡張）
using nyashstd.string
upper("hello") // string.upperを直接
// パターンC: エイリアス（将来拡張）
using nyashstd.string as str
str.upper("hello")
// パターンD: 完全修飾名（常時利用可能）
nyashstd.string.upper("hello") // using不要
```
## 📁 推奨ディレクトリ構造
### 基本プロジェクト構造
```
my-nyash-project/
├── nyash.link # 依存関係定義
├── src/
│ ├── main.nyash # エントリーポイント
│ ├── utils.nyash # ユーティリティモジュール
│ └── models/
│ └── user.nyash # モデル定義
├── libs/ # プロジェクト固有ライブラリ
│ └── mylib.nyash
├── stdlib/ # 標準ライブラリ（システム配布）
│ └── nyashstd.nyash
└── tests/ # テストファイル
└── test_main.nyash
```
### 標準ライブラリ構造
```
stdlib/
├── nyashstd.nyash # メインエントリー
├── string/
│ └── mod.nyash # string関連機能
├── math/
│ └── mod.nyash # 数学関数
├── http/
│ └── mod.nyash # HTTP関連
└── io/
└── mod.nyash # I/O関連
```
## 🔄 動作フロー
### 1. プロジェクト初期化
```bash
# 将来のCLI例
nyash init my-project # nyash.linkテンプレート生成
cd my-project
```
### 2. 実行時解決
```
main.nyash実行
↓
nyash.link読み込み
↓
using nyashstd解析
↓
./stdlib/nyashstd.nyash読み込み
↓
namespace nyashstd解析・登録
↓
string.upper()利用可能
```
### 3. 名前解決アルゴリズム
```
string.upper() 呼び出し
↓
1. ローカルスコープ検索
2. usingでインポートされた名前空間検索
3. 完全修飾名として解釈
4. エラー（未定義）
```
## 🧪 実装段階
### Phase 1: 最小実装
```nyash
// ✅ 実装目標
using mylib // 単純パス解決
mylib.hello() // 関数呼び出し
// nyash.link
[dependencies]
mylib = { path = "./mylib.nyash" }
```
### Phase 2: 名前空間サポート
```nyash
// ✅ 実装目標
using nyashstd
string.upper("hello")
// nyashstd.nyash
namespace nyashstd {
static box string {
static upper(str) { ... }
}
}
```
### Phase 3: 高度機能
- エイリアス（`using ... as ...`）
- 選択インポート（`using nyashstd.string`）
- 循環依存検出
- パッケージレジストリ連携
## ⚡ 実装優先順位
### 🚨 Critical（即時）
1. **UsingTokenizer実装** - Token::USINGを追加
2. **基本パーサー** - using文AST構築
3. **nyash.link解析** - TOML読み込み機能
### ⚡ High（今週）
4. **名前解決エンジン** - モジュール→ファイル解決
5. **基本テスト** - using mylib動作確認
6. **エラー処理** - 未定義モジュール等
### 📝 Medium（来週）
7. **namespace構文** - static box解析
8. **標準ライブラリ設計** - nyashstd.nyash作成
9. **完全修飾名** - nyashstd.string.upper()
### 🔮 Future（今後）
10. **IDE連携** - Language Server補完
11. **パッケージマネージャー** - 外部レジストリ
12. **循環依存検出** - 高度エラー処理
## 🎉 期待効果
### 📈 開発体験向上
- **IDE補完**: `ny`→全標準機能表示
- **探索可能性**: モジュール構造が明確
- **エラー削減**: 名前衝突・未定義の事前検出
### 🏗️ プロジェクト管理
- **依存関係明確化**: nyash.linkで一元管理
- **ビルド再現性**: 他環境での確実な動作
- **スケーラビリティ**: 大規模プロジェクト対応
### 🌍 エコシステム発展
- **ライブラリ共有**: 標準化されたモジュール形式
- **コミュニティ成長**: パッケージレジストリ基盤
- **言語成熟度**: モダンな言語仕様
---
**🐾 この設計でNyashが真にモダンなプログラミング言語になるにゃ！**

654
docs/development/proposals/nyash.link/bid-using-integration.md Normal file
View File

@ -0,0 +1,654 @@
# BID×usingシステム統合：技術実装詳細
## 🎯 統合設計の核心
### 📊 既存システムとの整合性
- ✅ **MIR ExternCall**: 既にFFI-ABI対応実装済み
- ✅ **WASM RuntimeImports**: BID→WASM自動生成基盤あり
- ✅ **VM ExternStub**: スタブ実行環境実装済み
- 🔧 **統合課題**: usingシステムとBIDの橋渡し実装
### 🚀 統合アーキテクチャ概要
```
User Code (using statements)
↓
UniversalNamespaceRegistry
↓
CallTarget Resolution
↓ ↓ ↓
Builtin FFI-ABI NyashModule
↓ ↓ ↓
MIR Generation (BuiltinCall/ExternCall/ModuleCall)
↓
Backend Execution (VM/WASM/AOT)
```
## 🏗️ 詳細技術実装
### 1. BID定義システム
#### **BIDファイル構造拡張**
```yaml
# apis/enhanced_canvas.yaml
version: 1
metadata:
name: "Enhanced Canvas API"
description: "Extended Canvas API with batch operations"
target_environments: ["browser", "node-canvas", "skia"]
nyash_namespace: "canvas_api" # usingで使用する名前空間
interfaces:
- name: canvas_api.canvas
box: Canvas
methods:
# 基本描画
- name: fillRect
params:
- {string: canvas_id, description: "Canvas element ID"}
- {i32: x, description: "X coordinate"}
- {i32: y, description: "Y coordinate"}
- {i32: width, description: "Rectangle width"}
- {i32: height, description: "Rectangle height"}
- {string: color, description: "Fill color (CSS format)"}
returns: void
effect: io
optimization_hints:
batch_compatible: true # バッチ処理可能
gpu_accelerated: true # GPU加速対応
# バッチ描画（最適化版）
- name: fillRectBatch
params:
- {string: canvas_id}
- {array_of_rect: rects, element_type: "CanvasRect"}
returns: void
effect: io
optimization_hints:
prefer_over: ["fillRect"] # 複数fillRectの代替
min_batch_size: 3
# テキスト描画
- name: fillText
params:
- {string: canvas_id}
- {string: text}
- {i32: x}
- {i32: y}
- {string: font}
- {string: color}
returns: void
effect: io
# カスタム型定義
custom_types:
- name: CanvasRect
fields:
- {i32: x}
- {i32: y}
- {i32: width}
- {i32: height}
- {string: color}
```
#### **BID読み込み・検証システム**
```rust
// 新ファイル: src/bid/mod.rs
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BidDefinition {
pub version: u32,
pub metadata: BidMetadata,
pub interfaces: Vec<BidInterface>,
pub custom_types: Option<Vec<BidCustomType>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BidMetadata {
pub name: String,
pub description: String,
pub target_environments: Vec<String>,
pub nyash_namespace: String, // using文で使用する名前空間名
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BidInterface {
pub name: String, // "canvas_api.canvas"
pub box_name: String, // "Canvas"
pub methods: Vec<BidMethod>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BidMethod {
pub name: String,
pub params: Vec<BidParam>,
pub returns: BidType,
pub effect: BidEffect,
pub optimization_hints: Option<BidOptimizationHints>,
pub description: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct BidOptimizationHints {
pub batch_compatible: Option<bool>,
pub gpu_accelerated: Option<bool>,
pub prefer_over: Option<Vec<String>>,
pub min_batch_size: Option<usize>,
}
impl BidDefinition {
pub fn load_from_file(path: &Path) -> Result<Self, BidError> {
let content = std::fs::read_to_string(path)?;
let bid: BidDefinition = serde_yaml::from_str(&content)?;
// バリデーション
bid.validate()?;
Ok(bid)
}
pub fn validate(&self) -> Result<(), BidError> {
// バージョン確認
if self.version > 1 {
return Err(BidError::UnsupportedVersion(self.version));
}
// 名前空間重複チェック
let mut interface_names = HashSet::new();
for interface in &self.interfaces {
if interface_names.contains(&interface.name) {
return Err(BidError::DuplicateInterface(interface.name.clone()));
}
interface_names.insert(interface.name.clone());
}
// パラメータ型確認
for interface in &self.interfaces {
for method in &interface.methods {
for param in &method.params {
self.validate_type(&param.param_type)?;
}
self.validate_type(&method.returns)?;
}
}
Ok(())
}
pub fn resolve_method(&self, box_name: &str, method_name: &str)
-> Option<&BidMethod> {
for interface in &self.interfaces {
// インターフェース名から最後の部分を取得
// "canvas_api.canvas" → "canvas"
let interface_box_name = interface.name.split('.').last().unwrap_or(&interface.name);
if interface_box_name == box_name {
for method in &interface.methods {
if method.name == method_name {
return Some(method);
}
}
}
}
None
}
}
```
### 2. 統合名前空間レジストリ詳細
#### **UniversalNamespaceRegistry実装**
```rust
// src/registry/universal.rs
use crate::stdlib::BuiltinStdlib;
use crate::bid::BidDefinition;
use crate::module::ExternalModule;
use crate::mir::Effect;
pub struct UniversalNamespaceRegistry {
/// 組み込み標準ライブラリ
builtin_stdlib: Arc<BuiltinStdlib>,
/// FFI-ABI定義（BID）
bid_definitions: HashMap<String, Arc<BidDefinition>>,
/// Nyashモジュール（従来）
nyash_modules: HashMap<String, Arc<ExternalModule>>,
/// ファイル別usingコンテキスト
using_contexts: Arc<RwLock<HashMap<String, UsingContext>>>,
/// 最適化情報キャッシュ
optimization_cache: Arc<RwLock<OptimizationCache>>,
}
#[derive(Debug, Clone)]
pub struct UsingContext {
pub file_id: String,
pub builtin_namespaces: Vec<String>, // ["nyashstd"]
pub bid_namespaces: Vec<String>, // ["canvas_api", "console_api"]
pub module_namespaces: Vec<String>, // ["mylib", "utils"]
}
impl UniversalNamespaceRegistry {
pub fn new() -> Self {
UniversalNamespaceRegistry {
builtin_stdlib: Arc::new(BuiltinStdlib::new()),
bid_definitions: HashMap::new(),
nyash_modules: HashMap::new(),
using_contexts: Arc::new(RwLock::new(HashMap::new())),
optimization_cache: Arc::new(RwLock::new(OptimizationCache::new())),
}
}
pub fn load_from_nyash_link(&mut self, nyash_link: &NyashLink)
-> Result<(), RegistryError> {
// BID依存関係読み込み
for (namespace_name, dependency) in &nyash_link.dependencies {
match dependency {
Dependency::Bid { bid_path, .. } => {
let bid = BidDefinition::load_from_file(Path::new(bid_path))?;
self.bid_definitions.insert(namespace_name.clone(), Arc::new(bid));
},
Dependency::Path { path } => {
let module = ExternalModule::load_from_file(Path::new(path))?;
self.nyash_modules.insert(namespace_name.clone(), Arc::new(module));
},
Dependency::Builtin { .. } => {
// 組み込みライブラリは既に初期化済み
},
}
}
Ok(())
}
/// 統合using処理
pub fn process_using(&mut self, namespace_name: &str, file_id: &str)
-> Result<(), RuntimeError> {
let mut contexts = self.using_contexts.write().unwrap();
let context = contexts.entry(file_id.to_string()).or_insert_with(|| {
UsingContext {
file_id: file_id.to_string(),
builtin_namespaces: Vec::new(),
bid_namespaces: Vec::new(),
module_namespaces: Vec::new(),
}
});
// 組み込み標準ライブラリチェック
if self.builtin_stdlib.has_namespace(namespace_name) {
if !context.builtin_namespaces.contains(&namespace_name.to_string()) {
context.builtin_namespaces.push(namespace_name.to_string());
}
return Ok(());
}
// BID定義チェック
if let Some(bid) = self.bid_definitions.get(namespace_name) {
if !context.bid_namespaces.contains(&namespace_name.to_string()) {
context.bid_namespaces.push(namespace_name.to_string());
}
return Ok(());
}
// Nyashモジュールチェック
if let Some(_module) = self.nyash_modules.get(namespace_name) {
if !context.module_namespaces.contains(&namespace_name.to_string()) {
context.module_namespaces.push(namespace_name.to_string());
}
return Ok(());
}
Err(RuntimeError::UndefinedNamespace(namespace_name.to_string()))
}
/// 統合関数解決
pub fn resolve_call(&self, file_id: &str, call_path: &[String])
-> Result<ResolvedCall, RuntimeError> {
if call_path.len() != 2 {
return Err(RuntimeError::InvalidCallPath(call_path.join(".")));
}
let box_name = &call_path[0];
let method_name = &call_path[1];
let contexts = self.using_contexts.read().unwrap();
if let Some(context) = contexts.get(file_id) {
// 1. 組み込み標準ライブラリ解決
for namespace in &context.builtin_namespaces {
if let Some(method) = self.builtin_stdlib.resolve_method(namespace, box_name, method_name) {
return Ok(ResolvedCall::Builtin {
namespace: namespace.clone(),
box_name: box_name.clone(),
method_name: method_name.clone(),
method_info: method,
});
}
}
// 2. BID定義解決
for namespace in &context.bid_namespaces {
if let Some(bid) = self.bid_definitions.get(namespace) {
if let Some(method) = bid.resolve_method(box_name, method_name) {
return Ok(ResolvedCall::BidCall {
namespace: namespace.clone(),
interface_name: format!("{}.{}", namespace, box_name),
method_name: method_name.clone(),
method_info: method.clone(),
bid_definition: bid.clone(),
});
}
}
}
// 3. Nyashモジュール解決
for namespace in &context.module_namespaces {
if let Some(module) = self.nyash_modules.get(namespace) {
if let Some(function) = module.resolve_function(box_name, method_name) {
return Ok(ResolvedCall::ModuleCall {
namespace: namespace.clone(),
module_name: namespace.clone(),
function_name: format!("{}.{}", box_name, method_name),
function_info: function,
});
}
}
}
}
Err(RuntimeError::UndefinedMethod(format!("{}.{}", box_name, method_name)))
}
}
#[derive(Debug, Clone)]
pub enum ResolvedCall {
Builtin {
namespace: String,
box_name: String,
method_name: String,
method_info: BuiltinMethodInfo,
},
BidCall {
namespace: String,
interface_name: String,
method_name: String,
method_info: BidMethod,
bid_definition: Arc<BidDefinition>,
},
ModuleCall {
namespace: String,
module_name: String,
function_name: String,
function_info: ModuleFunctionInfo,
},
}
```
### 3. MIR生成統合
#### **統合MIR Builder**
```rust
// src/mir/builder.rs拡張
impl MirBuilder {
pub fn build_unified_method_call(&mut self, resolved_call: ResolvedCall, args: Vec<ValueId>)
-> Result<Option<ValueId>, MirError> {
match resolved_call {
ResolvedCall::Builtin { method_info, .. } => {
let result = self.new_value_id();
self.emit(MirInstruction::BuiltinCall {
qualified_name: method_info.qualified_name(),
args,
result,
effect: method_info.effect(),
});
Ok(Some(result))
},
ResolvedCall::BidCall { interface_name, method_name, method_info, .. } => {
let result = if method_info.returns == BidType::Void {
None
} else {
Some(self.new_value_id())
};
self.emit(MirInstruction::ExternCall {
interface: interface_name,
method: method_name,
args,
result,
effect: self.bid_effect_to_mir_effect(&method_info.effect),
bid_signature: BidSignature::from_method(&method_info),
});
Ok(result)
},
ResolvedCall::ModuleCall { module_name, function_name, function_info, .. } => {
let result = self.new_value_id();
self.emit(MirInstruction::ModuleCall {
module: module_name,
function: function_name,
args,
result,
effect: Effect::Io, // Nyashモジュールはデフォルトでio
});
Ok(Some(result))
},
}
}
fn bid_effect_to_mir_effect(&self, bid_effect: &BidEffect) -> Effect {
match bid_effect {
BidEffect::Pure => Effect::Pure,
BidEffect::Mut => Effect::Mut,
BidEffect::Io => Effect::Io,
BidEffect::Control => Effect::Control,
}
}
}
```
### 4. バックエンド統合
#### **WASM生成統合**
```rust
// src/backend/wasm/codegen.rs拡張
impl WasmCodegen {
pub fn generate_unified_call(&mut self, instruction: &MirInstruction)
-> Result<(), WasmError> {
match instruction {
MirInstruction::ExternCall { interface, method, args, bid_signature, .. } => {
// BIDから自動生成されたWASM import名
let wasm_import_name = self.bid_to_wasm_import_name(interface, method);
// 引数の型変換・マーシャリング
let marshalled_args = self.marshal_args_for_wasm(args, &bid_signature.params)?;
// WASM関数呼び出し生成
self.emit_call(&wasm_import_name, &marshalled_args)?;
// 戻り値のアンマーシャリング
if bid_signature.returns != BidType::Void {
self.unmarshal_return_value(&bid_signature.returns)?;
}
Ok(())
},
// 他の命令は既存実装
_ => self.generate_instruction_legacy(instruction),
}
}
fn bid_to_wasm_import_name(&self, interface: &str, method: &str) -> String {
// "canvas_api.canvas" + "fillRect" → "canvas_api_canvas_fillRect"
format!("{}_{}", interface.replace(".", "_"), method)
}
fn marshal_args_for_wasm(&mut self, args: &[ValueId], params: &[BidParam])
-> Result<Vec<WasmValue>, WasmError> {
let mut marshalled = Vec::new();
for (i, param) in params.iter().enumerate() {
let arg_value = self.get_value(args[i])?;
match &param.param_type {
BidType::String => {
// 文字列を (ptr, len) にマーシャル
let (ptr, len) = self.string_to_wasm_memory(&arg_value)?;
marshalled.push(WasmValue::I32(ptr));
marshalled.push(WasmValue::I32(len));
},
BidType::I32 => {
marshalled.push(WasmValue::I32(arg_value.to_i32()?));
},
BidType::F64 => {
marshalled.push(WasmValue::F64(arg_value.to_f64()?));
},
// その他の型...
}
}
Ok(marshalled)
}
}
```
#### **VM実行統合**
```rust
// src/backend/vm.rs拡張
impl VmBackend {
pub fn execute_unified_instruction(&mut self, instruction: &MirInstruction)
-> Result<(), VmError> {
match instruction {
MirInstruction::ExternCall { interface, method, args, bid_signature, .. } => {
// VM環境ではスタブまたはネイティブ呼び出し
let evaluated_args = self.evaluate_args(args)?;
if let Some(native_impl) = self.find_native_implementation(interface, method) {
// ネイティブ実装がある場合（例：ファイルI/O）
let result = native_impl.call(evaluated_args, bid_signature)?;
if let Some(result_id) = &instruction.result {
self.set_value(*result_id, result);
}
} else {
// スタブ実装（ログ出力等）
self.execute_stub_call(interface, method, evaluated_args, bid_signature)?;
}
Ok(())
},
// 他の命令は既存実装
_ => self.execute_instruction_legacy(instruction),
}
}
fn find_native_implementation(&self, interface: &str, method: &str)
-> Option<&dyn NativeImplementation> {
// VM環境で利用可能なネイティブ実装を検索
match (interface, method) {
("env.console", "log") => Some(&self.console_impl),
("env.filesystem", "read") => Some(&self.filesystem_impl),
("env.filesystem", "write") => Some(&self.filesystem_impl),
_ => None,
}
}
}
```
## 🧪 統合テスト戦略
### Phase別テスト実装
#### **Phase 0: 基本統合テスト**
```nyash
# test_basic_integration.nyash
using nyashstd
# 組み込み標準ライブラリのみ
assert(string.upper("test") == "TEST")
assert(math.sin(0) == 0)
```
#### **Phase 1: BID統合テスト**
```nyash
# test_bid_integration.nyash
using nyashstd
using console_api
# 組み込み + FFI-ABI
string.upper("hello") # 組み込み
console.log("Testing") # FFI-ABI
```
#### **Phase 2: 完全統合テスト**
```nyash
# test_full_integration.nyash
using nyashstd
using console_api
using mylib
# 3種類すべて
string.upper("test") # 組み込み
console.log("Integration") # FFI-ABI
mylib.process("data") # Nyashモジュール
```
### エラーハンドリングテスト
```nyash
# test_error_handling.nyash
try {
using nonexistent_api
} catch error {
assert(error.type == "UndefinedNamespace")
}
try {
console.nonexistent_method("test")
} catch error {
assert(error.type == "UndefinedMethod")
assert(error.message.contains("Available methods:"))
}
```
## 📊 実装マイルストーン
### ✅ Phase 0完了条件
- [ ] UniversalNamespaceRegistry基盤実装
- [ ] 組み込み標準ライブラリ統合
- [ ] 基本using文処理
- [ ] MIR BuiltinCall生成
### ✅ Phase 1完了条件
- [ ] BID定義読み込み・検証
- [ ] BID→MIR ExternCall統合
- [ ] WASM RuntimeImports自動生成
- [ ] VM スタブ実行
### ✅ Phase 2完了条件
- [ ] Nyashモジュール統合
- [ ] 統合エラーハンドリング
- [ ] 最適化キャッシュ
- [ ] 全バックエンド対応
---
**🎯 この詳細実装により、BIDとusingシステムの完全統合が実現でき、「なんでもAPI計画」の技術基盤が完成するにゃ！🚀🐱**

456
docs/development/proposals/nyash.link/builtin-stdlib-architecture.md Normal file
View File

@ -0,0 +1,456 @@
# 組み込みnyashstd名前空間アーキテクチャ設計
## 🏗️ 技術的実装アーキテクチャ
### 📊 現在のインタープリター構造分析
#### **NyashInterpreter構造**
```rust
pub struct NyashInterpreter {
pub(super) shared: SharedState, // 共有状態
pub(super) local_vars: HashMap<String, SharedNyashBox>,
pub(super) outbox_vars: HashMap<String, SharedNyashBox>,
// その他の制御フロー状態...
}
```
#### **設計判断：SharedStateに組み込み**
- **理由**: 標準ライブラリは不変・全インタープリターで共有可能
- **利点**: メモリ効率、パフォーマンス向上
- **実装**: SharedStateに`builtin_stdlib`フィールド追加
## 🌟 最適化されたアーキテクチャ設計
### 1. SharedState拡張
#### **src/interpreter/core.rs**
```rust
#[derive(Clone)]
pub struct SharedState {
// 既存フィールド...
pub global_vars: Arc<RwLock<HashMap<String, SharedNyashBox>>>,
pub functions: Arc<RwLock<HashMap<String, Function>>>,
pub box_definitions: Arc<RwLock<HashMap<String, Box<UserDefinedBoxDefinition>>>>,
pub loop_counter: Arc<AtomicU64>,
pub included_files: Arc<RwLock<HashSet<String>>>,
// 🌟 新規追加: 組み込み標準ライブラリ
pub builtin_stdlib: Arc<BuiltinStdlib>,
pub using_imports: Arc<RwLock<HashMap<String, UsingContext>>>, // ファイル別インポート管理
}
#[derive(Debug, Clone)]
pub struct UsingContext {
pub imported_namespaces: Vec<String>, // ["nyashstd"]
pub file_id: String, // インポート元ファイル識別
}
```
### 2. BuiltinStdlib効率化設計
#### **新ファイル: src/stdlib/builtin.rs**
```rust
//! 🚀 高性能組み込み標準ライブラリ
//!
//! 設計方針:
//! - Zero-allocation関数実行
//! - 高速名前解決
//! - 既存Box実装の最大活用
use crate::boxes::*;
use std::collections::HashMap;
/// 組み込み標準ライブラリのメイン構造体
#[derive(Debug)]
pub struct BuiltinStdlib {
/// 高速アクセス用：フラットな関数マップ
/// "string.upper" -> BuiltinFunction
pub flat_functions: HashMap<String, BuiltinFunction>,
/// IDE補完用：階層構造
/// "nyashstd" -> { "string" -> ["upper", "lower", ...] }
pub hierarchical_map: HashMap<String, HashMap<String, Vec<String>>>,
}
/// 組み込み関数の実装
pub struct BuiltinFunction {
pub namespace: &'static str, // "nyashstd"
pub box_name: &'static str, // "string"
pub method_name: &'static str, // "upper"
pub implementation: BuiltinMethodImpl,
pub arg_count: Option<usize>, // None = 可変長
pub description: &'static str, // エラーメッセージ・ヘルプ用
}
/// 高性能関数実装
pub type BuiltinMethodImpl = fn(&[Box<dyn NyashBox>]) -> Result<Box<dyn NyashBox>, RuntimeError>;
impl BuiltinStdlib {
/// 🚀 標準ライブラリ初期化（起動時1回のみ）
pub fn new() -> Self {
let mut stdlib = BuiltinStdlib {
flat_functions: HashMap::new(),
hierarchical_map: HashMap::new(),
};
// 標準関数登録
stdlib.register_all_functions();
stdlib
}
/// ⚡ 高速関数解決
pub fn get_function(&self, qualified_name: &str) -> Option<&BuiltinFunction> {
// "string.upper" で直接アクセス
self.flat_functions.get(qualified_name)
}
/// 🔍 IDE補完用：利用可能関数一覧取得
pub fn get_available_methods(&self, namespace: &str, box_name: &str) -> Option<&Vec<String>> {
self.hierarchical_map.get(namespace)?.get(box_name)
}
/// 📋 全名前空間取得（IDE補完用）
pub fn get_all_namespaces(&self) -> Vec<&String> {
self.hierarchical_map.keys().collect()
}
}
```
### 3. 標準関数実装（高性能版）
#### **文字列関数実装**
```rust
impl BuiltinStdlib {
fn register_all_functions(&mut self) {
// === nyashstd.string.* ===
self.register_function("string.upper", BuiltinFunction {
namespace: "nyashstd",
box_name: "string",
method_name: "upper",
implementation: |args| {
if args.len() != 1 {
return Err(RuntimeError::InvalidArguments(
"string.upper(str) takes exactly 1 argument".to_string()
));
}
// 🚀 既存StringBox実装活用
let input_str = args[0].to_string_box().value;
let result = StringBox::new(&input_str.to_uppercase());
Ok(Box::new(result))
},
arg_count: Some(1),
description: "Convert string to uppercase",
});
self.register_function("string.lower", BuiltinFunction {
namespace: "nyashstd",
box_name: "string",
method_name: "lower",
implementation: |args| {
if args.len() != 1 {
return Err(RuntimeError::InvalidArguments(
"string.lower(str) takes exactly 1 argument".to_string()
));
}
let input_str = args[0].to_string_box().value;
let result = StringBox::new(&input_str.to_lowercase());
Ok(Box::new(result))
},
arg_count: Some(1),
description: "Convert string to lowercase",
});
self.register_function("string.split", BuiltinFunction {
namespace: "nyashstd",
box_name: "string",
method_name: "split",
implementation: |args| {
if args.len() != 2 {
return Err(RuntimeError::InvalidArguments(
"string.split(str, separator) takes exactly 2 arguments".to_string()
));
}
// 🚀 既存StringBox.split()メソッド活用
let string_box = StringBox::new(&args[0].to_string_box().value);
let separator = &args[1].to_string_box().value;
string_box.split(separator)
},
arg_count: Some(2),
description: "Split string by separator into array",
});
// === nyashstd.math.* ===
self.register_function("math.sin", BuiltinFunction {
namespace: "nyashstd",
box_name: "math",
method_name: "sin",
implementation: |args| {
if args.len() != 1 {
return Err(RuntimeError::InvalidArguments(
"math.sin(x) takes exactly 1 argument".to_string()
));
}
// 🚀 既存MathBox実装活用
let math_box = MathBox::new();
let x = args[0].to_integer_box().value as f64;
let result = math_box.sin(x)?;
Ok(result)
},
arg_count: Some(1),
description: "Calculate sine of x (in radians)",
});
// 階層マップも同時構築
self.build_hierarchical_map();
}
fn register_function(&mut self, qualified_name: &str, function: BuiltinFunction) {
self.flat_functions.insert(qualified_name.to_string(), function);
}
fn build_hierarchical_map(&mut self) {
for (qualified_name, function) in &self.flat_functions {
let namespace_map = self.hierarchical_map
.entry(function.namespace.to_string())
.or_insert_with(HashMap::new);
let method_list = namespace_map
.entry(function.box_name.to_string())
.or_insert_with(Vec::new);
method_list.push(function.method_name.to_string());
}
// ソートして一貫性確保
for namespace_map in self.hierarchical_map.values_mut() {
for method_list in namespace_map.values_mut() {
method_list.sort();
}
}
}
}
```
### 4. インタープリター統合
#### **NyashInterpreter拡張**
```rust
impl NyashInterpreter {
/// using文実行
pub fn execute_using(&mut self, namespace_name: &str) -> Result<(), RuntimeError> {
// 組み込み名前空間存在チェック
if !self.shared.builtin_stdlib.hierarchical_map.contains_key(namespace_name) {
return Err(RuntimeError::UndefinedNamespace(namespace_name.to_string()));
}
// 現在ファイルのusingコンテキスト更新
let file_id = self.get_current_file_id();
let mut using_imports = self.shared.using_imports.write().unwrap();
let context = using_imports.entry(file_id.clone()).or_insert(UsingContext {
imported_namespaces: Vec::new(),
file_id: file_id.clone(),
});
if !context.imported_namespaces.contains(&namespace_name.to_string()) {
context.imported_namespaces.push(namespace_name.to_string());
}
Ok(())
}
/// ⚡ 高速名前解決：string.upper() → nyashstd.string.upper()
pub fn resolve_qualified_call(&self, path: &[String]) -> Option<String> {
if path.len() != 2 {
return None; // Phase 0では2段階のみ対応
}
let box_name = &path[0];
let method_name = &path[1];
let file_id = self.get_current_file_id();
// 現在ファイルのusingインポート確認
if let Ok(using_imports) = self.shared.using_imports.read() {
if let Some(context) = using_imports.get(&file_id) {
for namespace in &context.imported_namespaces {
let qualified_name = format!("{}.{}", box_name, method_name);
// 実際に関数が存在するかチェック
if self.shared.builtin_stdlib.get_function(&qualified_name).is_some() {
return Some(qualified_name);
}
}
}
}
None
}
/// 🚀 組み込み関数実行
pub fn call_builtin_function(&self, qualified_name: &str, args: Vec<Box<dyn NyashBox>>)
-> Result<Box<dyn NyashBox>, RuntimeError> {
if let Some(function) = self.shared.builtin_stdlib.get_function(qualified_name) {
// 引数数チェック
if let Some(expected_count) = function.arg_count {
if args.len() != expected_count {
return Err(RuntimeError::InvalidArguments(
format!("{}.{}() takes exactly {} arguments, got {}",
function.box_name, function.method_name,
expected_count, args.len())
));
}
}
// 関数実行
(function.implementation)(&args)
} else {
Err(RuntimeError::UndefinedMethod(qualified_name.to_string()))
}
}
}
```
### 5. 式実行統合
#### **src/interpreter/expressions.rs修正**
```rust
impl NyashInterpreter {
pub fn execute_expression(&mut self, node: &ASTNode) -> Result<Box<dyn NyashBox>, RuntimeError> {
match node {
// 既存のケース...
// メソッド呼び出し処理修正
ASTNode::MethodCall { object, method, args, .. } => {
// オブジェクトが単純な識別子かチェック
if let ASTNode::Variable { name: box_name, .. } = object.as_ref() {
// using経由での短縮呼び出しチェック
let path = vec![box_name.clone(), method.clone()];
if let Some(qualified_name) = self.resolve_qualified_call(&path) {
// 引数評価
let evaluated_args = self.evaluate_arguments(args)?;
// 組み込み関数実行
return self.call_builtin_function(&qualified_name, evaluated_args);
}
}
// 既存のメソッド呼び出し処理
// ...
}
// using文実行
ASTNode::UsingStatement { namespace_name, .. } => {
self.execute_using(namespace_name)?;
Ok(Box::new(VoidBox::new()))
}
// 他の既存ケース...
}
}
}
```
## 📊 パフォーマンス特性
### ⚡ 最適化ポイント
#### **1. Zero-Allocation関数解決**
```rust
// ❌ 遅い：毎回文字列生成
let qualified = format!("{}.{}", box_name, method_name);
// ✅ 高速：事前計算済みマップ
if let Some(func) = stdlib.flat_functions.get(&qualified_name) { ... }
```
#### **2. 高速名前解決**
```rust
// O(1)アクセス：HashMap直接ルックアップ
// "string.upper" -> BuiltinFunction
```
#### **3. 既存Box実装活用**
```rust
// 既存の最適化済みStringBox.split()を直接使用
string_box.split(separator) // 新規実装不要
```
## 🧪 テストカバレッジ
### Phase 0必須テスト
#### **基本機能テスト**
```nyash
# test_builtin_stdlib_basic.nyash
using nyashstd
# 文字列操作
assert(string.upper("hello") == "HELLO")
assert(string.lower("WORLD") == "world")
assert(string.split("a,b,c", ",").length() == 3)
# 数学関数
assert(math.sin(0) == 0)
assert(math.cos(0) == 1)
# 配列操作
local arr = [1, 2, 3]
assert(array.length(arr) == 3)
assert(array.get(arr, 1) == 2)
```
#### **エラーハンドリング**
```nyash
# test_builtin_stdlib_errors.nyash
using nyashstd
# 引数数エラー
try {
string.upper("hello", "extra") # 2引数でエラー
assert(false, "Should have thrown error")
} catch e {
assert(e.contains("takes exactly 1 argument"))
}
# 未定義名前空間
try {
using nonexistent
assert(false, "Should have thrown error")
} catch e {
assert(e.contains("UndefinedNamespace"))
}
```
#### **IDE補完サポート**
```rust
// テスト：補完候補取得
let methods = stdlib.get_available_methods("nyashstd", "string");
assert!(methods.unwrap().contains(&"upper".to_string()));
assert!(methods.unwrap().contains(&"lower".to_string()));
```
## 🎯 実装順序
### 🚨 Critical（即時実装）
1. **BuiltinStdlib基盤** - src/stdlib/builtin.rs作成
2. **SharedState統合** - builtin_stdlibフィールド追加
3. **using文パーサー** - ASTNode::UsingStatement
### ⚡ High（今週中）
4. **string関数4種** - upper, lower, split, join
5. **基本テスト** - using nyashstd動作確認
6. **エラーハンドリング** - 適切なエラーメッセージ
### 📝 Medium（来週）
7. **math関数5種** - sin, cos, sqrt, floor, random
8. **array関数4種** - length, get, push, slice
9. **io関数3種** - print, println, debug
---
**⚡ この高性能アーキテクチャで、複雑なファイル依存関係なしに即座に実用的なnamespace/usingが実現できるにゃ！🚀**

394
docs/development/proposals/nyash.link/examples.md Normal file
View File

@ -0,0 +1,394 @@
# nyash.linkシステム使用例
## 🎯 基本的な使用例
### 📁 プロジェクト構造例
```
my-awesome-app/
├── nyash.link # 依存関係定義
├── src/
│ ├── main.nyash # メインファイル
│ ├── models/
│ │ └── user.nyash # ユーザーモデル
│ └── utils/
│ └── helpers.nyash # ヘルパー関数
├── libs/
│ └── custom_lib.nyash # カスタムライブラリ
└── stdlib/
└── nyashstd.nyash # 標準ライブラリ
```
### 📋 nyash.linkファイル例
```toml
[project]
name = "my-awesome-app"
version = "1.0.0"
description = "Everything is Box philosophy in action!"
[dependencies]
# 標準ライブラリ
nyashstd = { path = "./stdlib/nyashstd.nyash" }
# プロジェクト内モジュール
user_model = { path = "./src/models/user.nyash" }
helpers = { path = "./src/utils/helpers.nyash" }
# カスタムライブラリ
custom_lib = { path = "./libs/custom_lib.nyash" }
[search_paths]
stdlib = "./stdlib/"
src = "./src/"
libs = "./libs/"
[build]
entry_point = "./src/main.nyash"
```
## 🌟 実用的なコード例
### 1. 基本的なusing使用
```nyash
# ===== src/main.nyash =====
using nyashstd
using helpers
static box Main {
init { console }
main() {
me.console = new ConsoleBox()
# 標準ライブラリ使用
local text = "hello world"
local upper_text = string.upper(text) # nyashstd.string.upper
me.console.log("Upper: " + upper_text)
# ヘルパー関数使用
local processed = helpers.process_data("sample data")
me.console.log("Processed: " + processed)
# 数学関数
local result = math.sin(3.14159)
me.console.log("Sin: " + result.toString())
}
}
```
### 2. 標準ライブラリ定義例
```nyash
# ===== stdlib/nyashstd.nyash =====
namespace nyashstd {
static box string {
static upper(str) {
local string_box = new StringBox(str)
return string_box.upper()
}
static lower(str) {
local string_box = new StringBox(str)
return string_box.lower()
}
static split(str, separator) {
local string_box = new StringBox(str)
return string_box.split(separator)
}
static join(array, separator) {
local sep_box = new StringBox(separator)
return sep_box.join(array)
}
}
static box math {
static sin(x) {
local math_box = new MathBox()
return math_box.sin(x)
}
static cos(x) {
local math_box = new MathBox()
return math_box.cos(x)
}
static random() {
local random_box = new RandomBox()
return random_box.nextFloat()
}
static floor(x) {
local math_box = new MathBox()
return math_box.floor(x)
}
}
static box io {
static read_file(path) {
local file_box = new FileBox()
return file_box.read(path)
}
static write_file(path, content) {
local file_box = new FileBox()
return file_box.write(path, content)
}
}
}
```
### 3. ヘルパーモジュール例
```nyash
# ===== src/utils/helpers.nyash =====
using nyashstd
static function process_data(data) {
# データ処理のヘルパー
local trimmed = string.trim(data)
local upper = string.upper(trimmed)
return "PROCESSED: " + upper
}
static function calculate_score(points, multiplier) {
local result = points * multiplier
return math.floor(result)
}
static function format_user_name(first, last) {
return string.upper(first) + " " + string.upper(last)
}
```
### 4. モデル定義例
```nyash
# ===== src/models/user.nyash =====
using nyashstd
using helpers
box User {
init { name, email, score }
birth(user_name, user_email) {
me.name = user_name
me.email = user_email
me.score = 0
}
add_points(points) {
me.score = me.score + points
return me.score
}
get_formatted_name() {
local parts = string.split(me.name, " ")
if parts.length() >= 2 {
return helpers.format_user_name(parts.get(0), parts.get(1))
} else {
return string.upper(me.name)
}
}
save_to_file() {
local data = "User: " + me.name + ", Email: " + me.email + ", Score: " + me.score.toString()
local filename = "user_" + string.lower(me.name) + ".txt"
io.write_file(filename, data)
}
}
```
## 🎮 実用アプリケーション例
### 1. シンプルなWebサーバー
```nyash
# ===== web_server.nyash =====
using nyashstd
using custom_lib
static box WebServer {
init { server, port }
birth(server_port) {
me.port = server_port
me.server = new HttpServerBox()
}
start() {
me.server.bind("localhost", me.port)
me.server.on("request", me.handle_request)
local console = new ConsoleBox()
console.log("Server started on port " + me.port.toString())
me.server.listen()
}
handle_request(request, response) {
local url = request.getUrl()
if url == "/" {
local html = io.read_file("./public/index.html")
response.setStatus(200)
response.setHeader("Content-Type", "text/html")
response.send(html)
} else {
response.setStatus(404)
response.send("Not Found")
}
}
}
# メイン実行
local server = new WebServer(3000)
server.start()
```
### 2. データ処理パイプライン
```nyash
# ===== data_processor.nyash =====
using nyashstd
using helpers
static box DataProcessor {
init { input_file, output_file }
birth(input_path, output_path) {
me.input_file = input_path
me.output_file = output_path
}
process() {
# データ読み込み
local raw_data = io.read_file(me.input_file)
local lines = string.split(raw_data, "\n")
# 処理済みデータ配列
local processed_lines = new ArrayBox()
# 各行を処理
local i = 0
loop(i < lines.length()) {
local line = lines.get(i)
local processed = helpers.process_data(line)
processed_lines.push(processed)
i = i + 1
}
# 結果をファイルに保存
local result = string.join(processed_lines, "\n")
io.write_file(me.output_file, result)
return processed_lines.length()
}
}
# メイン処理
local processor = new DataProcessor("input.txt", "output.txt")
local count = processor.process()
local console = new ConsoleBox()
console.log("Processed " + count.toString() + " lines")
```
## 🔧 高度な使用パターン
### 1. 条件付きモジュール読み込み（将来拡張）
```nyash
# 開発環境では詳細ログ、本番環境ではシンプルログ
using nyashstd
static function get_logger() {
local env = os.get_env("NYASH_ENV")
if env == "development" {
using dev_logger
return new dev_logger.DetailLogger()
} else {
using prod_logger
return new prod_logger.SimpleLogger()
}
}
```
### 2. エイリアス使用例（将来拡張）
```nyash
# 長い名前空間のエイリアス
using very.long.namespace.name as short
local result = short.helper_function("data")
# 複数の類似ライブラリ
using json_v1 as json1
using json_v2 as json2
local data1 = json1.parse(input)
local data2 = json2.parse(input)
```
### 3. 部分インポート（将来拡張）
```nyash
# 名前空間全体ではなく特定機能のみ
using nyashstd.string
using nyashstd.math
# これで直接呼び出せる
local result = upper("hello") # string.upper不要
local sin_val = sin(3.14) # math.sin不要
```
## 📊 移行例：既存includeからusingへ
### Before（現在のinclude使用）
```nyash
# ===== 既存のtext_adventure例 =====
include "text_adventure/items.nyash"
include "text_adventure/rooms.nyash"
# アイテム作成
local sword = new Weapon("Sword", 10)
```
### After（新しいusing使用）
```nyash
# ===== nyash.link =====
[dependencies]
game_items = { path = "./text_adventure/items.nyash" }
game_rooms = { path = "./text_adventure/rooms.nyash" }
# ===== main.nyash =====
using game_items
using game_rooms
# アイテム作成（名前空間経由）
local sword = game_items.create_weapon("Sword", 10)
```
## 🎉 期待される開発体験
### IDE補完の改善
```nyash
using nyashstd
# "st" と入力すると...
st → string (補完候補)
# "string." と入力すると...
string. → upper, lower, split, join, trim, ... (全メソッド表示)
```
### エラーメッセージの改善
```nyash
using nyashstd
# 間違った呼び出し
local result = string.uppper("hello") # typo
# エラー:
# Error: Method 'uppper' not found in nyashstd.string
# Did you mean: 'upper'?
# Available methods: upper, lower, split, join, trim
```
---
**🌟 これらの例でnyash.linkシステムの実用性と美しさが伝わるにゃ！🐱**

406
docs/development/proposals/nyash.link/final-implementation-strategy.md Normal file
View File

@ -0,0 +1,406 @@
# 最終実装戦略：標準関数優先namespace/usingシステム
## 🎯 実装戦略まとめ
### 📋 設計完了項目
- ✅ **基本戦略**: nyash.link前の段階的実装
- ✅ **アーキテクチャ**: SharedState統合による高性能設計
- ✅ **標準関数**: 組み込みnyashstd名前空間
- ✅ **実装順序**: Critical → High → Medium
### 🚀 最終実装ロードマップ
## Phase 0: 組み込みnyashstd基盤（1-2週間）
### 🚨 Critical実装（即時）
#### **1. トークナイザー拡張**
```rust
// src/tokenizer.rs
pub enum TokenType {
// 既存...
USING, // using キーワード追加
}
// キーワード認識
fn tokenize_keyword(word: &str) -> TokenType {
match word {
// 既存...
"using" => TokenType::USING,
_ => TokenType::IDENTIFIER(word.to_string()),
}
}
```
#### **2. AST最小拡張**
```rust
// src/ast.rs
pub enum ASTNode {
// 既存...
UsingStatement {
namespace_name: String, // Phase 0: "nyashstd"のみ
span: Span,
},
}
```
#### **3. BuiltinStdlib基盤**
```rust
// 新ファイル: src/stdlib/mod.rs
pub mod builtin;
pub use builtin::*;
// 新ファイル: src/stdlib/builtin.rs
// （前回設計したBuiltinStdlib実装）
```
#### **4. SharedState統合**
```rust
// src/interpreter/core.rs
#[derive(Clone)]
pub struct SharedState {
// 既存フィールド...
pub builtin_stdlib: Arc<BuiltinStdlib>,
pub using_imports: Arc<RwLock<HashMap<String, UsingContext>>>,
}
impl SharedState {
pub fn new() -> Self {
SharedState {
// 既存初期化...
builtin_stdlib: Arc::new(BuiltinStdlib::new()),
using_imports: Arc::new(RwLock::new(HashMap::new())),
}
}
}
```
### ⚡ High実装（今週中）
#### **5. using文パーサー**
```rust
// src/parser/statements.rs
impl NyashParser {
pub fn parse_statement(&mut self) -> Result<ASTNode, ParseError> {
match &self.current_token().token_type {
// 既存ケース...
TokenType::USING => self.parse_using(),
// 他の既存ケース...
}
}
fn parse_using(&mut self) -> Result<ASTNode, ParseError> {
let start_span = self.current_token().span.clone();
self.advance(); // consume 'using'
if let TokenType::IDENTIFIER(namespace_name) = &self.current_token().token_type {
let name = namespace_name.clone();
self.advance();
// Phase 0制限：nyashstdのみ許可
if name != "nyashstd" {
return Err(ParseError::UnsupportedFeature(
format!("Only 'nyashstd' namespace is supported in Phase 0, got '{}'", name)
));
}
Ok(ASTNode::UsingStatement {
namespace_name: name,
span: start_span,
})
} else {
Err(ParseError::ExpectedIdentifier(
"Expected namespace name after 'using'".to_string()
))
}
}
}
```
#### **6. 基本string関数実装**
```rust
// src/stdlib/builtin.rs拡張
impl BuiltinStdlib {
fn register_string_functions(&mut self) {
// string.upper
self.register_function("string.upper", BuiltinFunction {
namespace: "nyashstd",
box_name: "string",
method_name: "upper",
implementation: |args| {
if args.len() != 1 {
return Err(RuntimeError::InvalidArguments(
"string.upper() takes exactly 1 argument".to_string()
));
}
let input = &args[0].to_string_box().value;
let result = StringBox::new(&input.to_uppercase());
Ok(Box::new(result))
},
arg_count: Some(1),
description: "Convert string to uppercase",
});
// string.lower
self.register_function("string.lower", BuiltinFunction {
namespace: "nyashstd",
box_name: "string",
method_name: "lower",
implementation: |args| {
if args.len() != 1 {
return Err(RuntimeError::InvalidArguments(
"string.lower() takes exactly 1 argument".to_string()
));
}
let input = &args[0].to_string_box().value;
let result = StringBox::new(&input.to_lowercase());
Ok(Box::new(result))
},
arg_count: Some(1),
description: "Convert string to lowercase",
});
// string.split
self.register_function("string.split", BuiltinFunction {
namespace: "nyashstd",
box_name: "string",
method_name: "split",
implementation: |args| {
if args.len() != 2 {
return Err(RuntimeError::InvalidArguments(
"string.split() takes exactly 2 arguments".to_string()
));
}
let string_box = StringBox::new(&args[0].to_string_box().value);
let separator = &args[1].to_string_box().value;
string_box.split(separator)
},
arg_count: Some(2),
description: "Split string by separator",
});
// string.join
self.register_function("string.join", BuiltinFunction {
namespace: "nyashstd",
box_name: "string",
method_name: "join",
implementation: |args| {
if args.len() != 2 {
return Err(RuntimeError::InvalidArguments(
"string.join() takes exactly 2 arguments".to_string()
));
}
let array_arg = &args[0];
let separator = &args[1].to_string_box().value;
let separator_box = StringBox::new(separator);
separator_box.join(array_arg.clone())
},
arg_count: Some(2),
description: "Join array elements with separator",
});
}
}
```
#### **7. インタープリター統合**
```rust
// src/interpreter/expressions.rs
impl NyashInterpreter {
pub fn execute_expression(&mut self, node: &ASTNode) -> Result<Box<dyn NyashBox>, RuntimeError> {
match node {
// using文処理
ASTNode::UsingStatement { namespace_name, .. } => {
self.execute_using(namespace_name)?;
Ok(Box::new(VoidBox::new()))
}
// メソッド呼び出し処理拡張
ASTNode::MethodCall { object, method, args, .. } => {
// 組み込み関数チェック
if let ASTNode::Variable { name: box_name, .. } = object.as_ref() {
let path = vec![box_name.clone(), method.clone()];
if let Some(qualified_name) = self.resolve_qualified_call(&path) {
let evaluated_args = self.evaluate_arguments(args)?;
return self.call_builtin_function(&qualified_name, evaluated_args);
}
}
// 既存のメソッド呼び出し処理
// ...
}
// 既存の他のケース...
}
}
}
```
### 📝 Medium実装（来週）
#### **8. math関数実装**
```rust
// math.sin, cos, sqrt, floor, random
```
#### **9. array関数実装**
```rust
// array.length, get, push, slice
```
#### **10. io関数実装**
```rust
// io.print, println, debug
```
## Phase 1: 拡張機能（2-3週間後）
### 🌟 完全修飾名対応
```nyash
# using不要でも使える
nyashstd.string.upper("hello")
nyashstd.math.sin(3.14)
```
#### **実装**
```rust
// ASTNode::QualifiedCall追加
ASTNode::QualifiedCall {
path: Vec<String>, // ["nyashstd", "string", "upper"]
args: Vec<ASTNode>,
span: Span,
}
// パーサーで "identifier.identifier.identifier()" 構文解析
```
### 🔧 エラーハンドリング強化
```rust
// より詳細なエラーメッセージ
RuntimeError::UndefinedBuiltinMethod {
namespace: String,
box_name: String,
method_name: String,
available_methods: Vec<String>, // "Did you mean: ..."
span: Span,
}
```
### 📊 IDE補完サポート
```rust
// Language Server連携用API
impl BuiltinStdlib {
pub fn get_completion_candidates(&self, prefix: &str) -> Vec<CompletionItem> {
// "ny" -> ["nyashstd"]
// "nyashstd." -> ["string", "math", "array", "io"]
// "nyashstd.string." -> ["upper", "lower", "split", "join"]
}
}
```
## Phase 2: nyash.link準備（1ヶ月後）
### 🔗 外部モジュール対応基盤
```rust
// ModuleResolver拡張
pub enum NamespaceSource {
Builtin(Arc<BuiltinStdlib>), // 組み込み
External(PathBuf), // nyash.linkで管理
}
// NamespaceRegistry統合
pub struct NamespaceRegistry {
builtin: Arc<BuiltinStdlib>,
external: HashMap<String, ExternalModule>,
}
```
### 📁 nyash.link対応
```toml
[dependencies]
mylib = { path = "./mylib.nyash" }
# using mylib # Phase 2で対応
```
## 🧪 段階的テスト戦略
### Phase 0テスト
```nyash
# test_phase0_basic.nyash
using nyashstd
# 基本動作
assert(string.upper("hello") == "HELLO")
assert(string.lower("WORLD") == "world")
# エラー処理
try {
using unknown_namespace
} catch e {
assert(e.contains("nyashstd"))
}
```
### Phase 1テスト
```nyash
# test_phase1_qualified.nyash
# using不要のテスト
assert(nyashstd.string.upper("hello") == "HELLO")
assert(nyashstd.math.sin(0) == 0)
```
### Phase 2テスト
```nyash
# test_phase2_external.nyash
using mylib
assert(mylib.custom.process("data") == "processed: data")
```
## 📊 実装マイルストーン
### ✅ Phase 0完了条件
- [ ] USINGトークン認識
- [ ] using nyashstd構文解析
- [ ] 組み込みstring関数4種動作
- [ ] 基本テスト全通過
- [ ] エラーハンドリング適切
### ✅ Phase 1完了条件
- [ ] 完全修飾名 nyashstd.string.upper() 動作
- [ ] math/array/io関数実装
- [ ] IDE補完候補API実装
- [ ] 詳細エラーメッセージ
### ✅ Phase 2完了条件
- [ ] 外部モジュール基盤実装
- [ ] nyash.link基本対応
- [ ] 依存関係解決機能
- [ ] 全機能統合テスト
## 🔥 即座に開始すべき実装
### 今日やること
1. **src/stdlib/mod.rs作成** - モジュール基盤
2. **TokenType::USING追加** - トークナイザー拡張
3. **BuiltinStdlib::new()実装** - 空の基盤作成
### 今週やること
4. **using文パーサー実装** - 基本構文解析
5. **string.upper()実装** - 最初の関数
6. **基本テスト作成** - 動作確認
### 来週やること
7. **string関数完成** - lower, split, join
8. **math関数開始** - sin, cos, sqrt
9. **IDE補完設計** - Language Server準備
---
**🎯 この段階的戦略で、複雑なnyash.linkなしに即座に実用的なnamespace/usingシステムが実現できるにゃ！**
**🚀 Phase 0実装を今すぐ開始して、Nyashをモダンなプログラミング言語に進化させよう！🐱✨**

471
docs/development/proposals/nyash.link/implementation-plan.md Normal file
View File

@ -0,0 +1,471 @@
# nyash.linkシステム実装計画
## 🎯 実装戦略
### 📊 現状確認
- ✅ **include**: 限定的使用（text_adventure例のみ）→廃止OK
- ✅ **using**: 未実装→完全新規作成
- ✅ **namespace**: 設計完了→実装のみ
- ✅ **Gemini推奨**: 技術的妥当性確認済み
## 📋 段階的実装ロードマップ
### 🚀 **Phase 1: 基盤構築（1-2週間）**
#### 1.1 トークナイザー拡張
```rust
// src/tokenizer.rs
pub enum TokenType {
// 既存...
USING, // using キーワード
NAMESPACE, // namespace キーワード
AS, // as キーワード（将来のエイリアス用）
}
// キーワード認識追加
fn tokenize_identifier(input: &str) -> TokenType {
match input {
// 既存...
"using" => TokenType::USING,
"namespace" => TokenType::NAMESPACE,
"as" => TokenType::AS,
_ => TokenType::IDENTIFIER(input.to_string()),
}
}
```
#### 1.2 AST拡張
```rust
// src/ast.rs
pub enum ASTNode {
// 既存...
UsingStatement {
module_path: Vec<String>, // ["nyashstd"] or ["mylib"]
alias: Option<String>, // using mylib as lib
span: Span,
},
NamespaceDeclaration {
name: String,
body: Vec<ASTNode>,
span: Span,
},
QualifiedCall {
path: Vec<String>, // ["nyashstd", "string", "upper"]
args: Vec<ASTNode>,
span: Span,
},
}
```
#### 1.3 パーサー基本実装
```rust
// src/parser/statements.rs
impl NyashParser {
pub fn parse_using(&mut self) -> Result<ASTNode, ParseError> {
self.advance(); // consume 'using'
let module_path = self.parse_module_path()?;
// using mylib → ["mylib"]
// using nyashstd.string → ["nyashstd", "string"]
Ok(ASTNode::UsingStatement {
module_path,
alias: None, // Phase 1では未サポート
span: self.current_span(),
})
}
fn parse_module_path(&mut self) -> Result<Vec<String>, ParseError> {
let mut path = vec![];
// 最初の識別子
if let TokenType::IDENTIFIER(name) = &self.current_token().token_type {
path.push(name.clone());
self.advance();
} else {
return Err(ParseError::ExpectedIdentifier);
}
// ドット区切りで追加パス（将来拡張）
// using nyashstd.string のような構文
Ok(path)
}
}
```
### ⚡ **Phase 2: nyash.link基盤（2-3週間）**
#### 2.1 nyash.linkパーサー
```rust
// 新ファイル: src/link_file.rs
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Deserialize, Serialize)]
pub struct NyashLink {
pub project: Option<ProjectInfo>,
pub dependencies: HashMap<String, Dependency>,
pub search_paths: Option<HashMap<String, String>>,
pub build: Option<BuildConfig>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct ProjectInfo {
pub name: String,
pub version: String,
pub description: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(untagged)]
pub enum Dependency {
Path { path: String },
Stdlib { stdlib: bool },
Registry { version: String, registry: String },
}
#[derive(Debug, Deserialize, Serialize)]
pub struct BuildConfig {
pub entry_point: Option<String>,
}
impl NyashLink {
pub fn from_file(path: &Path) -> Result<Self, LinkError> {
let content = std::fs::read_to_string(path)?;
let link: NyashLink = toml::from_str(&content)?;
Ok(link)
}
pub fn resolve_dependency(&self, name: &str) -> Option<PathBuf> {
if let Some(dep) = self.dependencies.get(name) {
match dep {
Dependency::Path { path } => Some(PathBuf::from(path)),
Dependency::Stdlib { .. } => {
// 標準ライブラリパス解決ロジック
self.resolve_stdlib_path(name)
}
_ => None, // Phase 2では未サポート
}
} else {
None
}
}
}
```
#### 2.2 依存関係解決エンジン
```rust
// 新ファイル: src/module_resolver.rs
pub struct ModuleResolver {
nyash_link: NyashLink,
loaded_modules: HashMap<String, Arc<ParsedModule>>,
loading_stack: Vec<String>, // 循環依存検出用
}
impl ModuleResolver {
pub fn new(link_path: &Path) -> Result<Self, ResolverError> {
let nyash_link = NyashLink::from_file(link_path)?;
Ok(ModuleResolver {
nyash_link,
loaded_modules: HashMap::new(),
loading_stack: Vec::new(),
})
}
pub fn resolve_using(&mut self, module_name: &str) -> Result<Arc<ParsedModule>, ResolverError> {
// 既にロード済みかチェック
if let Some(module) = self.loaded_modules.get(module_name) {
return Ok(module.clone());
}
// 循環依存チェック
if self.loading_stack.contains(&module_name.to_string()) {
return Err(ResolverError::CircularDependency(
self.loading_stack.clone()
));
}
// ファイルパス解決
let file_path = self.nyash_link.resolve_dependency(module_name)
.ok_or(ResolverError::ModuleNotFound(module_name.to_string()))?;
// 再帰的読み込み防止
self.loading_stack.push(module_name.to_string());
// ファイル読み込み・パース
let content = std::fs::read_to_string(&file_path)?;
let ast = NyashParser::parse_from_string(&content)?;
// モジュール作成
let module = Arc::new(ParsedModule {
name: module_name.to_string(),
file_path,
ast,
exports: self.extract_exports(&ast)?,
});
// キャッシュに保存
self.loaded_modules.insert(module_name.to_string(), module.clone());
self.loading_stack.pop();
Ok(module)
}
}
```
### 📈 **Phase 3: 名前空間システム（3-4週間）**
#### 3.1 namespace解析
```rust
impl NyashParser {
pub fn parse_namespace(&mut self) -> Result<ASTNode, ParseError> {
self.advance(); // consume 'namespace'
let name = self.expect_identifier()?;
self.expect_token(TokenType::LBRACE)?;
let mut body = vec![];
while !self.check_token(&TokenType::RBRACE) {
body.push(self.parse_statement()?);
}
self.expect_token(TokenType::RBRACE)?;
Ok(ASTNode::NamespaceDeclaration {
name,
body,
span: self.current_span(),
})
}
}
```
#### 3.2 名前空間レジストリ
```rust
// 新ファイル: src/namespace_registry.rs
pub struct NamespaceRegistry {
namespaces: HashMap<String, Namespace>,
using_imports: HashMap<String, Vec<String>>, // ファイル別インポート
}
pub struct Namespace {
pub name: String,
pub static_boxes: HashMap<String, StaticBox>,
}
pub struct StaticBox {
pub name: String,
pub static_methods: HashMap<String, MethodSignature>,
}
impl NamespaceRegistry {
pub fn register_namespace(&mut self, name: String, namespace: Namespace) {
self.namespaces.insert(name, namespace);
}
pub fn add_using_import(&mut self, file_id: String, namespace_name: String) {
self.using_imports
.entry(file_id)
.or_insert_with(Vec::new)
.push(namespace_name);
}
pub fn resolve_call(&self, file_id: &str, path: &[String]) -> Option<MethodSignature> {
// 例: string.upper() → nyashstd.string.upper()
if path.len() == 2 {
let box_name = &path[0];
let method_name = &path[1];
// usingでインポートされた名前空間を検索
if let Some(imports) = self.using_imports.get(file_id) {
for namespace_name in imports {
if let Some(namespace) = self.namespaces.get(namespace_name) {
if let Some(static_box) = namespace.static_boxes.get(box_name) {
if let Some(method) = static_box.static_methods.get(method_name) {
return Some(method.clone());
}
}
}
}
}
}
None
}
}
```
### 🎯 **Phase 4: インタープリター統合（4-5週間）**
#### 4.1 using文実行
```rust
// src/interpreter/core.rs
impl NyashInterpreter {
pub fn execute_using(&mut self, module_path: &[String]) -> Result<(), RuntimeError> {
let module_name = module_path.join(".");
// モジュール解決・読み込み
let module = self.module_resolver.resolve_using(&module_name)?;
// 名前空間登録
if let Some(namespace) = self.extract_namespace_from_module(&module) {
self.namespace_registry.register_namespace(module_name.clone(), namespace);
self.namespace_registry.add_using_import(
self.current_file_id.clone(),
module_name
);
}
Ok(())
}
fn extract_namespace_from_module(&self, module: &ParsedModule) -> Option<Namespace> {
// ASTからnamespace宣言を探して解析
for node in &module.ast {
if let ASTNode::NamespaceDeclaration { name, body, .. } = node {
return Some(self.build_namespace_from_body(name, body));
}
}
None
}
}
```
#### 4.2 qualified call実行
```rust
impl NyashInterpreter {
pub fn execute_qualified_call(&mut self, path: &[String], args: &[ASTNode])
-> Result<Box<dyn NyashBox>, RuntimeError> {
// 名前解決
if let Some(method_sig) = self.namespace_registry.resolve_call(
&self.current_file_id,
path
) {
// 引数評価
let evaluated_args = self.evaluate_args(args)?;
// メソッド実行（既存のBox呼び出しシステム活用）
return self.call_static_method(&method_sig, evaluated_args);
}
// 完全修飾名として試行
if path.len() >= 3 {
// nyashstd.string.upper() の場合
let namespace_name = &path[0];
let box_name = &path[1];
let method_name = &path[2];
if let Some(namespace) = self.namespace_registry.namespaces.get(namespace_name) {
if let Some(static_box) = namespace.static_boxes.get(box_name) {
if let Some(method) = static_box.static_methods.get(method_name) {
let evaluated_args = self.evaluate_args(args)?;
return self.call_static_method(method, evaluated_args);
}
}
}
}
Err(RuntimeError::UndefinedMethod(path.join(".")))
}
}
```
## 🧪 テスト戦略
### Phase 1テスト
```nyash
# test_basic_using.nyash
# 基本using文テスト
# ファイル: mylib.nyash
static function hello() {
return "Hello from mylib!"
}
# ファイル: main.nyash
using mylib
local result = mylib.hello()
assert(result == "Hello from mylib!")
```
### Phase 2テスト
```nyash
# test_nyash_link.nyash
# nyash.linkファイル連携テスト
# nyash.link内容:
# [dependencies]
# mylib = { path = "./mylib.nyash" }
using mylib
local result = mylib.process("data")
assert(result == "processed: data")
```
### Phase 3テスト
```nyash
# test_namespace.nyash
# 名前空間システムテスト
# nyashstd.nyash:
# namespace nyashstd {
# static box string {
# static upper(str) { ... }
# }
# }
using nyashstd
local result = string.upper("hello")
assert(result == "HELLO")
# 完全修飾名
local result2 = nyashstd.string.upper("world")
assert(result2 == "WORLD")
```
## 📊 実装マイルストーン
### ✅ 完了条件
#### Phase 1
- [ ] USING/NAMESPACE トークン認識
- [ ] using文AST構築
- [ ] 基本パーサーテスト通過
#### Phase 2
- [ ] nyash.linkファイル読み込み
- [ ] 依存関係解決
- [ ] モジュールキャッシュ機能
#### Phase 3
- [ ] namespace宣言解析
- [ ] 名前空間レジストリ動作
- [ ] 静的メソッド解決
#### Phase 4
- [ ] インタープリター統合
- [ ] qualified call実行
- [ ] 全テストケース通過
## 🔮 将来拡張
### Phase 5: 高度機能
- エイリアス（`using mylib as lib`）
- 選択インポート（`using nyashstd.string`）
- 動的モジュール読み込み
### Phase 6: 標準ライブラリ
- nyashstd.nyash完全実装
- string/math/io/http モジュール
- ドキュメント生成
### Phase 7: エコシステム
- パッケージレジストリ設計
- CLI ツール（nyash init/install）
- IDE Language Server連携
---
**🎯 この実装計画でnyash.linkシステムを段階的に完成させるにゃ！**

372
docs/development/proposals/nyash.link/master-architecture.md Normal file
View File

@ -0,0 +1,372 @@
# なんでもAPI計画：最終統合アーキテクチャ
## 🌟 革命的ビジョンの実現
### 📊 統合設計完了状況
- ✅ **nyash.link基盤**: 依存関係管理システム設計完了
- ✅ **FFI-ABI統合**: BID×MIR×バックエンド統合設計完了
- ✅ **usingシステム**: 3種類API統一インポート設計完了
- ✅ **実世界例**: ゲーム・データサイエンス・Web・システムプログラミング実証
- 🎯 **最終統合**: 全システム統合による革命的開発体験実現
### 🚀 完成後の開発体験
```nyash
# === たった一つの構文ですべてが使える ===
using nyashstd # 組み込み標準ライブラリ
using browser_api # ブラウザAPI（Canvas, DOM, WebAudio...）
using system_api # システムAPI（libc, filesystem, network...）
using ml_api # 機械学習（TensorFlow, PyTorch, OpenCV...）
using game_api # ゲーム開発（SDL, OpenGL, Vulkan...）
using mylib # 自作Nyashモジュール
# 全部同じ記法・同じパフォーマンス・同じエラーハンドリング！
string.upper("hello") # 組み込み標準
browser.canvas.fillRect("game", 10, 10, 100, 100, "red") # ブラウザAPI
system.file.read("/etc/passwd") # システムAPI
ml.opencv.loadImage("photo.jpg") # 機械学習API
game.sdl.createWindow("Game", 800, 600) # ゲームAPI
mylib.processData("input") # 自作モジュール
```
## 🏗️ 最終統合アーキテクチャ
### 1. 全体システム構成
```
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Nyash Code │ │ nyash.link │ │ BID Files │
│ │ │ │ │ │
│ using browser_api│ │ [dependencies] │ │ browser_api: │
│ using system_api │───▶│ browser_api = │───▶│ canvas.yaml │
│ using mylib │ │ {bid=...} │ │ dom.yaml │
│ canvas.fillRect │ │ system_api = │ │ system_api: │
│ file.read │ │ {bid=...} │ │ libc.yaml │
│ mylib.process │ │ mylib = {path} │ │ filesystem.yaml│
└─────────────────┘ └─────────────────┘ └─────────────────┘
│ │ │
└────────────────────────┼────────────────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ UniversalNamespaceRegistry │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────┐ │
│ │BuiltinStdlib│ │BidDefinition│ │ExternalModules │ │
│ │ │ │ │ │ │ │
│ │nyashstd.* │ │browser_api.*│ │mylib.* │ │
│ │string.upper │ │canvas.fill* │ │custom functions │ │
│ │math.sin │ │dom.events │ │ │ │
│ │array.length │ │system.file* │ │ │ │
│ └─────────────┘ └─────────────┘ └─────────────────┘ │
└─────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ MIR Generation │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────┐ │
│ │BuiltinCall │ │ExternCall │ │ModuleCall │ │
│ │ │ │ │ │ │ │
│ │string.upper │ │canvas.fill* │ │mylib.process │ │
│ │effect:pure │ │effect:io │ │effect:io │ │
│ │optimize:yes │ │gpu_accel:yes│ │ │ │
│ └─────────────┘ └─────────────┘ └─────────────────┘ │
└─────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ Backend Execution │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────┐ │
│ │ VM │ │ WASM │ │ AOT │ │
│ │ │ │ │ │ │ │
│ │Native Impl │ │RuntimeImport│ │LLVM ExternFunc │ │
│ │Stub Calls │ │Auto-generated│ │Native Libraries │ │
│ │ │ │from BID │ │ │ │
│ └─────────────┘ └─────────────┘ └─────────────────┘ │
└─────────────────────────────────────────────────────────┘
```
### 2. nyash.link統合仕様（最終版）
```toml
# nyash.link - 全API統一管理設定
[project]
name = "ultimate-nyash-app"
version = "2.0.0"
description = "Everything is accessible through unified APIs"
license = "MIT"
[dependencies]
# === 組み込み標準ライブラリ ===
nyashstd = { builtin = true }
# === ブラウザ・Web API ===
browser_api = {
bid = ["./apis/canvas.yaml", "./apis/dom.yaml", "./apis/webaudio.yaml"],
target_environments = ["browser"]
}
webgl_api = {
bid = "./apis/webgl.yaml",
target_environments = ["browser"]
}
# === システム・OS API ===
system_api = {
bid = ["./apis/libc.yaml", "./apis/filesystem.yaml", "./apis/network.yaml"],
library = "system",
target_environments = ["linux", "macos", "windows"]
}
posix_api = {
bid = "./apis/posix.yaml",
library = "system",
target_environments = ["linux", "macos"]
}
# === 機械学習・データサイエンス ===
ml_api = {
bid = ["./apis/opencv.yaml", "./apis/numpy.yaml"],
library = ["./libs/opencv.so", "./libs/numpy.so"],
target_environments = ["linux", "macos"]
}
tensorflow_api = {
bid = "./apis/tensorflow.yaml",
library = "./libs/tensorflow.so",
optional = true # 環境によってオプション
}
# === ゲーム開発 ===
game_api = {
bid = ["./apis/sdl.yaml", "./apis/opengl.yaml"],
library = ["SDL2", "OpenGL"],
target_environments = ["linux", "macos", "windows"]
}
# === データベース ===
database_api = {
bid = ["./apis/sqlite.yaml", "./apis/postgresql.yaml"],
library = ["sqlite3", "pq"],
}
# === ネットワーク・Web ===
http_api = {
bid = "./apis/http_client.yaml",
library = "curl"
}
# === Nyashモジュール（従来通り） ===
mylib = { path = "./src/mylib.nyash" }
utils = { path = "./src/utils/" }
models = { path = "./src/models.nyash" }
# === 将来の外部パッケージ ===
awesome_lib = {
version = "^1.2.0",
registry = "nyash-pkg",
bid = "auto" # パッケージレジストリから自動取得
}
[build]
entry_point = "./src/main.nyash"
backends = ["vm", "wasm", "aot"]
optimization_level = "release"
[targets]
browser = ["browser_api", "webgl_api"]
desktop = ["system_api", "game_api", "ml_api"]
server = ["system_api", "database_api", "http_api"]
[optimization]
# MIRレベル最適化設定
enable_effect_optimization = true
enable_batch_optimization = true # FFI-ABI呼び出しバッチ化
enable_gpu_acceleration = true
cache_bid_compilation = true
```
### 3. BIDエコシステム（標準API集）
```
nyash-std-apis/ # 標準APIライブラリ
├── browser/
│ ├── canvas.yaml # Canvas API
│ ├── dom.yaml # DOM API
│ ├── webaudio.yaml # Web Audio API
│ ├── webgl.yaml # WebGL API
│ └── fetch.yaml # Fetch API
├── system/
│ ├── libc.yaml # C標準ライブラリ
│ ├── filesystem.yaml # ファイルシステム
│ ├── network.yaml # ネットワーク
│ ├── process.yaml # プロセス管理
│ └── threads.yaml # スレッド・並行処理
├── ml/
│ ├── opencv.yaml # コンピューターヴィジョン
│ ├── numpy.yaml # 数値計算
│ ├── tensorflow.yaml # 機械学習
│ └── pytorch.yaml # 深層学習
├── game/
│ ├── sdl.yaml # SDL2ライブラリ
│ ├── opengl.yaml # OpenGL API
│ ├── vulkan.yaml # Vulkan API
│ └── physics.yaml # 物理エンジン
├── database/
│ ├── sqlite.yaml # SQLite
│ ├── postgresql.yaml # PostgreSQL
│ ├── mysql.yaml # MySQL
│ └── redis.yaml # Redis
└── crypto/
├── openssl.yaml # OpenSSL
├── libsodium.yaml # libsodium
└── bcrypt.yaml # bcrypt
```
## 🚀 段階的実装戦略（現実的ロードマップ）
### Phase 0: 基盤構築（2-3週間）
```rust
// 🎯 最小実装目標
// using nyashstd → 動作
```
#### **実装内容**
1. **USINGトークナイザー** - `TokenType::USING`追加
2. **基本パーサー** - `using nyashstd`構文解析
3. **BuiltinStdlib基盤** - 組み込み標準ライブラリ
4. **基本string関数** - upper, lower, split, join
#### **テスト**
```nyash
using nyashstd
assert(string.upper("hello") == "HELLO")
```
### Phase 1: BID基盤（4-6週間）
```rust
// 🎯 外部API基盤目標
// using console_api → 動作（VM Stub）
```
#### **実装内容**
1. **BID読み込み** - YAML解析・検証システム
2. **UniversalNamespaceRegistry** - 統合名前空間管理
3. **MIR ExternCall統合** - BID→MIR変換
4. **VM Stub実装** - console.log等の基本スタブ
#### **テスト**
```nyash
using nyashstd
using console_api
string.upper("test")
console.log("BID integration works!")
```
### Phase 2: WASM統合（6-8週間）
```rust
// 🎯 WASM動作目標
// ブラウザでCanvas API動作
```
#### **実装内容**
1. **WASM RuntimeImports自動生成** - BID→WASM import
2. **文字列マーシャリング** - UTF-8 (ptr,len)対応
3. **Canvas API完全実装** - fillRect, fillText等
4. **ブラウザテスト環境** - HTML/JS統合
#### **テスト**
```nyash
using browser_api
canvas.fillRect("game-canvas", 10, 10, 100, 100, "red")
```
### Phase 3: システムAPI統合（8-12週間）
```rust
// 🎯 ネイティブライブラリ動作目標
// ファイルI/O, システムコール等
```
#### **実装内容**
1. **AOTバックエンド統合** - LLVM IR外部関数
2. **システムライブラリ連携** - libc, filesystem等
3. **エラーハンドリング統合** - 統一エラーモデル
4. **パフォーマンス最適化** - バッチ処理・GPU加速
#### **テスト**
```nyash
using system_api
local content = file.read("/etc/passwd")
file.write("./output.txt", content)
```
### Phase 4: 完全エコシステム（12-16週間）
```rust
// 🎯 実用的アプリケーション開発
// ゲーム・ML・Webアプリ等
```
#### **実装内容**
1. **標準APIライブラリ** - nyash-std-apis完成
2. **パッケージレジストリ** - BID共有システム
3. **IDE Language Server** - 統合補完・エラー検出
4. **最適化エンジン** - Effect System活用
#### **実用例**
```nyash
# 本格的なゲーム開発
using game_api
using audio_api
game.sdl.createWindow("My Game", 1024, 768)
audio.mixer.playMusic("bgm.ogg")
```
## 📊 既存実装との整合性
### Phase 9.75eとの関係
```
Phase 9.75e (既存計画) なんでもAPI計画 (新設計)
↓ ↓
namespace構文 using統一構文
依存関係システム → nyash.link統合管理
外部ファイル読み込み → BID統合システム
↓
完全統合アーキテクチャ
```
### 既存MIR/バックエンドとの統合
- ✅ **MIR ExternCall**: 既存実装活用
- ✅ **WASM RuntimeImports**: 既存基盤拡張
- ✅ **VM Backend**: 既存スタブシステム活用
- 🔧 **統合課題**: usingシステムとの橋渡し
## 🌟 長期ビジョン：Nyashの未来
### 2025年目標
- **Phase 0-1完了**: 基盤・BID統合
- **実用アプリ**: シンプルなブラウザゲーム・ツール
- **コミュニティ**: 開発者コミュニティ形成
### 2026年目標
- **Phase 2-3完了**: WASM・システムAPI統合
- **本格アプリ**: ゲーム・データサイエンス・Webアプリ
- **エコシステム**: BIDライブラリエコシステム
### 2027年目標
- **Phase 4完了**: 完全エコシステム
- **産業利用**: 企業での実用的活用
- **言語標準化**: BID標準の業界採用
## 🎯 即座に開始すべき実装
### 今日のアクション
1. **src/stdlib/mod.rs作成** - 組み込み標準ライブラリ基盤
2. **TokenType::USING追加** - トークナイザー拡張
3. **Phase 0実装開始** - using nyashstd基本動作
### 今週のアクション
4. **BuiltinStdlib::new()実装** - string関数4種
5. **基本テスト作成** - using動作確認
6. **Phase 1設計** - BID統合詳細設計
### 来週のアクション
7. **BID読み込み基盤** - YAML解析システム
8. **UniversalNamespaceRegistry** - 統合名前空間管理
9. **console.log実装** - 最初のBID統合テスト
---
**🎉 この最終統合アーキテクチャにより、Nyashが真に「なんでもできる」革命的プログラミング言語になるにゃ！**
**🚀 今すぐPhase 0実装を開始して、プログラミング言語の未来を創造しよう！🐱✨**

435
docs/development/proposals/nyash.link/minimal-stdlib-first.md Normal file
View File

@ -0,0 +1,435 @@
# 最小実装：標準関数優先namespace/usingシステム
## 🎯 基本戦略：nyash.link前の段階的実装
### 📊 現状分析
- **既存Box型**: 25種類以上の豊富なBox実装
- **include使用**: 限定的（text_adventure例のみ）
- **using実装**: 完全未実装→新規作成可能
- **最優先課題**: 複雑なファイル依存関係システムより、まず標準関数のIDE補完
### 🌟 段階的実装アプローチ
#### **Phase 0: 組み込みnyashstd（最小実装）**
```
ファイル読み込み一切なし → インタープリターに直接組み込み
```
#### **Phase 1: using構文**
```nyash
using nyashstd
string.upper("hello") # ✅ 動作
```
#### **Phase 2: 将来のnyash.link対応**
```
外部ファイル・依存関係システム（後日実装）
```
## 🏗️ 組み込みnyashstd設計
### 優先順位別Box分類
#### 🚨 **Tier 1: 最優先基本機能**
```rust
// 使用頻度最高・IDE補完必須
- string_box.rs → nyashstd.string.*
- math_box.rs → nyashstd.math.*
- array/mod.rs → nyashstd.array.*
- console_box.rs → nyashstd.io.*
```
#### ⚡ **Tier 2: 重要機能**
```rust
// 標準的な機能
- time_box.rs → nyashstd.time.*
- random_box.rs → nyashstd.random.*
- map_box.rs → nyashstd.map.*
```
#### 📝 **Tier 3: 特殊用途**
```rust
// 特定用途・後で追加
- debug_box.rs → nyashstd.debug.*
- http_server_box.rs → nyashstd.http.*
- p2p_box.rs → nyashstd.p2p.*
```
### 最小実装スコープ（Phase 0）
#### **nyashstd.string機能**
```nyash
using nyashstd
string.upper("hello") # "HELLO"
string.lower("WORLD") # "world"
string.split("a,b,c", ",") # ["a", "b", "c"]
string.join(["a","b"], "-") # "a-b"
string.length("test") # 4
```
#### **nyashstd.math機能**
```nyash
using nyashstd
math.sin(3.14159) # 0.0 (approximately)
math.cos(0) # 1.0
math.sqrt(16) # 4.0
math.floor(3.7) # 3
math.random() # 0.0-1.0のランダム値
```
#### **nyashstd.array機能**
```nyash
using nyashstd
array.length([1,2,3]) # 3
array.push([1,2], 3) # [1,2,3]
array.get([1,2,3], 1) # 2
array.slice([1,2,3,4], 1, 3) # [2,3]
```
#### **nyashstd.io機能**
```nyash
using nyashstd
io.print("Hello") # コンソール出力
io.println("World") # 改行付き出力
io.debug("Debug info") # デバッグ出力
```
## 💻 技術実装戦略
### 1. インタープリター組み込み方式
#### **新ファイル: `src/stdlib/mod.rs`**
```rust
//! 組み込み標準ライブラリ
//! nyash.linkなしで動作する基本的な標準関数群
use crate::boxes::*;
use std::collections::HashMap;
pub struct BuiltinStdlib {
pub namespaces: HashMap<String, BuiltinNamespace>,
}
pub struct BuiltinNamespace {
pub name: String,
pub static_boxes: HashMap<String, BuiltinStaticBox>,
}
pub struct BuiltinStaticBox {
pub name: String,
pub methods: HashMap<String, BuiltinMethod>,
}
pub type BuiltinMethod = fn(&[Box<dyn NyashBox>]) -> Result<Box<dyn NyashBox>, RuntimeError>;
impl BuiltinStdlib {
pub fn new() -> Self {
let mut stdlib = BuiltinStdlib {
namespaces: HashMap::new(),
};
// nyashstd名前空間登録
stdlib.register_nyashstd();
stdlib
}
fn register_nyashstd(&mut self) {
let mut nyashstd = BuiltinNamespace {
name: "nyashstd".to_string(),
static_boxes: HashMap::new(),
};
// string static box
nyashstd.static_boxes.insert("string".to_string(), self.create_string_box());
// math static box
nyashstd.static_boxes.insert("math".to_string(), self.create_math_box());
// array static box
nyashstd.static_boxes.insert("array".to_string(), self.create_array_box());
// io static box
nyashstd.static_boxes.insert("io".to_string(), self.create_io_box());
self.namespaces.insert("nyashstd".to_string(), nyashstd);
}
}
```
#### **文字列関数実装例**
```rust
impl BuiltinStdlib {
fn create_string_box(&self) -> BuiltinStaticBox {
let mut string_box = BuiltinStaticBox {
name: "string".to_string(),
methods: HashMap::new(),
};
// string.upper(str) -> String
string_box.methods.insert("upper".to_string(), |args| {
if args.len() != 1 {
return Err(RuntimeError::InvalidArguments(
"string.upper() takes exactly 1 argument".to_string()
));
}
let string_arg = args[0].to_string_box();
let result = StringBox::new(&string_arg.value.to_uppercase());
Ok(Box::new(result))
});
// string.lower(str) -> String
string_box.methods.insert("lower".to_string(), |args| {
if args.len() != 1 {
return Err(RuntimeError::InvalidArguments(
"string.lower() takes exactly 1 argument".to_string()
));
}
let string_arg = args[0].to_string_box();
let result = StringBox::new(&string_arg.value.to_lowercase());
Ok(Box::new(result))
});
// string.split(str, separator) -> Array
string_box.methods.insert("split".to_string(), |args| {
if args.len() != 2 {
return Err(RuntimeError::InvalidArguments(
"string.split() takes exactly 2 arguments".to_string()
));
}
let string_arg = args[0].to_string_box();
let sep_arg = args[1].to_string_box();
let string_box = StringBox::new(&string_arg.value);
let result = string_box.split(&sep_arg.value)?;
Ok(result)
});
string_box
}
}
```
### 2. インタープリター統合
#### **インタープリター拡張: `src/interpreter/core.rs`**
```rust
use crate::stdlib::BuiltinStdlib;
pub struct NyashInterpreter {
// 既存フィールド...
pub builtin_stdlib: BuiltinStdlib,
pub using_imports: HashMap<String, Vec<String>>, // ファイル別インポート
}
impl NyashInterpreter {
pub fn new() -> Self {
NyashInterpreter {
// 既存初期化...
builtin_stdlib: BuiltinStdlib::new(),
using_imports: HashMap::new(),
}
}
// using文実行
pub fn execute_using(&mut self, namespace_name: &str) -> Result<(), RuntimeError> {
// 組み込み名前空間かチェック
if self.builtin_stdlib.namespaces.contains_key(namespace_name) {
// 現在ファイルのインポートリストに追加
self.using_imports
.entry(self.current_file_id.clone())
.or_insert_with(Vec::new)
.push(namespace_name.to_string());
Ok(())
} else {
Err(RuntimeError::UndefinedNamespace(namespace_name.to_string()))
}
}
// 短縮名解決: string.upper() -> nyashstd.string.upper()
pub fn resolve_short_call(&self, box_name: &str, method_name: &str)
-> Option<(&str, &str, &str)> { // (namespace, box, method)
if let Some(imports) = self.using_imports.get(&self.current_file_id) {
for namespace_name in imports {
if let Some(namespace) = self.builtin_stdlib.namespaces.get(namespace_name) {
if namespace.static_boxes.contains_key(box_name) {
return Some((namespace_name, box_name, method_name));
}
}
}
}
None
}
// 組み込み関数呼び出し
pub fn call_builtin_method(&self, namespace: &str, box_name: &str, method_name: &str, args: Vec<Box<dyn NyashBox>>)
-> Result<Box<dyn NyashBox>, RuntimeError> {
if let Some(ns) = self.builtin_stdlib.namespaces.get(namespace) {
if let Some(static_box) = ns.static_boxes.get(box_name) {
if let Some(method) = static_box.methods.get(method_name) {
return method(&args);
}
}
}
Err(RuntimeError::UndefinedMethod(
format!("{}.{}.{}", namespace, box_name, method_name)
))
}
}
```
### 3. パーサー最小拡張
#### **トークナイザー: `src/tokenizer.rs`**
```rust
pub enum TokenType {
// 既存...
USING, // using キーワード
// NAMESPACE は後のPhaseで追加
}
```
#### **AST最小拡張: `src/ast.rs`**
```rust
pub enum ASTNode {
// 既存...
UsingStatement {
namespace_name: String, // "nyashstd" のみ対応
span: Span,
},
// QualifiedCall は後のPhaseで追加
}
```
#### **パーサー: `src/parser/statements.rs`**
```rust
impl NyashParser {
pub fn parse_using(&mut self) -> Result<ASTNode, ParseError> {
self.advance(); // consume 'using'
if let TokenType::IDENTIFIER(namespace_name) = &self.current_token().token_type {
let name = namespace_name.clone();
self.advance();
// Phase 0では "nyashstd" のみ許可
if name != "nyashstd" {
return Err(ParseError::UnsupportedNamespace(name));
}
Ok(ASTNode::UsingStatement {
namespace_name: name,
span: self.current_span(),
})
} else {
Err(ParseError::ExpectedIdentifier)
}
}
}
```
## 🧪 テスト戦略
### Phase 0テストケース
#### **基本using文テスト**
```nyash
# test_using_basic.nyash
using nyashstd
local result = string.upper("hello")
assert(result == "HELLO")
local lower = string.lower("WORLD")
assert(lower == "world")
```
#### **数学関数テスト**
```nyash
# test_math_basic.nyash
using nyashstd
local sin_result = math.sin(0)
assert(sin_result == 0)
local sqrt_result = math.sqrt(16)
assert(sqrt_result == 4)
```
#### **配列操作テスト**
```nyash
# test_array_basic.nyash
using nyashstd
local arr = [1, 2, 3]
local length = array.length(arr)
assert(length == 3)
local item = array.get(arr, 1)
assert(item == 2)
```
## 📊 実装マイルストーン
### ✅ Phase 0完了条件
- [ ] USING トークン認識
- [ ] using nyashstd 構文解析
- [ ] 組み込みnyashstd.string実装
- [ ] 組み込みnyashstd.math実装
- [ ] 組み込みnyashstd.array実装
- [ ] 組み込みnyashstd.io実装
- [ ] 基本テストケース全通過
### 🔮 将来の発展
#### **Phase 1: 完全修飾名対応**
```nyash
# using不要でも使える
nyashstd.string.upper("hello")
```
#### **Phase 2: namespace構文対応**
```nyash
# 組み込み以外の名前空間
namespace mylib {
static box utils {
static process(data) { ... }
}
}
```
#### **Phase 3: nyash.link統合**
```toml
# nyash.link
[dependencies]
mylib = { path = "./mylib.nyash" }
```
## 🎯 実装優先順位
### 🚨 Critical（今すぐ）
1. **USINGトークナイザー** - Token::USING追加
2. **using文パーサー** - "using nyashstd"解析
3. **BuiltinStdlib基盤** - src/stdlib/mod.rs作成
### ⚡ High（今週中）
4. **string関数実装** - upper, lower, split, join
5. **math関数実装** - sin, cos, sqrt, floor
6. **基本テスト** - using nyashstd動作確認
### 📝 Medium（来週）
7. **array関数実装** - length, get, push, slice
8. **io関数実装** - print, println, debug
9. **エラーハンドリング** - 適切なエラーメッセージ
---
**🎉 この戦略なら複雑なファイル依存関係システムなしで、すぐに実用的なnamespace/usingが実現できるにゃ！🐱**

625
docs/development/proposals/nyash.link/real-world-examples.md Normal file
View File

@ -0,0 +1,625 @@
# なんでもAPI計画：実世界での具体例
## 🌟 革命的開発体験の実例
### 🎮 ゲーム開発例：Nyashブラウザゲーム
```nyash
# === nyash.link ===
[dependencies]
nyashstd = { builtin = true }
canvas_api = { bid = "./apis/canvas.yaml" }
dom_api = { bid = "./apis/dom.yaml" }
audio_api = { bid = "./apis/webaudio.yaml" }
# === game.nyash ===
using nyashstd
using canvas_api
using dom_api
using audio_api
static box Game {
init { canvas_id, score, player_x, player_y, enemies }
main() {
me.canvas_id = "game-canvas"
me.score = 0
me.player_x = 200
me.player_y = 300
me.enemies = new ArrayBox()
# DOMイベント設定（FFI-ABI経由）
dom.addEventListener("keydown", me.handleKeyDown)
# ゲームループ開始
me.gameLoop()
}
gameLoop() {
loop(true) {
me.update()
me.render()
# ブラウザのrequestAnimationFrame（FFI-ABI）
dom.requestAnimationFrame(me.gameLoop)
}
}
update() {
# 敵の移動（組み込み標準ライブラリ）
local i = 0
loop(i < array.length(me.enemies)) {
local enemy = array.get(me.enemies, i)
enemy.y = enemy.y + enemy.speed
i = i + 1
}
# 当たり判定（組み込み数学関数）
local distance = math.sqrt(
math.pow(me.player_x - enemy.x, 2) +
math.pow(me.player_y - enemy.y, 2)
)
if distance < 30 {
me.gameOver()
}
}
render() {
# 画面クリア（Canvas API - FFI-ABI）
canvas.fillRect(me.canvas_id, 0, 0, 800, 600, "black")
# プレイヤー描画
canvas.fillRect(me.canvas_id, me.player_x, me.player_y, 20, 20, "blue")
# 敵描画
local i = 0
loop(i < array.length(me.enemies)) {
local enemy = array.get(me.enemies, i)
canvas.fillRect(me.canvas_id, enemy.x, enemy.y, 15, 15, "red")
i = i + 1
}
# スコア表示
local score_text = "Score: " + string.toString(me.score)
canvas.fillText(me.canvas_id, score_text, 10, 30, "20px Arial", "white")
}
handleKeyDown(event) {
# キーボード入力処理（DOM API経由）
local key = dom.getEventKey(event)
if key == "ArrowLeft" {
me.player_x = me.player_x - 10
} else if key == "ArrowRight" {
me.player_x = me.player_x + 10
} else if key == " " { # スペースキー
me.shoot()
}
}
shoot() {
# 効果音再生（Web Audio API - FFI-ABI）
audio.playSound("shoot.wav")
# 弾の生成・発射処理
# ...
}
gameOver() {
# ゲームオーバー処理
audio.playSound("gameover.wav")
dom.alert("Game Over! Score: " + string.toString(me.score))
}
}
```
### 🔬 データサイエンス例：画像処理アプリ
```nyash
# === nyash.link ===
[dependencies]
nyashstd = { builtin = true }
opencv_api = { bid = "./apis/opencv.yaml", library = "./libs/opencv.so" }
numpy_api = { bid = "./apis/numpy.yaml", library = "./libs/numpy.so" }
matplotlib_api = { bid = "./apis/matplotlib.yaml", library = "./libs/matplotlib.so" }
file_api = { bid = "./apis/file.yaml" }
# === image_processor.nyash ===
using nyashstd
using opencv_api
using numpy_api
using matplotlib_api
using file_api
static box ImageProcessor {
init { input_path, output_path, processed_data }
main() {
me.input_path = "./images/input.jpg"
me.output_path = "./images/output.jpg"
# 画像読み込み（OpenCV - FFI-ABI）
local image = opencv.imread(me.input_path)
# 前処理
local gray = opencv.cvtColor(image, "BGR2GRAY")
local blurred = opencv.gaussianBlur(gray, 5, 5)
# エッジ検出
local edges = opencv.canny(blurred, 50, 150)
# NumPy配列操作（NumPy - FFI-ABI）
local edge_array = numpy.fromOpenCV(edges)
local normalized = numpy.normalize(edge_array, 0, 255)
# 統計計算（組み込み標準ライブラリ）
local edge_count = me.countEdgePixels(normalized)
local percentage = (edge_count * 100) / (image.width * image.height)
# 結果表示
io.println("Edge pixels: " + string.toString(edge_count))
io.println("Edge percentage: " + string.toString(percentage) + "%")
# 結果画像保存（OpenCV）
opencv.imwrite(me.output_path, edges)
# グラフ生成（Matplotlib - FFI-ABI）
me.generateHistogram(normalized)
}
countEdgePixels(image_array) {
local count = 0
local height = numpy.shape(image_array, 0)
local width = numpy.shape(image_array, 1)
local y = 0
loop(y < height) {
local x = 0
loop(x < width) {
local pixel = numpy.get(image_array, y, x)
if pixel > 0 {
count = count + 1
}
x = x + 1
}
y = y + 1
}
return count
}
generateHistogram(image_array) {
# ヒストグラム計算（NumPy）
local histogram = numpy.histogram(image_array, 256)
# グラフ描画（Matplotlib）
matplotlib.figure(800, 600)
matplotlib.plot(histogram.bins, histogram.values)
matplotlib.title("Edge Pixel Histogram")
matplotlib.xlabel("Pixel Intensity")
matplotlib.ylabel("Frequency")
matplotlib.savefig("./images/histogram.png")
matplotlib.show()
}
}
```
### 🌐 Webサーバー例：RESTful API
```nyash
# === nyash.link ===
[dependencies]
nyashstd = { builtin = true }
http_server_api = { bid = "./apis/http_server.yaml" }
sqlite_api = { bid = "./apis/sqlite.yaml", library = "./libs/sqlite.so" }
json_api = { bid = "./apis/json.yaml" }
crypto_api = { bid = "./apis/crypto.yaml", library = "./libs/openssl.so" }
# === api_server.nyash ===
using nyashstd
using http_server_api
using sqlite_api
using json_api
using crypto_api
static box ApiServer {
init { server, database, port }
main() {
me.port = 8080
me.server = http_server.create()
me.database = sqlite.open("./data/app.db")
# データベース初期化
me.initDatabase()
# ルート設定
http_server.route(me.server, "GET", "/api/users", me.getUsers)
http_server.route(me.server, "POST", "/api/users", me.createUser)
http_server.route(me.server, "PUT", "/api/users/:id", me.updateUser)
http_server.route(me.server, "DELETE", "/api/users/:id", me.deleteUser)
# サーバー開始
io.println("Server starting on port " + string.toString(me.port))
http_server.listen(me.server, me.port)
}
initDatabase() {
local sql = "CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
email TEXT UNIQUE NOT NULL,
password_hash TEXT NOT NULL,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)"
sqlite.exec(me.database, sql)
}
getUsers(request, response) {
# クエリ実行（SQLite - FFI-ABI）
local sql = "SELECT id, name, email, created_at FROM users"
local results = sqlite.query(me.database, sql)
# JSON変換（JSON API - FFI-ABI）
local json_response = json.stringify(results)
# レスポンス送信（HTTP Server API）
http_server.setHeader(response, "Content-Type", "application/json")
http_server.setStatus(response, 200)
http_server.send(response, json_response)
}
createUser(request, response) {
# リクエストボディ解析
local body = http_server.getBody(request)
local user_data = json.parse(body)
# バリデーション（組み込み標準ライブラリ）
if string.length(user_data.name) < 2 {
me.sendError(response, 400, "Name must be at least 2 characters")
return
}
if not me.isValidEmail(user_data.email) {
me.sendError(response, 400, "Invalid email format")
return
}
# パスワードハッシュ化（Crypto API - FFI-ABI）
local password_hash = crypto.hashPassword(user_data.password)
# データベース挿入
local sql = "INSERT INTO users (name, email, password_hash) VALUES (?, ?, ?)"
local params = [user_data.name, user_data.email, password_hash]
try {
local user_id = sqlite.insert(me.database, sql, params)
# 作成されたユーザー情報を返す
local created_user = map.create()
map.set(created_user, "id", user_id)
map.set(created_user, "name", user_data.name)
map.set(created_user, "email", user_data.email)
local json_response = json.stringify(created_user)
http_server.setHeader(response, "Content-Type", "application/json")
http_server.setStatus(response, 201)
http_server.send(response, json_response)
} catch error {
io.println("Database error: " + error.message)
me.sendError(response, 500, "Failed to create user")
}
}
isValidEmail(email) {
# 簡単なメール検証（組み込み文字列関数）
local at_pos = string.indexOf(email, "@")
local dot_pos = string.lastIndexOf(email, ".")
return at_pos > 0 and dot_pos > at_pos and dot_pos < string.length(email) - 1
}
sendError(response, status, message) {
local error_obj = map.create()
map.set(error_obj, "error", message)
local json_error = json.stringify(error_obj)
http_server.setHeader(response, "Content-Type", "application/json")
http_server.setStatus(response, status)
http_server.send(response, json_error)
}
}
```
### 🔧 システムプログラミング例：ファイル監視ツール
```nyash
# === nyash.link ===
[dependencies]
nyashstd = { builtin = true }
libc_api = { bid = "./apis/libc.yaml", library = "system" }
inotify_api = { bid = "./apis/inotify.yaml", library = "system" }
filesystem_api = { bid = "./apis/filesystem.yaml" }
# === file_monitor.nyash ===
using nyashstd
using libc_api
using inotify_api
using filesystem_api
static box FileMonitor {
init { watch_path, inotify_fd, watch_descriptors, callbacks }
main() {
me.watch_path = "./watched_directory"
me.watch_descriptors = new ArrayBox()
me.callbacks = map.create()
# inotify初期化（Linux inotify - FFI-ABI）
me.inotify_fd = inotify.init()
if me.inotify_fd < 0 {
io.println("Failed to initialize inotify")
return
}
# ディレクトリ監視設定
me.addWatch(me.watch_path)
# コールバック設定
me.setupCallbacks()
io.println("File monitor started. Watching: " + me.watch_path)
# メインループ
me.eventLoop()
}
addWatch(path) {
# 監視フラグ（inotify constants）
local flags = inotify.IN_CREATE or inotify.IN_DELETE or
inotify.IN_MODIFY or inotify.IN_MOVED_FROM or
inotify.IN_MOVED_TO
local wd = inotify.addWatch(me.inotify_fd, path, flags)
if wd >= 0 {
array.push(me.watch_descriptors, wd)
io.println("Added watch for: " + path)
} else {
io.println("Failed to add watch for: " + path)
}
}
setupCallbacks() {
# ファイル作成コールバック
map.set(me.callbacks, "CREATE", static function(event) {
io.println("File created: " + event.name)
# ファイル情報取得（Filesystem API）
local file_info = filesystem.stat(event.path)
local size = file_info.size
local permissions = file_info.permissions
io.println(" Size: " + string.toString(size) + " bytes")
io.println(" Permissions: " + permissions)
})
# ファイル変更コールバック
map.set(me.callbacks, "MODIFY", static function(event) {
io.println("File modified: " + event.name)
# 変更時刻記録
local timestamp = time.now()
local formatted_time = time.format(timestamp, "%Y-%m-%d %H:%M:%S")
io.println(" Modified at: " + formatted_time)
})
# ファイル削除コールバック
map.set(me.callbacks, "DELETE", static function(event) {
io.println("File deleted: " + event.name)
# ログファイルに記録
me.logEvent("DELETE", event.name, time.now())
})
}
eventLoop() {
local buffer_size = 4096
local buffer = libc.malloc(buffer_size)
loop(true) {
# inotify eventsを読み取り（blocking read）
local bytes_read = libc.read(me.inotify_fd, buffer, buffer_size)
if bytes_read > 0 {
me.processEvents(buffer, bytes_read)
} else if bytes_read == 0 {
# EOF
break
} else {
# エラー
local error_code = libc.errno()
io.println("Read error: " + string.toString(error_code))
break
}
}
libc.free(buffer)
}
processEvents(buffer, bytes_read) {
local offset = 0
loop(offset < bytes_read) {
# inotify_event構造体解析（libc memory operations）
local event = inotify.parseEvent(buffer, offset)
# イベントタイプ判定
local event_type = me.getEventType(event.mask)
# 対応するコールバック実行
if map.has(me.callbacks, event_type) {
local callback = map.get(me.callbacks, event_type)
callback(event)
}
# 次のイベントへ
offset = offset + event.size
}
}
getEventType(mask) {
if mask and inotify.IN_CREATE {
return "CREATE"
} else if mask and inotify.IN_MODIFY {
return "MODIFY"
} else if mask and inotify.IN_DELETE {
return "DELETE"
} else if mask and inotify.IN_MOVED_FROM {
return "MOVE_FROM"
} else if mask and inotify.IN_MOVED_TO {
return "MOVE_TO"
} else {
return "UNKNOWN"
}
}
logEvent(event_type, filename, timestamp) {
local log_entry = time.format(timestamp, "%Y-%m-%d %H:%M:%S") +
" [" + event_type + "] " + filename + "\n"
# ログファイルに追記（Filesystem API）
filesystem.appendFile("./file_monitor.log", log_entry)
}
}
```
## 📊 MIR同時拡張による最適化効果
### 🚀 最適化前後の比較
#### **従来の実装（最適化なし）**
```mir
; 非効率：毎回関数呼び出し
%1 = ExternCall env.canvas.fillRect ["canvas", 10, 10, 100, 100, "red"]
%2 = ExternCall env.canvas.fillRect ["canvas", 110, 10, 100, 100, "blue"]
%3 = ExternCall env.canvas.fillRect ["canvas", 220, 10, 100, 100, "green"]
```
#### **MIR最適化後（バッチ処理）**
```mir
; 効率化：バッチ処理
%rects = ArrayConstruct [
{x: 10, y: 10, w: 100, h: 100, color: "red"},
{x: 110, y: 10, w: 100, h: 100, color: "blue"},
{x: 220, y: 10, w: 100, h: 100, color: "green"}
]
%1 = ExternCall env.canvas.fillRectBatch ["canvas", %rects]
```
#### **Effect Systemによる並列化**
```mir
; pure関数は並列実行可能
%1 = BuiltinCall string.upper ["hello"] ; effect: pure
%2 = BuiltinCall math.sin [3.14] ; effect: pure
%3 = BuiltinCall string.lower ["WORLD"] ; effect: pure
; ↑ これらは並列実行される
%4 = ExternCall env.console.log [%1] ; effect: io
%5 = ExternCall env.console.log [%2] ; effect: io
; ↑ これらは順序保持される
```
### 🎯 バックエンド別最適化
#### **WASM最適化**
```wasm
;; BIDから自動生成された最適化WASM
(func $optimized_canvas_batch
(param $canvas_id i32) (param $canvas_id_len i32)
(param $rects_ptr i32) (param $rect_count i32)
;; ループ展開による高速化
(local $i i32)
(local $rect_ptr i32)
loop $rect_loop
;; 直接メモリアクセス（境界チェック済み）
local.get $rect_ptr
i32.load ;; x
local.get $rect_ptr
i32.load offset=4 ;; y
;; ... 高速描画処理
local.get $rect_ptr
i32.const 20
i32.add
local.set $rect_ptr
local.get $i
i32.const 1
i32.add
local.tee $i
local.get $rect_count
i32.lt_u
br_if $rect_loop
end
)
```
#### **AOT最適化（LLVM IR）**
```llvm
; LLVM IRレベルでの最適化
define void @optimized_image_processing(i8* %image_data, i32 %width, i32 %height) {
entry:
; ベクトル化された画像処理
%0 = bitcast i8* %image_data to <16 x i8>*
; SIMD命令による並列処理
br label %loop.header
loop.header:
%i = phi i32 [ 0, %entry ], [ %i.next, %loop.body ]
%cmp = icmp ult i32 %i, %height
br i1 %cmp, label %loop.body, label %exit
loop.body:
; 16ピクセル同時処理（AVX2/NEON活用）
%pixel_ptr = getelementptr <16 x i8>, <16 x i8>* %0, i32 %i
%pixels = load <16 x i8>, <16 x i8>* %pixel_ptr
; ベクトル化されたエッジ検出
%edges = call <16 x i8> @vectorized_edge_detection(<16 x i8> %pixels)
store <16 x i8> %edges, <16 x i8>* %pixel_ptr
%i.next = add i32 %i, 1
br label %loop.header
exit:
ret void
}
```
## 🌟 革命的効果
### 🚀 開発者体験の向上
- **学習コスト**: 一つの構文ですべてのAPIが使える
- **IDE統合**: 全APIの統一補完・エラー検出
- **デバッグ**: 統一エラーモデルによる一貫したデバッグ体験
### ⚡ パフォーマンス向上
- **MIRレベル最適化**: すべてのAPIで同じ最適化技術
- **Effect System**: 安全な並列化・順序最適化
- **バックエンド最適化**: WASM/AOT固有の最適化
### 🌍 エコシステム拡大
- **ライブラリ統合**: 既存C/Rustライブラリの簡単統合
- **クロスプラットフォーム**: 同じコードが全環境で動作
- **標準化**: BIDによる外部API標準化
---
**🎉 これが「なんでもAPI計画」の真の実力だにゃ！あらゆる開発が統一された美しい構文で実現できるにゃ！🚀🐱**

563
docs/development/proposals/nyash.link/universal-api-integration.md Normal file
View File

@ -0,0 +1,563 @@
# なんでもAPI計画：nyash.link × FFI-ABI × MIR 統合設計
## 🌟 革命的統合ビジョン
### 📊 現状把握
- ✅ **nyash.linkシステム**: 標準関数・モジュール管理設計完了
- ✅ **FFI-ABI仕様**: BID(Box Interface Definition)による外部API統一
- ✅ **MIR ExternCall**: 外部関数呼び出しのMIRレベル実装
- 🎯 **統合目標**: 3つのシステムを統合し「なんでもAPI」を実現
### 🚀 統合後の開発体験
```nyash
# === 単一のusing構文ですべてが使える！ ===
using nyashstd # 組み込み標準ライブラリ
using console_api # ブラウザConsole API (FFI-ABI)
using canvas_api # Canvas API (FFI-ABI)
using opencv_api # OpenCV外部ライブラリ (FFI-ABI)
using mylib # 自作Nyashモジュール
# 全部同じ記法で使える！
string.upper("hello") # 組み込み標準ライブラリ
console.log("Hello Nyash!") # ブラウザAPI
canvas.fillRect("game", 10, 10, 80, 60, "red") # Canvas API
opencv.loadImage("photo.jpg") # 外部ライブラリ
mylib.processData("input") # 自作モジュール
```
## 🏗️ 統合アーキテクチャ設計
### 1. 拡張nyash.link仕様
#### **依存関係タイプの統合**
```toml
# nyash.link - 全API統一管理
[project]
name = "awesome-nyash-app"
version = "1.0.0"
[dependencies]
# === 組み込み標準ライブラリ ===
nyashstd = { builtin = true }
# === FFI-ABI経由外部API ===
console_api = { bid = "./apis/console.yaml" }
canvas_api = { bid = "./apis/canvas.yaml" }
webgl_api = { bid = "./apis/webgl.yaml" }
dom_api = { bid = "./apis/dom.yaml" }
# === システムライブラリ ===
libc = { bid = "./apis/libc.yaml", library = "system" }
math_lib = { bid = "./apis/math.yaml", library = "libm" }
# === 外部共有ライブラリ ===
opencv = { bid = "./apis/opencv.yaml", library = "./libs/opencv.so" }
sqlite = { bid = "./apis/sqlite.yaml", library = "./libs/sqlite.so" }
# === Nyashモジュール（従来通り） ===
mylib = { path = "./src/mylib.nyash" }
utils = { path = "./src/utils.nyash" }
models = { path = "./src/models/" }
# === 将来の外部パッケージ ===
# http_client = { version = "1.0.0", registry = "nyash-pkg" }
[build]
entry_point = "./src/main.nyash"
backends = ["vm", "wasm", "aot"] # 対象バックエンド指定
```
#### **BIDファイル例**
```yaml
# apis/console.yaml - Console API定義
version: 0
metadata:
name: "Browser Console API"
description: "Standard browser console interface"
target_environments: ["browser", "node"]
interfaces:
- name: console_api.console
box: Console
namespace: console_api
methods:
- name: log
params: [ {string: message} ]
returns: void
effect: io
description: "Output message to console"
- name: warn
params: [ {string: message} ]
returns: void
effect: io
- name: error
params: [ {string: message} ]
returns: void
effect: io
# apis/canvas.yaml - Canvas API定義
version: 0
interfaces:
- name: canvas_api.canvas
box: Canvas
namespace: canvas_api
methods:
- name: fillRect
params:
- {string: canvas_id}
- {i32: x}
- {i32: y}
- {i32: width}
- {i32: height}
- {string: color}
returns: void
effect: io
- name: fillText
params:
- {string: canvas_id}
- {string: text}
- {i32: x}
- {i32: y}
- {string: font}
- {string: color}
returns: void
effect: io
```
### 2. 統合名前空間レジストリ
#### **UniversalNamespaceRegistry設計**
```rust
// 新ファイル: src/registry/universal.rs
use crate::stdlib::BuiltinStdlib;
use crate::bid::BidDefinition;
use crate::module::ExternalModule;
pub struct UniversalNamespaceRegistry {
/// 組み込み標準ライブラリ
builtin: Arc<BuiltinStdlib>,
/// FFI-ABI経由の外部API
ffi_apis: HashMap<String, Arc<BidDefinition>>,
/// Nyashモジュール
nyash_modules: HashMap<String, Arc<ExternalModule>>,
/// using imports（ファイル別）
using_imports: Arc<RwLock<HashMap<String, UsingContext>>>,
}
#[derive(Debug, Clone)]
pub struct UsingContext {
pub builtin_imports: Vec<String>, // ["nyashstd"]
pub ffi_imports: Vec<String>, // ["console_api", "canvas_api"]
pub module_imports: Vec<String>, // ["mylib", "utils"]
pub file_id: String,
}
impl UniversalNamespaceRegistry {
pub fn new(nyash_link: &NyashLink) -> Result<Self, RegistryError> {
let mut registry = UniversalNamespaceRegistry {
builtin: Arc::new(BuiltinStdlib::new()),
ffi_apis: HashMap::new(),
nyash_modules: HashMap::new(),
using_imports: Arc::new(RwLock::new(HashMap::new())),
};
// nyash.linkからFFI-ABI定義読み込み
registry.load_ffi_apis(nyash_link)?;
// Nyashモジュール読み込み
registry.load_nyash_modules(nyash_link)?;
Ok(registry)
}
/// 統合using文処理
pub fn execute_using(&mut self, namespace_name: &str, file_id: &str)
-> Result<(), RuntimeError> {
let context = self.using_imports
.write().unwrap()
.entry(file_id.to_string())
.or_insert_with(|| UsingContext {
builtin_imports: Vec::new(),
ffi_imports: Vec::new(),
module_imports: Vec::new(),
file_id: file_id.to_string(),
});
// 組み込み標準ライブラリ
if self.builtin.has_namespace(namespace_name) {
if !context.builtin_imports.contains(&namespace_name.to_string()) {
context.builtin_imports.push(namespace_name.to_string());
}
return Ok(());
}
// FFI-ABI API
if self.ffi_apis.contains_key(namespace_name) {
if !context.ffi_imports.contains(&namespace_name.to_string()) {
context.ffi_imports.push(namespace_name.to_string());
}
return Ok(());
}
// Nyashモジュール
if self.nyash_modules.contains_key(namespace_name) {
if !context.module_imports.contains(&namespace_name.to_string()) {
context.module_imports.push(namespace_name.to_string());
}
return Ok(());
}
Err(RuntimeError::UndefinedNamespace(namespace_name.to_string()))
}
/// 統合関数解決
pub fn resolve_call(&self, file_id: &str, path: &[String])
-> Result<CallTarget, RuntimeError> {
if path.len() != 2 {
return Err(RuntimeError::InvalidQualifiedName(path.join(".")));
}
let box_name = &path[0];
let method_name = &path[1];
if let Ok(imports) = self.using_imports.read() {
if let Some(context) = imports.get(file_id) {
// 1. 組み込み標準ライブラリ検索
for namespace in &context.builtin_imports {
if let Some(target) = self.builtin.resolve_call(namespace, box_name, method_name) {
return Ok(CallTarget::Builtin(target));
}
}
// 2. FFI-ABI API検索
for namespace in &context.ffi_imports {
if let Some(bid) = self.ffi_apis.get(namespace) {
if let Some(target) = bid.resolve_method(box_name, method_name) {
return Ok(CallTarget::FfiAbi(target));
}
}
}
// 3. Nyashモジュール検索
for namespace in &context.module_imports {
if let Some(module) = self.nyash_modules.get(namespace) {
if let Some(target) = module.resolve_method(box_name, method_name) {
return Ok(CallTarget::NyashModule(target));
}
}
}
}
}
Err(RuntimeError::UndefinedMethod(format!("{}.{}", box_name, method_name)))
}
}
#[derive(Debug)]
pub enum CallTarget {
Builtin(BuiltinMethodTarget),
FfiAbi(FfiMethodTarget),
NyashModule(NyashMethodTarget),
}
```
### 3. MIRレベル統合
#### **MIR命令拡張**
```rust
// src/mir/instruction.rs拡張
#[derive(Debug, Clone)]
pub enum MirInstruction {
// 既存命令...
// === 統合関数呼び出し ===
/// 組み込み標準ライブラリ呼び出し
BuiltinCall {
target: String, // "string.upper"
args: Vec<ValueId>,
result: ValueId,
effect: Effect,
},
/// FFI-ABI外部API呼び出し
ExternCall {
interface: String, // "console_api.console"
method: String, // "log"
args: Vec<ValueId>,
result: Option<ValueId>,
effect: Effect,
bid_signature: BidMethodSignature,
},
/// Nyashモジュール関数呼び出し
ModuleCall {
module: String, // "mylib"
function: String, // "processData"
args: Vec<ValueId>,
result: ValueId,
effect: Effect,
},
}
#[derive(Debug, Clone)]
pub enum Effect {
Pure, // 副作用なし、並び替え可能
Mut, // 同リソース内で順序保持
Io, // プログラム順序保持
Control, // 制御フロー影響
}
```
#### **MIR生成統合**
```rust
// src/mir/builder.rs拡張
impl MirBuilder {
pub fn build_unified_call(&mut self, target: CallTarget, args: Vec<ValueId>)
-> Result<ValueId, MirError> {
match target {
CallTarget::Builtin(builtin_target) => {
let result = self.new_value_id();
self.emit(MirInstruction::BuiltinCall {
target: builtin_target.qualified_name(),
args,
result,
effect: builtin_target.effect(),
});
Ok(result)
},
CallTarget::FfiAbi(ffi_target) => {
let result = if ffi_target.returns_void() {
None
} else {
Some(self.new_value_id())
};
self.emit(MirInstruction::ExternCall {
interface: ffi_target.interface_name(),
method: ffi_target.method_name(),
args,
result,
effect: ffi_target.effect(),
bid_signature: ffi_target.signature().clone(),
});
result.ok_or(MirError::VoidReturn)
},
CallTarget::NyashModule(module_target) => {
let result = self.new_value_id();
self.emit(MirInstruction::ModuleCall {
module: module_target.module_name(),
function: module_target.function_name(),
args,
result,
effect: Effect::Io, // デフォルト
});
Ok(result)
},
}
}
}
```
### 4. バックエンド統合実装
#### **VM実行統合**
```rust
// src/backend/vm.rs拡張
impl VmBackend {
pub fn execute_instruction(&mut self, instr: &MirInstruction)
-> Result<(), VmError> {
match instr {
MirInstruction::BuiltinCall { target, args, result, .. } => {
let evaluated_args = self.evaluate_args(args)?;
let output = self.builtin_executor.call(target, evaluated_args)?;
self.set_value(*result, output);
Ok(())
},
MirInstruction::ExternCall { interface, method, args, result, bid_signature, .. } => {
// VM環境ではスタブ実装
let evaluated_args = self.evaluate_args(args)?;
let output = self.extern_stub.call(interface, method, evaluated_args, bid_signature)?;
if let Some(res_id) = result {
self.set_value(*res_id, output);
}
Ok(())
},
MirInstruction::ModuleCall { module, function, args, result, .. } => {
let evaluated_args = self.evaluate_args(args)?;
let output = self.module_executor.call(module, function, evaluated_args)?;
self.set_value(*result, output);
Ok(())
},
// 既存命令処理...
}
}
}
```
#### **WASM生成統合**
```rust
// src/backend/wasm/codegen.rs拡張
impl WasmCodegen {
pub fn generate_instruction(&mut self, instr: &MirInstruction)
-> Result<(), WasmError> {
match instr {
MirInstruction::BuiltinCall { target, args, result, .. } => {
// 組み込み関数は直接実装
self.generate_builtin_call(target, args, *result)
},
MirInstruction::ExternCall { interface, method, args, bid_signature, .. } => {
// BIDから自動生成されたWASM import呼び出し
let import_name = format!("{}_{}",
interface.replace(".", "_"),
method
);
self.generate_extern_call(&import_name, args, bid_signature)
},
MirInstruction::ModuleCall { module, function, args, result, .. } => {
// 内部関数呼び出し
let function_name = format!("{}_{}", module, function);
self.generate_function_call(&function_name, args, *result)
},
}
}
/// BIDからWASM RuntimeImports自動生成
pub fn generate_runtime_imports(&mut self, bid_definitions: &[BidDefinition])
-> Result<String, WasmError> {
let mut imports = String::new();
for bid in bid_definitions {
for interface in &bid.interfaces {
for method in &interface.methods {
let import_name = format!("{}_{}",
interface.name.replace(".", "_"),
method.name
);
let signature = self.bid_to_wasm_signature(&method.params, &method.returns)?;
imports.push_str(&format!(
"(import \"env\" \"{}\" {})\n",
import_name, signature
));
}
}
}
Ok(imports)
}
}
```
#### **AOT生成統合**
```rust
// src/backend/aot/compiler.rs拡張
impl AotCompiler {
pub fn compile_instruction(&mut self, instr: &MirInstruction)
-> Result<(), AotError> {
match instr {
MirInstruction::ExternCall { interface, method, args, bid_signature, .. } => {
// LLVM IR外部関数宣言生成
let extern_func_name = format!("{}_{}",
interface.replace(".", "_"),
method
);
let signature = self.bid_to_llvm_signature(bid_signature)?;
self.declare_external_function(&extern_func_name, &signature)?;
self.generate_call(&extern_func_name, args)?;
Ok(())
},
// その他の命令処理...
}
}
}
```
## 🎯 段階的実装戦略
### Phase 0: 基盤統合（2-3週間）
1. **UniversalNamespaceRegistry実装** - 全API統一管理
2. **nyash.link拡張** - BID依存関係サポート
3. **統合using文** - 3種類のAPI統一インポート
### Phase 1: FFI-ABI統合（3-4週間）
1. **BID読み込み機能** - YAML解析・検証
2. **MIR ExternCall統合** - FFI-ABI→MIR変換
3. **WASM RuntimeImports自動生成** - BID→WASM import
### Phase 2: 完全統合（4-6週間）
1. **全バックエンド対応** - VM/WASM/AOT統合実装
2. **エラーハンドリング統合** - 統一エラーモデル
3. **パフォーマンス最適化** - 高速名前解決
## 🧪 統合テスト戦略
### 基本統合テスト
```nyash
# test_universal_integration.nyash
using nyashstd
using console_api
using mylib
# 3種類のAPIが同じように使える
assert(string.upper("test") == "TEST") # 組み込み
console.log("Integration test successful") # FFI-ABI
assert(mylib.process("data") == "processed") # Nyash
```
### FFI-ABI統合テスト
```nyash
# test_ffi_abi_integration.nyash
using canvas_api
# Canvas API経由での描画
canvas.fillRect("game-canvas", 10, 10, 100, 100, "red")
canvas.fillText("game-canvas", "Score: 100", 10, 30, "16px Arial", "white")
```
## 🌟 期待される革命的効果
### 🚀 開発者体験
- **統一API**: 組み込み・外部・自作すべて同じ書き方
- **IDE補完**: すべてのAPIが`ny`で補完される
- **エラー処理**: 統一エラーモデルで一貫性
### 🏗️ アーキテクチャ
- **MIRレベル統合**: 全バックエンドで同じパフォーマンス最適化
- **Effect System**: pure/mut/io/controlによる安全性保証
- **言語非依存**: BIDによる外部ライブラリ標準化
### 🌍 エコシステム
- **なんでもAPI**: あらゆる外部ライブラリがNyashから使える
- **バックエンド統一**: 同じコードがVM/WASM/AOTで動作
- **将来拡張**: パッケージレジストリでBID共有
---
**🎉 この統合設計で、Nyashが真に「なんでもできる」モダン言語になるにゃ！🚀🐱**