fusion-lang 0.0.1 → 0.0.2

data/stdlib/entries.fsn

@@ -0,0 +1,6 @@
+# Destructure an object into an array of its [key, value] entries, in insertion
+# order. The inverse of @toObject.
+(
+  obj ? @Object => obj | @keys |: (k => [k, obj[k]]),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@entries", "status": 0, "input": x, "expected": ["_ ? @Object"]}
+)

data/stdlib/filter.fsn

@@ -6,7 +6,7 @@
     _ ? @falsey => {"f": f, "c": rest} | @,
     _           => [x, ...({"f": f, "c": rest} | @)],
   ),
-  {"f": f ? @Function, "c": obj ? @Object} =>
-    {"f": (e => e | ([_, v] => v | f)), "c": {"f": (k => [k, obj[k]]), "c": obj | @keys} | @map} | @ | @toObject,
-  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@filter", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]}
+  # Reduce to array case
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": ([_, v] => v | f), "c": obj | @entries} | @ | @toObject,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@filter", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]}
 )

data/stdlib/map.fsn

@@ -3,6 +3,7 @@
 (
   {"f": _ ? @Function, "c": []} => [],
   {"f": f ? @Function, "c": [x, ...rest]} => [x | f, ...({"f": f, "c": rest} | @)],
-  {"f": f ? @Function, "c": obj ? @Object} => {"f": (k => [k, obj[k] | f]), "c": obj | @keys} | @ | @toObject,
-  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@map", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]}
+  # Reduce to array case
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": ([k, v] => [k, v | f]), "c": obj | @entries} | @ | @toObject,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@map", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]}
 )

data/stdlib/matrix/Matrix.fsn

@@ -0,0 +1,8 @@
+# True for a matrix: a non-empty array of equally sized vectors (@vector/Vector).
+# A predicate: false for anything else, never an error.
+(rows => [
+  rows | @Array,
+  rows | @size > 0,
+  {"c": rows, "f": @vector/Vector} | @all,
+  rows |: @size | @OP.equal,
+] | @OP.and | @safe)

data/stdlib/matrix/OP.fsn

@@ -0,0 +1,18 @@
+# The operators reskinned for matrices. Point a directory's OP.fsn at
+# `@matrix/OP` to make the arithmetic sugar operate on matrices: `a + b`
+# (elementwise sum), `-a` / `a - b` (elementwise negation), `a * b` (matrix
+# product), `/a` (inverse), `a / b` (multiply by the inverse). `//` and `%`
+# have no matrix meaning and always raise. The spread keeps every other member
+# (equal, compare and its readers, the boolean operators) at its builtin
+# meaning — this module's own files rely on that: they use the comparison and
+# boolean sugar and plain `@OP` references freely, and reserve `@@OP` for the
+# scalar versions of the arithmetic members this file overrides.
+{
+  ...@@,
+  "sum": @sum,
+  "negate": @negate,
+  "product": @product,
+  "invert": @invert,
+  "quotient": (x => !{"kind": "math_error", "origin": "stdlib", "operation": "@matrix/OP.quotient", "status": 0, "input": x, "message": "integer division is not defined for matrices"}),
+  "modulo": (x => !{"kind": "math_error", "origin": "stdlib", "operation": "@matrix/OP.modulo", "status": 0, "input": x, "message": "modulo is not defined for matrices"}),
+}

data/stdlib/matrix/add.fsn

@@ -0,0 +1,7 @@
+# Add two equally sized matrices elementwise: zip the rows and add each pair
+# through @vector/add. Input: [a, b].
+(
+  [a, b] ? ([x ? @Matrix, y ? @Matrix] => [x, y] |: @dimensions | @OP.equal) =>
+    [a, b] | @zip |: @vector/add,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/add", "status": 0, "input": x, "expected": ["_ ? ([a ? @matrix/Matrix, b ? @matrix/Matrix] => [a, b] |: @matrix/dimensions | @OP.equal)"]}
+)

data/stdlib/matrix/column.fsn

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

data/stdlib/matrix/determinant.fsn

@@ -0,0 +1,16 @@
+# Determinant of a square matrix, by Laplace expansion along the first row: the
+# dot product of the first row with its cofactors (signed minor determinants).
+(
+  m ? (sq ? @Matrix => sq | @dimensions | (d => d.rows == d.columns)) =>
+    m | (
+      [[a]] => a,
+      [firstRow, ...] =>
+        [
+          firstRow,
+          (m | @dimensions).columns | @range |: (j =>
+            [[-1, j] | @math.pow, [m, 0, j] | @minor | @] | @@OP.product
+          ),
+        ] | @vector/dot
+    ),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/determinant", "status": 0, "input": x, "expected": ["_ ? (sq ? @matrix/Matrix => sq | @matrix/dimensions | (d => d.rows == d.columns))"]}
+)

data/stdlib/matrix/dimensions.fsn

@@ -0,0 +1,5 @@
+# The dimensions of a matrix, as {"rows": _, "columns": _}.
+(
+  m ? @Matrix => {"rows": m | @size, "columns": m[0] | @size},
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/dimensions", "status": 0, "input": x, "expected": ["_ ? @matrix/Matrix"]}
+)

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 => [m, 0] | @OP.compare | @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 | @gte)"]}
+  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/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, "c": v} | @map,
-  v ? @Object => {"f": @sanitize, "c": v} | @map,
+  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/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
+  version: 0.0.2
 platform: ruby
 authors:
 - Klaus Weidinger
@@ -17,6 +17,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".mutant.yml"
+- ".simplecov"
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -33,7 +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
@@ -65,18 +72,43 @@ files:
 - stdlib/chars.fsn
 - stdlib/compact.fsn
 - stdlib/concat.fsn
+- stdlib/entries.fsn
 - stdlib/falsey.fsn
 - stdlib/filter.fsn
 - stdlib/flatten.fsn
-- stdlib/gt.fsn
-- stdlib/gte.fsn
-- stdlib/lt.fsn
-- stdlib/lte.fsn
 - stdlib/map.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/stdlib/gt.fsn

@@ -1,9 +0,0 @@
-# Strictly greater: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @gt`.
-# A partial order's compare may return null (incomparable); that propagates as null.
-(
-  -1 => false,
-  0 => false,
-  1 => true,
-  null => null,
-  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@gt", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
-)

data/stdlib/gte.fsn

@@ -1,9 +0,0 @@
-# Greater-or-equal: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @gte`.
-# A partial order's compare may return null (incomparable); that propagates as null.
-(
-  -1 => false,
-  0 => true,
-  1 => true,
-  null => null,
-  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@gte", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
-)

data/stdlib/lt.fsn

@@ -1,9 +0,0 @@
-# Strictly less: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @lt`.
-# A partial order's compare may return null (incomparable); that propagates as null.
-(
-  -1 => true,
-  0 => false,
-  1 => false,
-  null => null,
-  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@lt", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
-)

data/stdlib/lte.fsn

@@ -1,9 +0,0 @@
-# Less-or-equal: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @lte`.
-# A partial order's compare may return null (incomparable); that propagates as null.
-(
-  -1 => true,
-  0 => true,
-  1 => false,
-  null => null,
-  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@lte", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
-)