add flix

Author: igr

flix/.gitignore

@@ -0,0 +1,2 @@
+build
+flix.jar

flix/justfile

@@ -0,0 +1,8 @@
+
+# just displays the receipes
+default:
+    @just --list
+
+# runs the project
+run:
+    java -jar flix.jar run

flix/src/Algebraic Data Types.flix

@@ -0,0 +1,19 @@
+
+/// An algebraic data type for shapes.
+enum Shape {
+    case Circle(Int32),          // circle radius
+    case Square(Int32),          // side length
+    case Rectangle(Int32, Int32) // height and width
+}
+
+/// Computes the area of the given shape using
+/// pattern matching and basic arithmetic.
+def area(s: Shape): Int32 = match s {
+    case Shape.Circle(r)       => 3 * (r * r)
+    case Shape.Square(w)       => w * w
+    case Shape.Rectangle(h, w) => h * w
+}
+
+// Computes the area of a 2 by 4.
+// def main(): Unit \ IO =
+//     area(Shape.Rectangle(2, 4)) |> println

flix/src/High Order Functions.flix

@@ -0,0 +1,15 @@
+/// Returns the sum of `x` and `y`.
+def add(x: Int32, y: Int32): Int32 = x + y
+
+/// Returns `x` plus one.
+def inc(x: Int32): Int32 = add(x, 1)
+
+/// Returns a function that applies `f` twice.
+def twice(f: Int32 -> Int32): Int32 -> Int32 = x -> f(f(x))
+
+/// Returns `x` plus two.
+def two(x: Int32): Int32 = twice(inc)(x)
+
+/// Returns 123 plus 4 = 127.
+// def main(): Unit \ IO =
+//     println(twice(two)(123))

flix/src/Lists.flix

@@ -0,0 +1,20 @@
+/// We can easily construct and append lists:
+def l(): List[Int32] =
+    let l1 = 1 :: 2 :: 3 :: Nil;
+    let l2 = 4 :: 5 :: 6 :: Nil;
+    l1 ::: l2
+
+/// We can use pattern matching to take a list apart:
+def length(l: List[a]): Int32 = match l {
+  case Nil     => 0
+  case _ :: xs => 1 + length(xs)
+}
+
+/// The Flix library has extensive support for lists:
+// def main(): Unit \ IO =
+//     let l1 = l();
+//     let l2 = List.intersperse(42, l1);
+//     let l3 = List.map(x -> x :: x :: Nil, l2);
+//     let l4 = List.flatten(l3);
+//     println(l4);
+//     println(length(l4))

flix/src/Parametric Polymorphism.flix

@@ -0,0 +1,23 @@
+/// An algebraic data type for binary trees with leaves.
+enum Tree[a] {
+    case Leaf(a),
+    case Node(Tree[a], Tree[a])
+}
+
+/// A higher-order function that transforms a tree with
+/// elements of type `a` to a tree with elements of type `b`.
+def map(f: a -> b, t: Tree[a]): Tree[b] = match t {
+    case Tree.Leaf(x)    => Tree.Leaf(f(x))
+    case Tree.Node(l, r) => Tree.Node(map(f, l), map(f, r))
+}
+
+/// A function that computes the sum of all leaves in a tree.
+def sum(t: Tree[Int32]): Int32 = match t {
+    case Tree.Leaf(x)    => x
+    case Tree.Node(l, r) => sum(l) + sum(r)
+}
+
+// def main(): Unit \ IO =
+//     let t1 = Tree.Node(Tree.Leaf("Hello"), Tree.Leaf("World"));
+//     let t2 = map(String.length, t1);
+//     println(sum(t2))