fusion-lang 0.0.1.alpha2 → 0.0.2

data/stdlib/matrix/identity.fsn

@@ -0,0 +1,6 @@
+# The n-by-n identity matrix for a positive integer n.
+(
+  n ? (i ? @Integer => i > 0) =>
+    n | @range |: (r => n | @range |: (c => (r == c) | (true => 1, false => 0))),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/identity", "status": 0, "input": x, "expected": ["_ ? (n ? @Integer => n > 0)"]}
+)

data/stdlib/matrix/invert.fsn

@@ -0,0 +1,26 @@
+# Inverse of a square matrix with a non-zero determinant: the adjugate scaled
+# by 1/determinant. Adjugate entry (i, j) is (-1)^(i+j) * determinant(minor(j, i)).
+(
+  m ? (sq ? @Matrix => sq | @dimensions | (d => d.rows == d.columns)) =>
+    m | @determinant | (det => (det ?? 0) | (
+      0 => !{"kind": "math_error", "origin": "stdlib", "operation": "@matrix/invert", "status": 0, "input": m, "message": "singular matrix (determinant 0)"},
+      _ => m | (
+        [[a]] => [[a | @@OP.invert]],
+        _ =>
+          [
+            det | @@OP.invert,
+            m | @dimensions | (d =>
+              d.rows | @range |: (i =>
+                d.columns | @range |: (j =>
+                  [
+                    [-1, [i, j] | @@OP.sum] | @math.pow,
+                    [m, j, i] | @minor | @determinant,
+                  ] | @@OP.product
+                )
+              )
+            ),
+          ] | @scale
+      )
+    )),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/invert", "status": 0, "input": x, "expected": ["_ ? (sq ? @matrix/Matrix => sq | @matrix/dimensions | (d => d.rows == d.columns))"]}
+)

data/stdlib/matrix/minor.fsn

@@ -0,0 +1,15 @@
+# The minor of a matrix: drop row r and column c. Input: [matrix, r, c]. The
+# matrix must be at least 2 by 2, so the minor is a matrix again.
+(
+  [m, r, c] ? ([x ? @Matrix, row ? @Integer, col ? @Integer] =>
+      x | @dimensions | (d =>
+        row >= 0 && row < d.rows &&
+        col >= 0 && col < d.columns &&
+        d.rows >= 2 && d.columns >= 2)) =>
+    m | @dimensions | (d =>
+      d.rows | @range |? (k => ~(k == r)) |: (k =>
+        d.columns | @range |? (l => ~(l == c)) |: (l => m[k][l])
+      )
+    ),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/minor", "status": 0, "input": x, "expected": ["_ ? ([m ? @matrix/Matrix, r ? @Integer, c ? @Integer] => m | @matrix/dimensions | (d => r >= 0 && r < d.rows && c >= 0 && c < d.columns && d.rows >= 2 && d.columns >= 2))"]}
+)

data/stdlib/matrix/multiply.fsn

@@ -0,0 +1,10 @@
+# Matrix multiplication of a pair [a, b]: a's column count must equal b's row
+# count. Entry (i, j) is the dot product of a's row i and b's column j — the
+# columns are the rows of the transposed b, computed once.
+(
+  [a, b] ? ([x ? @Matrix, y ? @Matrix] => (x | @dimensions).columns == (y | @dimensions).rows) =>
+    b | @transpose | (columns =>
+      a |: (row => columns |: (column => [row, column] | @vector/dot))
+    ),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/multiply", "status": 0, "input": x, "expected": ["_ ? ([x ? @matrix/Matrix, y ? @matrix/Matrix] => (x | @matrix/dimensions).columns == (y | @matrix/dimensions).rows)"]}
+)

data/stdlib/matrix/negate.fsn

@@ -0,0 +1,5 @@
+# Negate a matrix elementwise. Built on @matrix/scale.
+(
+  m ? @Matrix => [-1, m] | @scale,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/negate", "status": 0, "input": x, "expected": ["_ ? @matrix/Matrix"]}
+)

data/stdlib/matrix/product.fsn

