sharp 0.1.0

<p align="center">
<p align="center">
  <img src="Sharp.ico" alt="Sharp Logo" width="128">
</p>

# Sharp Programming Language

A modern, statically-typed language compiled to native code via LLVM. This README is the single source for installation, CLI usage, syntax, types, data structures, and examples — everything a programmer needs to use Sharp.

See the companion engine guide: [README_ENGINE.md](README_ENGINE.md)

## Install or Build

- If published: `cargo install sharp`
- From source (macOS example):
  ```bash
  brew install llvm@18
  export LLVM_SYS_180_PREFIX=/opt/homebrew/opt/llvm
  cargo build --release
  ```

## CLI Usage

```bash
# Compile to LLVM IR
./target/release/sharp program.shrp --emit-llvm

# Run LLVM IR (macOS Homebrew LLVM)
/opt/homebrew/opt/llvm@18/bin/lli program.ll

# Check without codegen
./target/release/sharp program.shrp --check

# Emit object file
./target/release/sharp program.shrp --emit-obj -o program.o

# Emit native binary
./target/release/sharp program.shrp --emit-binary -o program
```

## Language Fundamentals

- Types: `int`, `float`, `bool`, `string`, `void`, `auto`
- Variables with optional types:
  ```sharp
  def main() -> int {
      x: int = 10
      y = 20  // inferred
      return x + y
  }
  ```
- Functions:
  ```sharp
  def add(a: int, b: int) -> int { return a + b }
  ```
- Control Flow: `if`/`elif`/`else`, `while`, `for i in 0 .. N`, `match`
- Operators: arithmetic, comparison, logical, and compound assignments
- Printing: `print(x)` and `println(x)` support `int`, `bool`, and string literals

## Data Structures and Methods

### Structs
```sharp
struct Vector2 { x: float, y: float }

struct GameObject {
    position: Vector2
    health: int
    active: bool
}
```

### Impl Blocks and Methods
```sharp
impl Vector2 {
    def new(x: float, y: float) -> Vector2 {
        return Vector2 { x: x, y: y }
    }
    def magnitude(self) -> float {
        return (self.x * self.x + self.y * self.y).sqrt()
    }
}

impl GameObject {
    def take_damage(mut self, amount: int) { self.health -= amount }
}
```

### Struct Initialization
```sharp
let pos = Vector2 { x: 10.0, y: 20.0 }
let player = GameObject {
    position: Vector2 { x: 0.0, y: 0.0 },
    health: 100,
    active: true
}
```

### Enums
```sharp
enum GameState { Loading, MainMenu, Playing, Paused, GameOver }
enum EntityType { Player, Enemy, NPC, Projectile }
```

### Arrays (type annotations)
```sharp
# [T] or [T; N]
positions: [Vector2; 3]
values: [int]
```

## Syntax Reference (Quick)

```sharp
def f(a: int) -> int { return a }

def main() -> int {
    total: int = 0
    for i in 0 .. 10 { total += i }
    if total > 20 { return total } else { return 0 }
}

struct Health { current: int, max: int }
impl Health {
    def new(max: int) -> Health { return Health { current: max, max: max } }
    def take_damage(mut self, amount: int) { self.current -= amount }
    def is_alive(self) -> bool { return self.current > 0 }
}
```

## Examples

See the examples directory for runnable programs:
- `examples/hello.shrp`
- `examples/simple.shrp`
- `examples/advanced.shrp`
- `examples/structs.shrp`
- `examples/enums.shrp`
- `examples/gameobjects.shrp`
- `examples/gameobject_simple.shrp`

## Roadmap

- Arrays with methods (len/push)
- String utilities and formatting
- Traits and generics
- Pattern matching on enums
- Standard library (math, collections, io)

## Distribution

Sharp availability targets:
- Cargo: `cargo install sharp`
- Homebrew: `brew install sharp`
- Docker: `docker pull yourusername/sharp`
- GitHub Releases: download binaries

## License

MIT License

## Contributing

Contributions welcome. Please open issues or PRs.