fusion-lang 0.0.1.alpha1 → 0.0.1

data/stdlib/all.fsn

@@ -0,0 +1,13 @@
+# Return true if every item satisfies the predicate "f" (a truthy result) — over an
+# array's elements or an object's values. Input: {"f": predicate, "c": array-or-object}.
+# Short-circuits: the first item whose predicate is falsey yields false without testing
+# the rest.
+(
+  {"f": _ ? @Function, "c": []} => true,
+  {"f": f ? @Function, "c": [x, ...rest]} => (x | f) | (
+    _ ? @falsey => false,
+    _           => {"f": f, "c": rest} | @,
+  ),
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": f, "c": obj | @values} | @,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@all", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]},
+)

data/stdlib/any.fsn

@@ -0,0 +1,12 @@
+# True if any item satisfies the predicate — over an array's elements or an object's
+# values. Input: {"f": predicate, "c": array-or-object}. Short-circuits on the first
+# truthy result.
+(
+  {"f": _ ? @Function, "c": []} => false,
+  {"f": f ? @Function, "c": [x, ...rest]} => x | f | (
+    _ ? @falsey => {"f": f, "c": rest} | @,
+    _           => true,
+  ),
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": f, "c": obj | @values} | @,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@any", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]},
+)

data/stdlib/chars.fsn

@@ -0,0 +1,5 @@
+# Split a string into its characters. Built on @split with an empty separator.
+(
+  s ? @String => [s, ""] | @split,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@chars", "status": 0, "input": x, "expected": ["_ ? @String"]}
+)

data/stdlib/compact.fsn

@@ -0,0 +1,6 @@
+# Drop null entries from an array (by element) or an object (by value). Built on @filter.
+(
+  xs ? @Array => {"f": (null => false, _ => true), "c": xs} | @filter,
+  obj ? @Object => {"f": (null => false, _ => true), "c": obj} | @filter,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@compact", "status": 0, "input": x, "expected": ["_ ? @Array", "_ ? @Object"]}
+)

data/stdlib/concat.fsn

@@ -0,0 +1,5 @@
+# Concatenate two strings. Input: [a, b]. Built on @join with an empty separator.
+(
+  [a ? @String, b ? @String] => [[a, b], ""] | @join,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@concat", "status": 0, "input": x, "expected": ["[_ ? @String, _ ? @String]"]}
+)

data/stdlib/falsey.fsn

@@ -0,0 +1,6 @@
+# True for false and null — Fusion's own falsiness, decided by pattern matching.
+(
+  false => true,
+  null => true,
+  _ => false,
+)

data/stdlib/filter.fsn

@@ -0,0 +1,12 @@
+# Keep the array elements (or object values) for which f(x) is truthy. Input:
+# {"f": predicate, "c": array-or-object}. Like @map, it is polymorphic on c.
+(
+  {"f": _ ? @Function, "c": []} => [],
+  {"f": f ? @Function, "c": [x, ...rest]} => x | f | (
+    _ ? @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}"]}
+)

data/stdlib/flatten.fsn

@@ -0,0 +1,7 @@
+# Recursively flatten nested arrays into one flat array.
+(
+  [] => [],
+  [x ? @Array, ...rest] => [...(x | @), ...(rest | @)],
+  [x, ...rest] => [x, ...(rest | @)],
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@flatten", "status": 0, "input": x, "expected": ["_ ? @Array"]}
+)

data/stdlib/gt.fsn

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,9 @@
+# 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"]},
+)

data/stdlib/map.fsn

@@ -1,4 +1,8 @@
+# Apply f to each element of an array, or to each value of an object (keeping the
+# keys). Input: {"f": fn, "c": array-or-object}.
 (
-  {"f": _, "xs": []} => [],
-  {"f": f, "xs": [x, ...rest]} => [x | f, ...({"f": f, "xs": rest} | @map)]
+  {"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}"]}
 )

data/stdlib/range.fsn

@@ -1,4 +1,5 @@
 (
   0 => [],
-  n ? @Integer => [...([n, 1] | @subtract | @range), [n, 1] | @subtract]
+  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)"]}
 )

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/sanitize.fsn

@@ -0,0 +1,12 @@
+# Render a value safe to embed in an error payload, mirroring the interpreter's
+# lenient serialization (docs/user/reference.md §9.3): a function becomes
+# "<function>" and a non-finite number becomes "<Infinity>" / "<-Infinity>" /
+# "<NaN>". Arrays and objects are sanitized recursively; everything else is
+# 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 => v
+)

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,
+)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fusion-lang
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha1
+  version: 0.0.1
 platform: ruby
 authors:
 - Klaus Weidinger
@@ -22,22 +22,61 @@ files:
 - 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
 - docs/user/reference.md
 - docs/user/tutorial.md
 - examples/double.fsn
+- examples/ends.fsn
 - examples/factorial.fsn
 - examples/first.fsn
 - examples/fizzbuzz.fsn
+- examples/json_test.fsn
 - examples/palindrome.fsn
 - exe/fusion
 - lib/fusion.rb
+- lib/fusion/ast.rb
+- lib/fusion/atom.rb
+- lib/fusion/cli.rb
+- lib/fusion/cli/decoder.rb
+- lib/fusion/cli/encoder.rb
+- lib/fusion/cli/options.rb
+- lib/fusion/cli/parser.rb
+- lib/fusion/cli/repl.rb
+- lib/fusion/cli/serializer.rb
+- lib/fusion/interpreter.rb
+- lib/fusion/interpreter/builtins.rb
+- lib/fusion/interpreter/env.rb
+- lib/fusion/interpreter/error_val.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
+- lib/fusion/token.rb
+- 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/falsey.fsn
+- stdlib/filter.fsn
+- stdlib/flatten.fsn
+- stdlib/gt.fsn
+- stdlib/gte.fsn
+- stdlib/lt.fsn
+- stdlib/lte.fsn
 - stdlib/map.fsn
-- stdlib/math/square.fsn
 - stdlib/range.fsn
+- stdlib/reduce.fsn
+- stdlib/sanitize.fsn
+- stdlib/truthy.fsn
 homepage: https://github.com/dunkelziffer/fusion
 licenses:
 - MIT

data/stdlib/math/square.fsn

@@ -1 +0,0 @@
-(n ? @Integer => [n, n] | @multiply)