@@ -0,0 +1,11 @@
+# Product of a non-empty array of matrices, folded left through
+# @matrix/multiply. A dimension mismatch surfaces as @matrix/multiply's error.
+(
+  matrices ? (ms => [
+      ms | @Array,
+      ms | @size > 0,
+      {"c": ms, "f": @Matrix} | @all,
+    ] | @OP.and | @safe) =>
+    matrices |+ @multiply,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/product", "status": 0, "input": x, "expected": ["_ ? (ms => [ms | @Array, ms | @size > 0, {\"c\": ms, \"f\": @matrix/Matrix} | @all] | @OP.and | @safe)"]}
+)

data/stdlib/matrix/rotate.fsn

@@ -0,0 +1,10 @@
+# Rotate a 2x2 matrix by an angle in radians: the rotation matrix
+# [[cos, -sin], [sin, cos]] multiplied onto it. Input: [angle, matrix].
+(
+  [angle ? @Number, [[a ? @Number, b ? @Number], [c ? @Number, d ? @Number]]] =>
+    [
+      [[angle | @math.cos, angle | @math.sin | @@OP.negate], [angle | @math.sin, angle | @math.cos]],
+      [[a, b], [c, d]],
+    ] | @multiply,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/rotate", "status": 0, "input": x, "expected": ["[_ ? @Number, [[_ ? @Number, _ ? @Number], [_ ? @Number, _ ? @Number]]]"]}
+)

data/stdlib/matrix/row.fsn

@@ -0,0 +1,6 @@
+# Extract the i-th (0-based) row of a matrix as a vector. Input: [matrix, index].
+(
+  [m, i] ? ([x ? @Matrix, n ? @Integer] => n >= 0 && n < (x | @dimensions).rows) =>
+    m[i],
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/row", "status": 0, "input": x, "expected": ["_ ? ([m ? @matrix/Matrix, i ? @Integer] => i >= 0 && i < (m | @matrix/dimensions).rows)"]}
+)

data/stdlib/matrix/scale.fsn

@@ -0,0 +1,6 @@
+# Scale a matrix elementwise by a single number: each row scaled as a vector.
+# Input: [number, matrix].
+(
+  [s ? @Number, m ? @Matrix] => m |: (row => [s, row] | @vector/scale),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/scale", "status": 0, "input": x, "expected": ["[_ ? @Number, _ ? @matrix/Matrix]"]}
+)

data/stdlib/matrix/subtract.fsn

@@ -0,0 +1,7 @@
+# Subtract the second matrix from the first, elementwise: a + (-1 * b).
+# Input: [a, b].
+(
+  [a, b] ? ([x ? @Matrix, y ? @Matrix] => [x, y] |: @dimensions | @OP.equal) =>
+    [a, [-1, b] | @scale] | @add,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/subtract", "status": 0, "input": x, "expected": ["_ ? ([a ? @matrix/Matrix, b ? @matrix/Matrix] => [a, b] |: @matrix/dimensions | @OP.equal)"]}
+)

data/stdlib/matrix/sum.fsn

@@ -0,0 +1,14 @@
+# Elementwise sum of a non-empty array of equally sized matrices: a reduce
+# over @matrix/add. The guard is a flat conditions array ending in @safe: a
+# condition that errors (e.g. @dimensions of a non-matrix) collapses the array
+# into that error, @safe turns it into false, and the clause just doesn't match.
+(
+  matrices ? (ms => [
+      ms | @Array,
+      ms | @size > 0,
+      {"c": ms, "f": @Matrix} | @all,
+      ms |: @dimensions | @OP.equal,
+    ] | @OP.and | @safe) =>
+    matrices |+ @add,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/sum", "status": 0, "input": x, "expected": ["_ ? (ms => [ms | @Array, ms | @size > 0, {\"c\": ms, \"f\": @matrix/Matrix} | @all, ms |: @matrix/dimensions | @OP.equal] | @OP.and | @safe)"]}
+)

data/stdlib/matrix/transpose.fsn

@@ -0,0 +1,5 @@
+# Transpose a matrix: its columns become its rows.
+(
+  m ? @Matrix => (m | @dimensions).columns | @range |: (j => [m, j] | @column),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/transpose", "status": 0, "input": x, "expected": ["_ ? @matrix/Matrix"]}
+)

data/stdlib/range.fsn

@@ -1,5 +1,5 @@
 (
   0 => [],
-  n ? (m ? @Integer => [-1, m] | @lessThan, _ => false) => [...([n, 1] | @subtract | @range), [n, 1] | @subtract],
-  x => !{"kind": "type_error", "location": "stdlib range.fsn", "operation": "range", "input": x | @sanitize, "message": "expected a non-negative integer"}
+  n ? (m ? @Integer => [m, 0] | @OP.compare | @OP.gt) => [...([n, -1] | @OP.sum | @), [n, -1] | @OP.sum],
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@range", "status": 0, "input": x, "expected": ["_ ? (m ? @Integer => [m, 0] | @OP.compare | @OP.gte)"]}
 )

data/stdlib/reduce.fsn

@@ -0,0 +1,8 @@
+# Left fold over a NON-EMPTY array with no seed: combine the first two elements
+# with f, then fold that result with the rest. Input: {"f": binaryFn, "c": array}.
+# `f` receives the pair [acc, element]. An empty list is an error.
+(
+  {"f": _ ? @Function, "c": [x]} => x,
+  {"f": f ? @Function, "c": [x, y, ...rest]} => {"f": f, "c": [[x, y] | f, ...rest]} | @,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@reduce", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": [_, ...]}"]}
+)

data/stdlib/safe.fsn

@@ -0,0 +1,7 @@
+# Catch any error into false; pass every regular value through unchanged.
+# Appended to a guard condition (`cond | @safe`), an erroring check reads as
+# "no match" instead of propagating out of the guard.
+(
+  ! => false,
+  v => v
+)

data/stdlib/sanitize.fsn

@@ -5,8 +5,7 @@
 # returned unchanged.
 (
   v ? @Function => "<function>",
-  v ? @NonFinite => [["<", v | @toString] | @concat, ">"] | @concat,
-  v ? @Array => {"f": @sanitize, "xs": v} | @map,
-  v ? @Object => {"f": @sanitize, "object": v} | @mapValues,
+  v ? @NonFinite => ["<", v | @toString, ">"] | @concat,
+  v ? @Collection => v |: @,
   v => v
 )

data/stdlib/toObject.fsn

@@ -0,0 +1,7 @@
+# Build an object from an array of [key, value] entries; later duplicate keys win.
+# The inverse of @entries: folds the entries onto {} with the [=] setter.
+(
+  entries ? (xs ? @Array => {"c": xs, "f": ([_ ? @String, _] => true)} | @all) =>
+    [{}, ...entries] |+ ([object, [key, value]] => object[key = value]),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@toObject", "status": 0, "input": x, "expected": ["_ ? (xs ? @Array => {\"c\": xs, \"f\": ([_ ? @String, _] => true)} | @all)"]}
+)

data/stdlib/truthy.fsn

@@ -0,0 +1,7 @@
+# True for every value except false and null — Fusion's own truthiness, decided by
+# pattern matching, so it is independent of any @OP override.
+(
+  false => false,
+  null => false,
+  _ => true,
+)

data/stdlib/vector/Vector.fsn

@@ -0,0 +1,7 @@
+# True for a vector: a non-empty array of numbers. A predicate: false for
+# anything else, never an error.
+(v => [
+  v | @Array,
+  v | @size > 0,
+  {"c": v, "f": @Number} | @all,
+] | @OP.and | @safe)

data/stdlib/vector/add.fsn

@@ -0,0 +1,6 @@
+# Add two equal-length vectors elementwise: zip and sum each pair.
+(
+  [u, v] ? ([a ? @Vector, b ? @Vector] => [a, b] |: @size | @OP.equal) =>
+    [u, v] | @zip |: @OP.sum,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@vector/add", "status": 0, "input": x, "expected": ["_ ? ([u ? @vector/Vector, v ? @vector/Vector] => [u, v] |: @size | @OP.equal)"]}
+)

data/stdlib/vector/cross.fsn

@@ -0,0 +1,6 @@
+# Cross product of two 3-dimensional vectors.
+(
+  [[a ? @Number, b ? @Number, c ? @Number], [d ? @Number, e ? @Number, f ? @Number]] =>
+    [b * f - c * e, c * d - a * f, a * e - b * d],
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@vector/cross", "status": 0, "input": x, "expected": ["[[_ ? @Number, _ ? @Number, _ ? @Number], [_ ? @Number, _ ? @Number, _ ? @Number]]"]}
+)

data/stdlib/vector/dot.fsn

@@ -0,0 +1,6 @@
+# Dot product of two equal-length vectors: zip, multiply each pair, sum.
+(
+  [u, v] ? ([a ? @Vector, b ? @Vector] => [a, b] |: @size | @OP.equal) =>
+    [u, v] | @zip |: @OP.product | @OP.sum,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@vector/dot", "status": 0, "input": x, "expected": ["_ ? ([u ? @vector/Vector, v ? @vector/Vector] => [u, v] |: @size | @OP.equal)"]}
+)

data/stdlib/vector/norm.fsn

@@ -0,0 +1,6 @@
+# Euclidean norm (length) of a vector: the square root of the dot product with
+# itself. Always a float.
+(
+  v ? @Vector => [v, v] | @dot | @math.sqrt,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@vector/norm", "status": 0, "input": x, "expected": ["_ ? @vector/Vector"]}
+)

data/stdlib/vector/scale.fsn

@@ -0,0 +1,5 @@
+# Scale a vector elementwise by a single number. Input: [number, vector].
+(
+  [s ? @Number, v ? @Vector] => v |: (entry => s * entry),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@vector/scale", "status": 0, "input": x, "expected": ["[_ ? @Number, _ ? @vector/Vector]"]}
+)

data/stdlib/vector/subtract.fsn

@@ -0,0 +1,6 @@
+# Subtract the second vector from the first, elementwise: u + (-1 * v).
+(
+  [u, v] ? ([a ? @Vector, b ? @Vector] => [a, b] |: @size | @OP.equal) =>
+    [u, [-1, v] | @scale] | @add,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@vector/subtract", "status": 0, "input": x, "expected": ["_ ? ([u ? @vector/Vector, v ? @vector/Vector] => [u, v] |: @size | @OP.equal)"]}
+)

data/stdlib/zip.fsn

@@ -0,0 +1,6 @@
+# Zip a pair of equal-length arrays into an array of [left, right] pairs.
+(
+  [xs, ys] ? ([a ? @Array, b ? @Array] => a | @size == b | @size) =>
+    xs | @size | @range |: (k => [xs[k], ys[k]]),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@zip", "status": 0, "input": x, "expected": ["_ ? ([xs ? @Array, ys ? @Array] => xs | @size == ys | @size)"]}
+)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fusion-lang
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha2
+  version: 0.0.2
 platform: ruby
 authors:
 - Klaus Weidinger
@@ -17,11 +17,15 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".mutant.yml"
+- ".simplecov"
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - docs/index.md
 - docs/lang/design.md
+- docs/lang/implementation.md
 - docs/lang/roadmap.md
 - docs/user/explanation.md
 - docs/user/how-to-guides.md
@@ -32,6 +36,11 @@ files:
 - examples/factorial.fsn
 - examples/first.fsn
 - examples/fizzbuzz.fsn
+- examples/gcd.fsn
+- examples/json_test.fsn
+- examples/matrix/OP.fsn
+- examples/matrix/average.fsn
+- examples/matrix/solve.fsn
 - examples/palindrome.fsn
 - exe/fusion
 - lib/fusion.rb
@@ -48,9 +57,9 @@ files:
 - lib/fusion/interpreter/builtins.rb
 - lib/fusion/interpreter/env.rb
 - lib/fusion/interpreter/error_val.rb
-- lib/fusion/interpreter/file_thunk.rb
 - lib/fusion/interpreter/func.rb
 - lib/fusion/interpreter/native_func.rb
+- lib/fusion/interpreter/thunk.rb
 - lib/fusion/lexer.rb
 - lib/fusion/null.rb
 - lib/fusion/parser.rb
@@ -58,11 +67,48 @@ files:
 - lib/fusion/typed_data.rb
 - lib/fusion/version.rb
 - lib/fusion/wire_pair.rb
+- stdlib/all.fsn
+- stdlib/any.fsn
+- stdlib/chars.fsn
+- stdlib/compact.fsn
+- stdlib/concat.fsn
+- stdlib/entries.fsn
+- stdlib/falsey.fsn
+- stdlib/filter.fsn
+- stdlib/flatten.fsn
 - stdlib/map.fsn
-- stdlib/mapValues.fsn
-- stdlib/math/square.fsn
+- stdlib/matrix/Matrix.fsn
+- stdlib/matrix/OP.fsn
+- stdlib/matrix/add.fsn
+- stdlib/matrix/column.fsn
+- stdlib/matrix/determinant.fsn
+- stdlib/matrix/dimensions.fsn
+- stdlib/matrix/identity.fsn
+- stdlib/matrix/invert.fsn
+- stdlib/matrix/minor.fsn
+- stdlib/matrix/multiply.fsn
+- stdlib/matrix/negate.fsn
+- stdlib/matrix/product.fsn
+- stdlib/matrix/rotate.fsn
+- stdlib/matrix/row.fsn
+- stdlib/matrix/scale.fsn
+- stdlib/matrix/subtract.fsn
+- stdlib/matrix/sum.fsn
+- stdlib/matrix/transpose.fsn
 - stdlib/range.fsn
+- stdlib/reduce.fsn
+- stdlib/safe.fsn
 - stdlib/sanitize.fsn
+- stdlib/toObject.fsn
+- stdlib/truthy.fsn
+- stdlib/vector/Vector.fsn
+- stdlib/vector/add.fsn
+- stdlib/vector/cross.fsn
+- stdlib/vector/dot.fsn
+- stdlib/vector/norm.fsn
+- stdlib/vector/scale.fsn
+- stdlib/vector/subtract.fsn
+- stdlib/zip.fsn
 homepage: https://github.com/dunkelziffer/fusion
 licenses:
 - MIT

data/lib/fusion/interpreter/file_thunk.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# === Interpreter internals ===
-#
-# Lazy, memoized reference to a file's value (a "thunk" / promise).
-
-module Fusion
-  class Interpreter
-    class FileThunk
-      def initialize(loader, abspath)
-        @loader = loader
-        @abspath = abspath
-        @state = :unforced # :unforced | :forcing | :done
-        @value = nil
-      end
-
-      def force
-        case @state
-        when :done then @value
-        when :forcing
-          # We are already evaluating this file and were asked for it again
-          # without any intervening function boundary => non-productive data cycle.
-          ErrorVal.internal(
-            kind: "reference_error",
-            location: @loader.file_location(@abspath),
-            operation: "forcing a file reference",
-            input: @abspath,
-            message: "non-productive data cycle"
-          )
-        else
-          @state = :forcing
-          @value = @loader.evaluate_file(@abspath)
-          @state = :done
-          @value
-        end
-      end
-    end
-  end
-end

data/stdlib/mapValues.fsn

@@ -1,5 +0,0 @@
-# Apply f to each value of an object, keeping the keys. Input: {"f": fn, "object": obj}.
-(
-  {"f": f, "object": obj ? @Object} => {"f": (k => [k, [obj, k] | @get | f]), "xs": obj | @keys} | @map | @toObject,
-  x => !{"kind": "argument_error", "location": "stdlib mapValues.fsn", "operation": "mapValues", "input": x | @sanitize, "message": "expected {\"f\": _, \"object\": _}"}
-)

data/stdlib/math/square.fsn

@@ -1,4 +0,0 @@
-(
-  n ? @Integer => [n, n] | @multiply,
-  x => !{"kind": "type_error", "location": "stdlib square.fsn", "operation": "square", "input": x | @sanitize, "message": "expected an integer"}
-)