Flix (programming language): Difference between revisions

Revision as of 08:57, 19 December 2020

Revision as of 15:39, 20 December 2020

Line 1:

{{about|the Flix programming language|other uses|Flix (disambiguation)}}

{{Orphan|date=December 2020}}

{{Infobox programming language

| name = Flix

Line 9:

| license = [[Apache License 2.0]].<ref name="license-github">{{cite web |url=https://github.com/flix/flix/blob/master/LICENSE.md|title=Apache License 2.0|via=[[GitHub]]}}</ref>

| website = {{URL|https://flix.dev/}}

| influenced_by = [[F_Sharp_F Sharp (programming_languageprogramming language)|F#]], [[Go_Go (programming_languageprogramming language)|Go]], [[Haskell_Haskell (programming_languageprogramming language)|Haskell]], [[OCaml]], [[Scala_Scala (programming_languageprogramming language)|Scala]]

| file_ext = .flix

}}

'''Flix''' is a [[functional programming|functional]], [[imperative programming|imperative]], and [[logic programming|logic]] [[programming language]] developed at [[Aarhus University]], with funding from the [[Danish_Council_for_Independent_ResearchDanish Council for Independent Research|Independent Research Fund Denmark]],<ref>{{cite web |title=Forskningsprojekter |url=https://dff.dk/forskningsprojekter?SearchableText=functional+and+declarative+logic+programming&period%3Alist=all&instrument%3Alist=all&filed_method%3Alist=all |website=Danmarks Frie Forskningsfond |language=da}}</ref>, and by a community of [[open source]] contributors.<ref>{{cite web |title=Flix Authors |url=https://github.com/flix/flix/blob/master/AUTHORS.md |website=GitHub |language=en}}</ref>. The Flix language supports [[algebraic data types]], [[pattern matching]], [[parametric polymorphism]], [[currying]], [[higher-order functions]], [[extensible records]],<ref>{{cite journal |last1=Leijen |first1=Daan |title=Extensible records with scoped labels |journal=Trends in Functional Programming}}</ref>, [[Communicating_sequential_processesCommunicating sequential processes|channel and process-based concurrency]], and [[tail call elimination]]. Two notable features of Flix are its type and effect system<ref name="oopsla2020a">{{cite journal |last1=Madsen |first1=Magnus |last2=van de Pol |first2=Jaco |title=Polymorphic Types and Effects with Boolean Unification |journal=Proceedings of the ACM on Programming Languages |date=13 November 2020 |volume=4 |issue=OOPSLA |pages=1–29 |doi=10.1145/3428222}}</ref> and its support for first-class Datalog constraints.<ref name="oopsla2020b">{{cite journal |last1=Madsen |first1=Magnus |last2=Lhoták |first2=Ondřej |title=Fixpoints for the Masses: Programming with First-class Datalog Constraints |journal=Proceedings of the ACM on Programming Languages |date=13 November 2020 |volume=4 |issue=OOPSLA |pages=125:1–125:28 |doi=10.1145/3428193}}</ref>.

The Flix type and effect system supports [[Hindley–Milner_type_systemHindley–Milner type system|Hindley-Milner]]-style [[type inference]]. The system separates pure and impure code: if an expression is typed as pure then it cannot produce an effect at run-time. Higher-order functions can enforce that they are given pure (or impure) function arguments. The type and effect system supports [[effect polymorphism]]<ref>{{cite journal |last1=Lucassen |first1=J. M. |last2=Gifford |first2=D. K. |title=Polymorphic effect systems |journal=Proceedings of the 15th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages - POPL '88 |date=1988 |pages=47–57 |doi=10.1145/73560.73564|isbn=0897912527 |s2cid=13015611 }}</ref><ref>{{cite journal |last1=Leijen |first1=Daan |title=Koka: Programming with Row Polymorphic Effect Types |journal=Electronic Proceedings in Theoretical Computer Science |date=5 June 2014 |volume=153 |pages=100–126 |doi=10.4204/EPTCS.153.8|arxiv=1406.2061 |s2cid=14902937 }}</ref> which means that the effect of a higher-order function may depend on the effect(s) of its argument(s).

Flix supports [[Datalog]] programs as [[First-class_citizenclass citizen|first-class]] values. A Datalog program value, i.e. a collection of Datalog facts and rules, can be passed to and returned from functions, stored in data structures, and composed with other Datalog program values. The [[minimal model]] of a Datalog program value can be computed and is itself a Datalog program value. In this way, Flix can be viewed as a [[metaprogramming|meta programming]] language for Datalog. Flix supports [[Stratification_Stratification (mathematics)#In_mathematical_logicIn mathematical logic|stratified negation]] and the Flix compiler ensures stratification at compile-time.<ref name="Programming Flix - Fixpoints">{{cite web |title=Programming Flix - Fixpoints |url=https://doc.flix.dev/fixpoints/ |website=flix.dev}}</ref>. Flix also supports an enriched form of Datalog constraints where predicates are given [[Lattice_Lattice (order)|lattice]] semantics.<ref>{{cite journal |last1=Madsen |first1=Magnus |last2=Yee |first2=Ming-Ho |last3=Lhoták |first3=Ondřej |title=From Datalog to flix: a declarative language for fixed points on lattices |journal=ACM SIGPLAN Notices |date=August 2016 |volume=51 |issue=6 |pages=194–208 |doi=10.1145/2980983.2908096}}</ref><ref>{{cite journal |last1=Madsen |first1=Magnus |last2=Lhoták |first2=Ondřej |title=Safe and sound program analysis with Flix |journal=Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis - ISSTA 2018 |date=2018 |pages=38–48 |doi=10.1145/3213846.3213847|isbn=9781450356992 |s2cid=49427988 }}</ref><ref>{{cite journal |last1=Keidel |first1=Sven |last2=Erdweg |first2=Sebastian |title=Sound and reusable components for abstract interpretation |journal=Proceedings of the ACM on Programming Languages |date=10 October 2019 |volume=3 |issue=OOPSLA |pages=1–28 |doi=10.1145/3360602|s2cid=203631644 }}</ref><ref>{{cite book |last1=Gong |first1=Qing |title=Extending Parallel Datalog with Lattice |publisher=Pennsylvania State University}}</ref>.

== Overview ==

Flix is a [[programming language]] in the [[Standard ML|ML]]-family of languages. Its type and effect system is based on [[Hindley–Milner_type_systemHindley–Milner type system|Hindley-Milner]] with several extensions, including [[row polymorphism]] and [[Unification_Unification (computer_sciencecomputer science)#E-unification|Boolean unification]]. The syntax of Flix is inspired by [[Scala]] and uses short [[Reserved_wordReserved word|keywords]] and [[curly braces]]. Flix supports [[Uniform_Function_Call_SyntaxUniform Function Call Syntax|uniform function call syntax]] which allows a function call <code>f(x, y, z)</code> to be written as <code>x.f(y, z)</code>. The concurrency model of Flix is inspired by [[Go_Go (programming_languageprogramming language)|Go]] and based on [[Communicating_sequential_processesCommunicating sequential processes|channels and processes]]. A process is a light-weight thread that does not share (mutable) memory with another process. Processes communicate over channels which are bounded or unbounded queues of immutable messages.

While many programming languages support a mixture of functional and imperative programming, the Flix type and effect system tracks the purity of every expression making it possible to write parts of a Flix program in a [[Purely_functional_programmingPurely functional programming|purely functional style]] with purity enforced by the effect system.

Flix programs compiles to [[JVM bytecode]] and are executable on the [[Java Virtual Machine]] (JVM).<ref>{{cite book |last1=Yee |first1=Ming-Ho |title=Implementing a Functional Language for Flix |date=2016-09-15 |publisher=University of Waterloo}}</ref>.

The Flix compiler performs [[whole program compilation]], eliminates polymorphism via [[monomorphization]],<ref>{{cite web |title=Monomorphise |url=http://mlton.org/Monomorphise |website=mlton.org}}</ref>, and uses [[tree shaking]] to remove [[unreachable code]].

Monomorphization avoids [[Value_type_and_reference_typeValue type and reference type|boxing]] of primitive values at the cost of longer compilation times and larger executable binaries. Flix has some support for interoperability with programs written in [[Java programming language|Java]].<ref>{{cite web |title=Programming Flix - Interoperability |url=https://doc.flix.dev/interoperability/ |website=flix.dev}}</ref>.

Flix supports [[tail call elimination]] which ensures that function calls in tail position never consume stack space and hence cannot cause the call stack to overflow.<ref>{{cite journal |last1=Madsen |first1=Magnus |last2=Zarifi |first2=Ramin |last3=Lhoták |first3=Ondřej |title=Tail call elimination and data representation for functional languages on the Java virtual machine |journal=Proceedings of the 27th International Conference on Compiler Construction - CC 2018 |date=2018 |pages=139–150 |doi=10.1145/3178372.3179499|isbn=9781450356442 |s2cid=3432962 }}</ref>. Since the [[Java_bytecode_instruction_listingsJava bytecode instruction listings|JVM instruction set]] lacks explicit support for tail calls, such calls are emulated using a form of reusable stack frames.<ref>{{cite journal |last1=Tauber |first1=Tomáš |last2=Bi |first2=Xuan |last3=Shi |first3=Zhiyuan |last4=Zhang |first4=Weixin |last5=Li |first5=Huang |last6=Zhang |first6=Zhenrui |last7=Oliveira |first7=Bruno C. D. S. |title=Memory-Efficient Tail Calls in the JVM with Imperative Functional Objects |journal=Programming Languages and Systems |series=Lecture Notes in Computer Science |date=2015 |volume=9458 |pages=11–28 |doi=10.1007/978-3-319-26529-2_2|isbn=978-3-319-26528-5 }}</ref>. Support for tail call elimination is important since all iteration in Flix is expressed through [[recursion]].

The Flix compiler disallows most forms of unused or redundant code, including: unused local variables, unused functions, unused formal parameters, unused type parameters, and unused type declarations, such unused constructs are reported as compiler errors.<ref>{{cite web |title=Redundancies as Compile-Time Errors |url=https://flix.dev/blog/redundancies-as-compile-time-errors/ |website=flix.dev}}</ref>. [[Variable shadowing]] is also disallowed. The stated rationale is that unused or redundant code is often correlated with erroneous code<ref>{{cite journal |last1=Engler |first1=D. |title=Using redundancies to find errors |journal=IEEE Transactions on Software Engineering |date=October 2003 |volume=29 |issue=10 |pages=915–928 |doi=10.1109/TSE.2003.1237172}}</ref>

A [[Visual Studio Code]] extension for Flix is available.<ref>{{cite web |title=flix - Visual Studio Marketplace |url=https://marketplace.visualstudio.com/items?itemName=flix.flix |website=marketplace.visualstudio.com |language=en-us}}</ref>. The extension is based on the [[Language Server Protocol]], a common interface between [[Integrated_development_environmentIntegrated development environment|IDEs]] and [[compilers]] being developed by [[Microsoft]].

Flix is [[Open-source_softwaresource software|open source software]] available under the [[Apache_LicenseApache License|Apache 2.0 License]].

== Examples ==

Line 40:

=== Hello World ===

The following program prints "[["Hello,_World World!"_program program|Hello World!]]" when compiled and executed:

<syntaxhighlight lang="Scala">

Line 91:

=== Parametric Polymorphism ===

The following program fragment illustrates a [[Parametric_polymorphismParametric polymorphism|polymorphic function]] that maps a function <code>f: a -> b</code> over a list of elements of type <code>a</code> returning a list of elements of type <code>b</code>:

<syntaxhighlight lang="Scala">

Line 100:

</syntaxhighlight>

The <code>map</code> function recursively traverses the list <code>l</code> and applies <code>f</code> to each element constructing a new list.

Flix supports type parameter elision hence it is not required that the type parameters <code>a</code> and <code>b</code> are explicitly introduced.

Line 106:

=== Extensible Records ===

The following program fragment shows how to construct a [[Record_Record (computer_sciencecomputer science)|record]] with two fields <code>x</code> and <code>y</code>:

<syntaxhighlight lang="Scala">

Line 130:

=== Polymorphic Effects ===

The Flix type and effect system separates pure and impure expressions.<ref name="oopsla2020a"/><ref>{{cite web |title=Programming Flix - Effects |url=https://doc.flix.dev/effects/ |website=flix.dev}}</ref><ref>{{cite web|title=Rust Internals - Flix Polymorphic Effects|url=https://internals.rust-lang.org/t/flix-polymorphic-effects/13395}}</ref>. A pure expression is guaranteed to be [[Referential_transparencyReferential transparency|referentially transparent]]. A pure function always returns the same value when given the same argument(s) and cannot have any (observable) side-effects.

For example, the following expression is of type <code>Int</code> and is <code>Pure</code>:

Line 184:

A higher-order function that takes multiple function arguments may combine their effects.

For example, the standard library definition of forward [[Function_composition_Function composition (computer_sciencecomputer science)|function composition]] <code>&gt;&gt;</code> is pure if both its function arguments are pure:<ref>{{cite web |title=The Flix API - Prelude |url=https://api.flix.dev/ |website=api.flix.dev}}</ref>

<syntaxhighlight lang="Scala">

Line 226:

=== First-class Datalog Constraints ===

Flix supports [[Datalog]] programs as first-class values.<ref name="oopsla2020b"/>.<ref>{{cite web |titlename="Programming Flix - Fixpoints |url=https:"//doc.flix.dev/fixpoints/ |website=flix.dev}}</ref><ref>{{cite journal |last1=Arntzenius |first1=Michael |last2=Krishnaswami |first2=Neel |title=Seminaïve evaluation for a higher-order functional language |journal=Proceedings of the ACM on Programming Languages |date=January 2020 |volume=4 |issue=POPL |pages=1–28 |doi=10.1145/3371090|s2cid=208305062 }}</ref>. A Datalog program is a logic program that consists of a collection of unordered [[Fact|factsfact]]s and [[Horn_clauseHorn clause|rules]]. Together, the facts and rules imply a [[minimal model]], a unique solution to any Datalog program. In Flix, Datalog program values can be passed to and returned from functions, stored in data structures, composed with other Datalog program values, and solved. The solution to a Datalog program (the minimal model) is itself a Datalog program. Thus, it is possible to construct pipelines of Datalog programs where the solution, i.e. "output", of one Datalog program becomes the "input" to another Datalog program.

The following edge facts define a graph:

Line 249:

</syntaxhighlight>

In Flix, Datalog programs are values. The above program can be [[Domain-specific_languagespecific language|embedded]] in Flix as follows:

<syntaxhighlight lang="Scala">

Line 316:

==== Stratified Negation ====

The Flix compiler ensures that every Datalog program value constructed at run-time is [[Stratification_Stratification (mathematics)#In_mathematical_logicIn mathematical logic|stratified]]. Stratification is important because it guarantees the existence of a unique minimal model in the presence of negation. Intuitively, a Datalog program is stratified if there is no recursion through negation,<ref>{{cite book |last1=Minker |first1=Jack |title=Foundations of deductive databases and logic programming |publisher=Morgan Kaufmann}}</ref>, i.e. a predicate cannot depend negatively on itself. Given a Datalog program, a [[cycle detection]] algorithm can be used to determine if it is stratified.

For example, the following Flix program contains an expression that cannot be stratified:

Line 327:

</syntaxhighlight>

because the last expression constructs a Datalog program value whose [[precedence_graph_precedence graph (Datalog)|precedence graph]] contains a negative cycle: the <code>Bachelor</code> predicate negatively depends on the <code>Husband</code> predicate which in turn (positively) depends on the <code>Bachelor</code> predicate.

The Flix compiler computes the precedence graph for every Datalog program valued expression and determines its stratification at compile-time. If an expression is not stratified, the program is rejected by the compiler.

The stratification is sound, but conservative. For example, the following program is [[Type_systemType system#Static_type_checkingStatic type checking|unfairly rejected]]:

<syntaxhighlight lang="Scala">

Line 345:

== Design Philosophy ==

Flix is designed around a collection of stated principles:<ref>{{cite web |title=The Flix Programming Language - Principles |url=https://flix.dev/principles/ |website=flix.dev |accessdate=28 August 2020}}</ref>:

* [[Expression-oriented_programming_languageoriented programming language|Everything is an expression]]. Most Flix constructs, except for top-level declarations, are expressions that evaluate to values.

* [[Closed-world assumption]]. The Flix compiler assumes that the source code of the entire program is available at compile-time.

* Pure and impure code is separated. The type and effect system precisely captures whether an expression may produce an effect<ref>{{cite web |title=Taming Impurity with Polymorphic Effects |url=https://flix.dev/blog/taming-impurity-with-polymorphic-effects/ |website=flix.dev}}</ref>

Line 354:

The principles also list several programming language features that have been deliberately omitted. In particular, Flix lacks support for:

* [[Null_pointerNull pointer|Null values]]. Instead the use of the [[Option_typeOption type|Option]] data type is recommended.

* [[Type_conversionType conversion|Implicit coercions]]. Instead type conversions must be performed explicitly by the programmer.

* [[Reflection_Reflection (computer_programmingcomputer programming)|Reflection]]. The programmer cannot reflect over the structure of the program at run-time.

== References ==

Line 362:

{{reflist}}

== External Linkslinks ==

* [https://flix.dev/ The Official Website]

Line 371:

[[Category:Procedural programming languages]]

[[Category:Functional languages]]

[[Category:Procedural programming languages]]

[[Category:Logic programming languages]]

[[Category:High-level programming languages]]

[[Category:High-level programming languages]]