Typhon-Language 0.1.2

Typhon programming language

Typhon

Typhon is a modernized syntax sugar for Python, designed to improve developer experience with features like static typing, brace-based scoping, and expressive functional programming capabilities.

• GitHub repository: Typhon
• PyPI package: Typhon-Language
• VSCode extension: Typhon Language Support from GitHub Repository

Getting Started

Install Typhon via pip:

pip install typhon-language

Run Typhon from the command line:

typhon --help

Create a simple Typhon program in hello.typh:

def main() {
    print("Hello, Typhon!")
}
main()

Run the program:

typhon run hello.typh

Or run directly using uvx:

uvx --from typhon-language typhon run hello.typh

Design Concepts

Typhon is built on three core pillars:

1. Safety: As expected in modern programming languages, Typhon enforces safety through static typing, lexical scopes, immutable-by-default variables (let), and null safety features (?., ??, ?(), ?[]).
2. Expressiveness: Expression-oriented design with functional programming features. Control comprehension forms for if, match, try, and so on enable concise, value-returning expressions. Function literals, placeholders and pipe operators facilitate clean and readable code.
3. Python Interoperability: Typhon compiles directly to Python, allowing you to use the vast ecosystem of Python libraries seamlessly while enjoying a modern syntax.

Documentation

For a complete guide to the language, please visit the Typhon Reference Manual.

Quick Links

• Lexical Structure (Comments, Keywords, Delimiters)
• Types
• Variables
• Expressions
• Statements
• Definitions (Functions, Classes, Modules)
• Removed Features

Syntax Changes from Python

Typhon retains most of Python's semantics but introduces significant syntax changes.

Main Changes

• Brace Scoping: Typhon uses { ... } for blocks, replacing indentation-based scoping. Both ; and line breaks can also act as delimiters. See Lexical Structure for more details.
• Static Typing: Type checking is enforced at compile time. Currently powered by basedpyright type checker.
• Declarations: Variables must be declared with let (immutable) or var (mutable). See Variables.

Syntax Extensions

• Null Safety: ?., ??, ?(), ?[] operators. See Null Safety.
• Function literals: Unrestricted function literals with (x) => { return x + 1 } syntax, with totally the same capability as normal functions. SeeFunction literals.
• Pipe Operator: x |> f for function chaining. See Pipe Operator.
• Placeholders: _ for concise anonymous functions (e.g., _ + 1). See Placeholders.
• Control Comprehensions: Control statements as expressions (e.g., (if (c) x else y)). All if/while/for/let/try/with/match are supported as comprehension. See Comprehensions.
• Pattern Matching: Enhanced match, if-let, and let-else statements. See Control Flow.
• self Keyword: self is a keyword and is not explicitly declared in method signatures. See Classes.
• Data Records: Anonymous immutable structs {|x=1|}. See Types.
• Block Comments: #( ... )# allows nested comments.

Detailed Design Changes

• Logical Operators: &&, ||, ! replace and, or, not (though Python keywords are still reserved).
• Const Parameters: Function parameters are immutable by default.
• Line Breaks: Stricter rules for line continuations. See Lexical Structure.

Syntax Restrictions

Some Python features are removed to enforce safety and clarity. See Removed Features.

• No del, global, nonlocal.
• No wildcard imports.
• No chained assignments (a = b = c).
• No control statements inside class bodies.

Usage

Typhon can be run directly or translated to Python.

.typh files are Typhon source files. In directory mode, all .typh files are processed.

Note Typhon uses .typhon directory in source paths to place translated Python files and caches.

Run

Run a Typhon source file or directory.

typhon run <source> [args...]

Translate

Translate Typhon code to Python.

typhon translate <source> [-o output_dir]

Type Check

Run type checking on Typhon code.

typhon type_check <source>

Future Plans

See Future Plans for planned features like compile-time controls (static if) and known limitations.

Influenced By

Typhon draws inspiration from several modern programming languages:

• Python
• TypeScript
• Swift
• Rust
• Scala
• F#