flix/programming-flix

A tutorial for programming in Flix

Flix is a statically typed functional, imperative, and logic programming language.

We refer you to the official Flix website (flix.dev) for more information about Flix.

Example

Building

See docs/BUILD.md.

License

Flix is available under the Apache 2.0 license.

Sponsors

We kindly thank EJ Technologies for providing us with JProfiler and JetBrains for providing us with IntelliJ IDEA.

programming-flix's Issues

Add section on labelled arguments to record section

Document Lazy

(but maybe not before we decide if lazy should be pure/impure)

Add a section on basics

• let-bindings
• how to run the program
• if-then-else
• how to exit the program
• statement expressions are separated by semicolons

Add Documentation about Tuples to Data Types

Insecure WebSocket endpoint

The page at https://flix.github.io/programming-flix/ can't be loaded:

Mixed Content: The page at 'https://flix.github.io/programming-flix/' was loaded over HTTPS, but attempted to connect to the insecure WebSocket endpoint 'ws://flix.aau.dk:8080/'. This request has been blocked; this endpoint must be available over WSS.

Failed to execute the Introduction code.

Second paragraph of the introduction page
I tried to run the code that introduces polymorphic records in the playground, but failed.

It would be sad if an error occurred in the Introduction code, so I want to worked properly.

And if someone can give me some pointers on how to fix it, I'd like to try it.

Document package manager

Document `install` command

Rewrite `Effects`'s paragraph with impure function argument

The page Effects has this paragraph which explains "A higher-order function can also require that a function is impure.". But the syntax ~> used in this example

def foreach(f: a ~> Unit, l: List[a]): Unit & Impure

is not allowed anymore. And the paragraph should be rewritten.

Add a "Beginners Guide" to answer common problems

Add Documentation for Let*

`Using Flix to Solve Constraints on Lattices` example in `Fixpoints`

I cannot get the example to work, when I copy it into VS code.

Fixpoint lattice description doesn't match code

The lattice example code from the fixpoints doc ends with:

lat A(x: String, s: Sign)
lat B(x: String, s: Sign)
lat R(x: String, s: Sign)

A("a"; Pos).
B("a"; Top).
A("b"; Neg).

R("c"; s) :- A("a"; s).
R("c"; s) :- A("b"; s).
R("d"; s) :- A(x; s), B(x; s).

which it describes as

Finally, the program defines three predicate symbols A, B, and C with lattice interpretations. The program then defines three facts and three rules. The two first rules require that in the fact R("c", s) the s element must be at least the least upper bound of s1 and s2 for any facts A("a", s1) and A("b", s2). Thus we compute the fact R("c", Top). The last rule, on the other hand requires that in the fact R("d", s) s must be the greatest lower bound of s1 and s2 for any facts A(x, s1) and B(x, s2). Thus we compute the fact R("d", Pos).

...which leaves me somewhat confused. It could be my own misunderstanding, but I think the explanation does not match the code sample:

• There doesn't seem to be any symbol C
• The code sample does not use s1 and s2 like the explanation, but perhaps I am just not following the concept... 😅

Rewrite `Interoperability` to include return types of imports

This sentence is out-of-date, since we know always specify return types of java imports.

The Interoperability page should be updated to let the user know to specify the return type and effect of imports.

In the summary the return types are not included either.

Add Documentation about References to Data Types

Update documentation

• Introduction
• Functions
• Data Types
• Lists
• Records
• References
• Arrays
• Namespaces
• Concurrency
• Effects
  - #62
• Fixpoints
  - #67
• Interoperability
  - #63
  - #64
• Build & Packages
• Tips and Tricks
  - #65
  - #66

Update getting started gif

• As before, but also check the java version in a terminal java -version.
• Also show of more features?

Fix `let*` example on page `Tips & Tricks`

The example with let* syntax is not working.

use Option.flatMap;
let* o1 = Some(21);
let* o2 = Some(42);
Some(x + y) 

Use keywords for boolean ops

Instead of the old || and &&

THIS REPO IS BEING PHASED OUT

The new repo is at: https://github.com/flix/book/

Document type classes

Tracking ticket to list the features and details that should be covered.

InstanceErrors:

• OverlappingInstances
• MismatchedSignatures
• MissingImplementation
• ExtraneousDefinition
• DuplicateTypeVariableOccurrence
• ComplexInstanceType
• OrphanInstance
• MissingSuperClassInstance
• LawlessSuperClass
• UnlawfulSignature
• IllegalOverride
• UnmarkedOverride

ResolutionErrors:

• SealedClass

WeederErrors:

• IllegalPrivateDeclaration
• IllegalTypeConstraintParameter

NameErrors:

• IllegalSignature

Upgrade dependencies

Amazing how JavaScript breaks all the time :S

Non-existing `Unsafe.println(x)`

The example in this paragraph

def sum(x: Int32, y: Int32): Int32 = 
    let _ = Unsafe.println(x);
    let _ = Unsafe.println(y);
    x + y

does not work. It looks like there is an unsafePrint in Solver.flix.

Add info on how to include Java libraries

The question has come up a couple times on Gitter.

Add Documentation about Arrays to Data Types

Consider using more pictures for the intro

To guide the user in the beginning
see https://github.com/finnpedersenkazes/flix-feedback

Include singleton enum on Tips and Tricks page

Description from Magnus:

Just to say something like if you have an enum with a single case:

enum USD {
  case USD(Int32)
}

you can simplify it to enum USD(Int32) instead.

Something like that.

Rewrite `Interoperability`'s `Invoking Static Methods` paragraph

We have changed the syntax of importing static methods from

import java.lang.String:valueOf(Bool);
valueOf(true)

to

import static java.lang.String.valueOf(Bool);
valueOf(true)

The paragraph can be found here.

Document how to use external jars

Add Documentation for LambdaMatch