Frege/frege

Features

• Source-to-Bytecode Compilers - Translates high-level functional source code into executable JVM bytecode using parallel processing.
• Functional Programming Compilers - Provides a full-scale functional language compiler that transforms high-level syntax into executable bytecode.
• JVM Bytecode Compilers - Translates functional source code into Java bytecode for execution on the Java Virtual Machine.
• JVM Type Mappings - Converts JVM primitives, classes, and interfaces into abstract data types for runtime compatibility.
• Java Library Integrations - Provides direct access to external Java types and methods using a foreign function interface.
• Algebraic Data Types - Provides native support for algebraic data types, including sum and product types for complex data modeling.
• Automatic Type Inferences - Automatically determines the most general types for expressions without requiring explicit annotations.
• Lazy Evaluation - Implements non-strict evaluation, delaying computation of function arguments until their values are required.
• Interactive Read-Eval-Print Loops - Provides an interactive environment for real-time evaluation of expressions and inspection of values.
• Functional Toolchains - Provides a complete functional workflow including an interactive REPL, LSP support, and automated build integration.
• Generic Types - Implements type-safe generic operations across different data types using a system of type classes.
• Haskell-Inspired Compilers - Implements non-strict evaluation, rank polymorphism, and type classes while targeting a virtual machine.
• Java Interoperability - Produces standard JVM class files to make functional logic accessible to any JVM language.
• JVM Functional Languages - Brings purely functional programming and non-strict evaluation to the Java platform.
• Language Bridges - Integrates functional logic with Java libraries through a language bridge and type mapping.
• Higher-Rank Polymorphism - Supports universal quantification in type signatures to allow functions to accept other polymorphic functions.
• Foreign Function Interfaces - Maps Java classes and interfaces into functional types to enable interoperability with external libraries.
• Non-Strict Evaluation - Defers the computation of expressions until required to support infinite data structures.
• Purely Functional Languages - Provides a purely functional language with Haskell-like semantics that compiles to JVM bytecode.
• Static Type Inference - Implements a static type inference system that automatically determines variable types during compilation.
• Strongly-Typed Languages - Uses a rigorous type system with static inference and rank polymorphism to catch errors at compile time.
• Immutable Variable Enforcement - Enforces data immutability by preventing the reassignment of values to existing references.
• Type Classes - Implements generic operations across data types using type classes and automatic instances.
• Purity Annotations - Uses the type system to distinguish pure functions from side-effecting operations, ensuring thread safety.
• Static Purity Enforcement - Uses the type system to strictly separate pure computations from side-effecting operations.
• Build System Integration - Integrates the functional compiler into standard build tools to manage dependencies and lifecycles.
• Build Plugin Integrations - Automates compilation and dependency management via plugins for common build systems.
• Language Server Protocol Integrations - Offers language-aware features like autocomplete and navigation through a standard language server protocol.
• Project-Aware REPLs - Provides a REPL that can execute functions and browse modules with access to project dependencies.
• Instance Type Signatures - Provides explicit type signatures within instance declarations to ensure correctness through compiler checking.
• Build Automation - Provides a dedicated build automation plugin to handle project compilation and library dependencies.
• Incremental Recompilation - Analyzes module dependencies to perform recompilation only when source files or their dependencies change.
• Bytecode Optimizers - Applies function inlining and bytecode refinements to increase the execution speed of the final program.
• Binding Generalization - Controls the typing and optimization of local and top-level bindings to remove monomorphism restrictions.
• Exhaustiveness Analysis - Analyzes code to ensure all possible variants of a type are handled in pattern matches.
• Entry Point Definitions - Allows defining a main entry point for modules to process command line arguments and execute IO actions.
• Immutable Record Updates - Provides built-in mechanisms for non-destructive updates to immutable records.
• Match Guard Filtering - Provides pattern guards using boolean expressions to refine match arm triggers.
• Liberalised Type Synonyms - Allows the right-hand side of a type definition to include universal quantification.
• Module Namespace Mapping - Maps module names to a hierarchical structure that aligns with JVM class naming conventions.
• Module Namespaces - Uses hierarchical naming systems to organize imported modules and prevent identifier collisions.
• Rebindable Syntax - Implements rebindable syntax that translates syntactic sugar using functions currently in scope.
• Isolated Record Fields - Uses data types as namespaces to prevent record field names from polluting the global namespace.
• Type Class Hierarchy Simplification - Enables a single instance declaration to simultaneously satisfy a type and all its super-classes.
• Type Error Diagnostics - Produces detailed diagnostic output from the type checker for specific line ranges to resolve mismatches.
• Type Class Instance Derivations - Automatically generates type class implementations through derived declarations.
• Property-Based Testing - Generates arbitrary test data to verify that logical properties hold true across a wide range of inputs.
• Property Verification - Verifies software invariants hold true for all generated inputs using property-based verification.
• Compilers and Interpreters - JVM-based compiler for Frege.
• Programming Languages - Pure functional programming language in the spirit of Haskell.

Star history