diff --git a/src/App.css b/src/App.css index 8043582..e592428 100644 --- a/src/App.css +++ b/src/App.css @@ -39,7 +39,6 @@ p:last-child { .motto { font-size: 1.35rem; - color: #17a2b8; } .editor-output h5 { diff --git a/src/page/Home.js b/src/page/Home.js index f893977..65f248d 100644 --- a/src/page/Home.js +++ b/src/page/Home.js @@ -47,48 +47,50 @@ class Home extends Component { -

The Flix Programming Language

+

Flix —

-

Next-generation reliable, safe, concise, and functional-first programming - language.

+

+ A powerful effect-oriented programming language +

- Flix is a principled functional, imperative, and logic programming language - developed at Aarhus University, at the University of Waterloo, and by a community of Aarhus University and by a community of open source contributors.

-

Why Flix?

+

Why effect-oriented? And why Flix?

- Flix aims to offer a unique combination of - features that no other programming language offers, including: algebraic - data types and pattern matching (like Haskell, OCaml), extensible records (like Elm), traits (type classes) (like Haskell, Rust), higher-kinded types (like Haskell), typematch (like Scala), type inference (like Haskell, OCaml), structured channel and process-based concurrency (like - Go), and compilation to JVM bytecode (like Scala). + Why Effects? Effect systems represent the next major + evolution in statically typed programming languages. By explicitly modeling side effects, + effect-oriented programming enforces modularity and helps program reasoning. User-defined + effects and handlers allow programmers to implement their own control structures.

- Flix also supports several unique features, - including: a polymorphic effect system, region-based local mutation, purity reflection, and first-class Datalog constraints. + Why Flix? We claim that of all the upcoming + effect-oriented programming languages, Flix offers the most complete language implementation, the most extensive standard library, the most detailed documentation, and the best tool support.

+

+ Moreover, Flix builds on proven programming language technology, including: algebraic data types and pattern matching, extensible records, traits, higher-kinded types, associated types and effects, structured concurrency, + and more. +

- + @@ -229,6 +231,60 @@ def map(f: a -> b \\ ef, l: List[a]): List[b] \\ ef = + + + + +

Algebraic Effects

 + +

+ Flix supports algebraic effects, i.e. user-defined effects and handlers. + In particular, Flix supports multi-shot resumptions. +

+ +

+ Effect-oriented programming, with algebraic effects, allow programmers to + write pure functions modulo effects. Effect handlers enable program reasoning, + modularity, and testability. +

+ +

+ For example, the program on the right expresses a greeting function + that is pure modulo the current time of the day. In main we call + the function and handle the HourOfDay effect by getting the + real-world time from Java's LocalDateTime. +

+ + + + + + + {`import java.time.LocalDateTime + +eff HourOfDay { + def getCurrentHour(): Int32 +} + +def greeting(): String \\ {HourOfDay} = + let h = HourOfDay.getCurrentHour(); + if (h <= 12) "Good morning" + else if (h <= 18) "Good afternoon" + else "Good evening" + +def main(): Unit \\ IO = + run { + println(greeting()) + } with HourOfDay { + def getCurrentHour(_, resume) = + let dt = LocalDateTime.now(); + resume(dt.getHour()) + } +`} + + + + @@ -802,26 +858,22 @@ let r = query p select (c, d) from ReadyDate(c; d)
  • first-class functions
  • extensible records
  • parametric polymorphism
    • -
  • traits (type classes)
    • +
  • traits (i.e. type classes)
  • higher-kinded types
    • -
  • light-weight polymorphic effects
    • -
  • type aliases
    • -
  • Hindley-Milner type inference
    • +
  • associated types and effects
      • +
    • effect polymorphism + subeffecting
      • +
    • purity reflection
    • CSP-style concurrency
    • buffered & unbuffered channels
    • first-class datalog constraints
      • -
    • polymorphic datalog predicates
      • -
    • constraints with lattice semantics
      • -
    • stratified negation
      • -
    • interoperability with Java
      • +
    • seamless interoperability with Java
    • unboxed primitives
    • keyword-based syntax
      • -
    • redundancy checks
    @@ -832,11 +884,9 @@ let r = query p select (c, d) from ReadyDate(c; d)
  • expressions holes
  • compilation to JVM bytecode
  • full tail call elimination
    • -
  • core standard library
    • +
  • resilient compiler architecture
  • parallel compiler architecture
  • human friendly errors
    • -
  • interactive mode
    • -
  • Visual Studio Code support
    •  @@ -923,11 +973,11 @@ let r = query p select (c, d) from ReadyDate(c; d) Throughput (entire compiler): - 41,700 lines/sec + 52,800 lines/sec Throughput (frontend only): - 93,000 lines/sec + 95,500 lines/sec @@ -1182,19 +1232,19 @@ let r = query p select (c, d) from ReadyDate(c; d) - + - + - + - +
    3,800+4,900+ Merged Pull Requests (PRs)
    2,500+3,100+ Resolved Issues (Tickets)
    60+70+ Contributors
    244,000+272,000+ Lines in Compiler Codebase