Susumu - Arrow-Flow Programming Language

Susumu is a revolutionary functional programming language that uses arrow syntax to make data flow visually explicit. Instead of forcing developers to mentally trace data through complex systems, Susumu makes the data journey visible through arrows.

🚀 Quick Start

Installation

From Cargo (Rust):

cargo install susumu

From GitHub Releases:

# Download binary for your platform from GitHub releases
curl -L https://github.com/susumu-lang/susumu/releases/latest/download/susumu-linux -o susumu
chmod +x susumu

VSCode Extension: Install the "Susumu Language Support" extension from the VSCode marketplace for syntax highlighting, LSP support, and integrated development features.

Hello World

Create a file hello.susu:

main() {
    "Hello, Susumu!" -> print
}

Run it:

susumu hello.susu

📖 Language Overview

Core Concept: Visual Data Flow

Traditional code hides data flow:

# Python - data flow is hidden
result = process_data(validate_input(user_input))

Susumu makes data flow explicit:

# Susumu - data flow is visual
user_input -> validate_input -> process_data -> result

Basic Syntax

Arrow Operations:

5 -> double -> add_ten -> print    # Forward flow: 5 → double → add_ten → print
data -> process <- config          # Convergence: data and config flow into process

Functions:

double(x) { x -> multiply <- 2 }
process_order(order) {
    order -> validate -> calculate_total -> charge_payment
}

Control Flow:

user -> authenticate -> i success {
    user -> load_dashboard -> return <- dashboard
} e {
    user -> redirect_login -> error <- "Authentication failed"
}

Complex Example:

process_payment(order, payment_method) {
    order -> validate_items -> i valid {
        (order, payment_method) -> charge_card -> i success {
            order -> update_inventory -> 
            send_confirmation -> 
            return <- order_confirmation
        } e {
            order -> refund -> 
            notify_failure -> 
            error <- payment_error
        }
    } e {
        order -> error <- validation_error
    }
}

🔧 Development Setup

Prerequisites

Rust 1.70+
Node.js 18+ (for VSCode extension development)

Building from Source

# Clone the repository
git clone https://github.com/susumu-lang/susumu.git
cd susumu

# Build the interpreter
cargo build --release

# Build the LSP server
cargo build --bin susumu-lsp --features lsp --release

# Run tests
cargo test

VSCode Extension Development

cd vscode-extension
npm install
npm run compile
npm run package  # Creates susumu-language-x.x.x.vsix

📚 Documentation

Language Reference: docs/language-reference.md
Examples: examples/
VSCode Extension: vscode-extension/README.md
API Documentation: docs.rs/susumu

🎯 Key Features

Visual Debugging Revolution

Traditional debugging requires mental tracing through code. Susumu's arrow syntax makes data flow immediately visible:

// Bug immediately visible: payment processed before validation
order -> charge_payment -> validate_order  // ❌ Wrong order!

// Correct flow is obvious:
order -> validate_order -> charge_payment  // ✅ Correct

Production Benefits

10x faster debugging: Visual flow eliminates guesswork
Self-documenting code: Arrows ARE the documentation
Instant onboarding: New developers understand flow at a glance
System-level comprehension: Entire pipelines visible in one file

Performance

Sub-millisecond parsing: <1ms for typical programs
Lean binaries: 972KB interpreter, 2.6MB LSP server
Fast compilation: 13.6s clean release build

🛠️ Architecture

Repository Structure

susumu/
├── core/                  # Core Rust interpreter
│   ├── src/
│   │   ├── lexer.rs      # Tokenization
│   │   ├── parser.rs     # AST generation  
│   │   ├── interpreter.rs # Execution engine
│   │   ├── lsp.rs        # Language Server Protocol
│   │   ├── ast.rs        # Abstract Syntax Tree
│   │   ├── builtins.rs   # Built-in functions
│   │   └── main.rs       # CLI entry point
│   ├── Cargo.toml        # Rust package manifest
│   └── tests/            # Integration tests
├── vscode-extension/      # VSCode language support
│   ├── src/              # Extension source
│   ├── syntaxes/         # TextMate grammars
│   └── package.json      # Extension manifest
├── examples/             # Example programs (.susu files)
├── docs/                 # Documentation
├── assets/               # Project assets (logo, etc.)
└── scripts/              # Development and testing scripts

Deployment Targets

Core Language: Cargo package on crates.io
VSCode Extension: VSCode Marketplace
Binaries: GitHub Releases (Linux, macOS, Windows)

🚧 Development Status

✅ Completed (v0.3.0)

Core language interpreter with arrow syntax
Full LSP server with diagnostics, completion, hover
VSCode extension with syntax highlighting
Complex control flow and error handling
Production-ready build pipeline

🔄 In Progress

Assignment parsing edge cases
Module system design
Standard library expansion

📋 Roadmap

v0.4.0: Module system and imports
v0.5.0: Type inference and static analysis
v1.0.0: Production stability and ecosystem
Future: Web framework, frontend compiler, documentation site

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Quick Contribution Steps

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes and add tests
Run the test suite: cargo test
Submit a pull request

Development Priorities

Language Core: Parser improvements, type system
Developer Experience: IDE support, debugging tools
Ecosystem: Standard library, package management
Performance: Optimization, compilation targets

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

🌟 Vision

The core insight: Traditional debugging is detective work. Susumu debugging is watching a movie of your data's journey.

Susumu transforms programming from hidden complexity to visual clarity. Our goal is to make complex data flows as easy to understand as following arrows on a map.

Built with ❤️ by the Susumu community

Website • Documentation • Contributing

susumu 0.1.3