eyelang 1.7.16 → 2.0.0

package/examples/statistics-summary.eye

@@ -1,56 +0,0 @@
-% Population statistics for a small numeric sample.
-%
-% The sample is the textbook data set [2,4,4,4,5,5,7,9], whose population
-% mean is 5, variance is 4, and standard deviation is 2.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(count, 2).
-materialize(mean, 2).
-materialize(populationVariance, 2).
-materialize(populationStddev, 2).
-
-% The sample is one list fact, which lets recursive list folds demonstrate
-% aggregation without introducing a separate row relation.
-sample(scores, [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]).
-
-sum([], 0.0).
-% sum/2 and squared_error_sum/3 are recursive folds; the public relations then
-% derive count, mean, population variance, and standard deviation.
-sum([?x|?xs], ?total) :-
-  sum(?xs, ?rest),
-  add(?x, ?rest, ?total).
-
-mean(?name, ?mean) :-
-  sample(?name, ?values),
-  sum(?values, ?total),
-  length(?values, ?count),
-  div(?total, ?count, ?mean).
-
-squared_error_sum([], ?_mean, 0.0).
-squared_error_sum([?x|?xs], ?mean, ?total) :-
-  sub(?x, ?mean, ?delta),
-  pow(?delta, 2.0, ?squared),
-  squared_error_sum(?xs, ?mean, ?rest),
-  add(?squared, ?rest, ?total).
-
-population_variance(?name, ?variance) :-
-  sample(?name, ?values),
-  mean(?name, ?mean),
-  squared_error_sum(?values, ?mean, ?sumsquarederrors),
-  length(?values, ?count),
-  div(?sumsquarederrors, ?count, ?variance).
-
-population_stddev(?name, ?stddev) :-
-  population_variance(?name, ?variance),
-  pow(?variance, 0.5, ?stddev).
-
-count(?name, ?count) :-
-  sample(?name, ?values),
-  length(?values, ?count).
-
-
-populationVariance(?name, ?variance) :-
-  population_variance(?name, ?variance).
-
-populationStddev(?name, ?stddev) :-
-  population_stddev(?name, ?stddev).

package/examples/stirling-bell-numbers.eye

@@ -1,69 +0,0 @@
-% Stirling numbers of the second kind and Bell numbers.
-%
-% The Stirling count S(N,K) is computed with the inclusion-exclusion formula
-%   S(N,K) = (1/K!) * sum(I=0..K, (-1)^(K-I) * C(K,I) * I^N)
-% instead of the overlapping two-branch recurrence.  Bell numbers use
-%   B(0) = 1, B(N) = sum(K=0..N-1, C(N-1,K) * B(K)).
-% The table declarations memoize the smaller helper relations used by both formulas.
-materialize(stirling_bell_answer, 2).
-
-table(factorial, 2).
-table(binomial, 3).
-table(stirling2, 3).
-table(bell, 2).
-
-factorial(0, 1).
-factorial(?n, ?value) :-
-  gt(?n, 0),
-  sub(?n, 1, ?n1),
-  factorial(?n1, ?previous),
-  mul(?n, ?previous, ?value).
-
-binomial(0, 0, 1).
-binomial(?n, 0, 1) :- gt(?n, 0).
-binomial(?n, ?n, 1) :- gt(?n, 0).
-binomial(?n, ?k, ?value) :-
-  gt(?n, 0),
-  gt(?k, 0),
-  lt(?k, ?n),
-  sub(?n, 1, ?n1),
-  sub(?k, 1, ?k1),
-  binomial(?n1, ?k1, ?left),
-  binomial(?n1, ?k, ?right),
-  add(?left, ?right, ?value).
-
-signed_term(?n, ?k, ?i, ?term) :-
-  binomial(?k, ?i, ?c),
-  pow(?i, ?n, ?p),
-  mul(?c, ?p, ?unsigned),
-  sub(?k, ?i, ?d),
-  mod(?d, 2, 0),
-  eq(?term, ?unsigned).
-signed_term(?n, ?k, ?i, ?term) :-
-  binomial(?k, ?i, ?c),
-  pow(?i, ?n, ?p),
-  mul(?c, ?p, ?unsigned),
-  sub(?k, ?i, ?d),
-  mod(?d, 2, 1),
-  neg(?unsigned, ?term).
-
-stirling2(0, 0, 1).
-stirling2(?n, 0, 0) :- gt(?n, 0).
-stirling2(0, ?k, 0) :- gt(?k, 0).
-stirling2(?n, ?k, ?count) :-
-  gt(?n, 0),
-  gt(?k, 0),
-  sumall(?term, (between(0, ?k, ?i), signed_term(?n, ?k, ?i, ?term)), ?sum),
-  factorial(?k, ?factorial),
-  div(?sum, ?factorial, ?count).
-
-bell(0, 1).
-bell(?n, ?count) :-
-  gt(?n, 0),
-  sub(?n, 1, ?n1),
-  sumall(?term, (between(0, ?n1, ?k), binomial(?n1, ?k, ?choose), bell(?k, ?bell), mul(?choose, ?bell, ?term)), ?count).
-
-stirling_bell_answer(stirling_10_4, ?count) :- stirling2(10, 4, ?count).
-stirling_bell_answer(stirling_12_5, ?count) :- stirling2(12, 5, ?count).
-stirling_bell_answer(bell_10, ?count) :- bell(10, ?count).
-stirling_bell_answer(bell_12, ?count) :- bell(12, ?count).

package/examples/sudoku-4x4.eye

@@ -1,54 +0,0 @@
-% Compact 4x4 Sudoku search with row permutations and column/box constraints.
-%
-% The givens are baked into row1/1 ... row4/1, so each candidate row is already
-% a permutation of 1..4.  sudoku_solution/1 then checks the remaining columns
-% and 2x2 boxes, which keeps the example clear and playground-friendly.
-materialize(sudoku_answer, 2).
-
-perm([], []).
-perm(?items, [?x|?rest]) :-
-  select(?x, ?items, ?remaining),
-  perm(?remaining, ?rest).
-
-% distinct/1 is the reusable all-different constraint.
-distinct([]).
-distinct([?x|?xs]) :-
-  not_member(?x, ?xs),
-  distinct(?xs).
-
-row1([1, ?b, ?c, 4]) :- perm([1, 2, 3, 4], [1, ?b, ?c, 4]).
-row2([?a, 4, 1, ?d]) :- perm([1, 2, 3, 4], [?a, 4, 1, ?d]).
-row3([?b, 1, 4, ?c]) :- perm([1, 2, 3, 4], [?b, 1, 4, ?c]).
-row4([4, ?c, ?b, 1]) :- perm([1, 2, 3, 4], [4, ?c, ?b, 1]).
-
-column([?r1, ?r2, ?r3, ?r4], ?index, [?a, ?b, ?c, ?d]) :-
-  nth0(?index, ?r1, ?a),
-  nth0(?index, ?r2, ?b),
-  nth0(?index, ?r3, ?c),
-  nth0(?index, ?r4, ?d).
-
-% The four boxes are extracted as lists, then passed through distinct/1.
-boxes([?r1, ?r2, ?r3, ?r4], [?box1, ?box2, ?box3, ?box4]) :-
-  nth0(0, ?r1, ?a), nth0(1, ?r1, ?b), nth0(0, ?r2, ?c), nth0(1, ?r2, ?d),
-  eq(?box1, [?a, ?b, ?c, ?d]),
-  nth0(2, ?r1, ?e), nth0(3, ?r1, ?f), nth0(2, ?r2, ?g), nth0(3, ?r2, ?h),
-  eq(?box2, [?e, ?f, ?g, ?h]),
-  nth0(0, ?r3, ?i), nth0(1, ?r3, ?j), nth0(0, ?r4, ?k), nth0(1, ?r4, ?l),
-  eq(?box3, [?i, ?j, ?k, ?l]),
-  nth0(2, ?r3, ?m), nth0(3, ?r3, ?n), nth0(2, ?r4, ?o), nth0(3, ?r4, ?p),
-  eq(?box4, [?m, ?n, ?o, ?p]).
-
-sudoku_solution([?r1, ?r2, ?r3, ?r4]) :-
-  row1(?r1),
-  row2(?r2),
-  row3(?r3),
-  row4(?r4),
-  column([?r1, ?r2, ?r3, ?r4], 0, ?c0), distinct(?c0),
-  column([?r1, ?r2, ?r3, ?r4], 1, ?c1), distinct(?c1),
-  column([?r1, ?r2, ?r3, ?r4], 2, ?c2), distinct(?c2),
-  column([?r1, ?r2, ?r3, ?r4], 3, ?c3), distinct(?c3),
-  boxes([?r1, ?r2, ?r3, ?r4], [?b1, ?b2, ?b3, ?b4]),
-  distinct(?b1), distinct(?b2), distinct(?b3), distinct(?b4).
-
-sudoku_answer(solution, ?grid) :- once(sudoku_solution(?grid)).
-sudoku_answer(solution_count, ?count) :- countall(sudoku_solution(?_grid), ?count).

package/examples/superdense-coding.eye

@@ -1,84 +0,0 @@
-% Superdense coding using discrete quantum computing, adapted from
-% Eyelet's input/superdense-coding.eye.
-%
-% The Eyelet program toggles dynamic sdcoding/2 facts so answers appearing an
-% even number of times cancel. eyelang expresses the same finite example
-% declaratively: for this protocol the surviving messages are exactly those
-% with a single support path after the interference choices are expanded.
-
-% |R) = |0, 0) + |1, 1)
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(decodesAs, 2).
-materialize(preservesMessage, 2).
-materialize(cancelsCrossTalk, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-r(false, false).
-r(true, true).
-
-% ID |0) = |0), ID |1) = |1)
-identity(false, false).
-identity(true, true).
-
-% G |0) = |1), G |1) = |0)
-g(false, true).
-g(true, false).
-
-% K |0) = |0), K |1) = |0) + |1)
-k(false, false).
-k(true, false).
-k(true, true).
-
-% KG and GK compositions.
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-kg(?x, ?y) :-
-  g(?x, ?z),
-  k(?z, ?y).
-
-gk(?x, ?y) :-
-  k(?x, ?z),
-  g(?z, ?y).
-
-% Alice encodes two classical bits as one of four transformations.
-alice(0, ?x, ?y) :- identity(?x, ?y).
-alice(1, ?x, ?y) :- g(?x, ?y).
-alice(2, ?x, ?y) :- k(?x, ?y).
-alice(3, ?x, ?y) :- kg(?x, ?y).
-
-% Bob decodes with the Bell-style measurement basis.
-bob(?x, ?y, 0) :- gk(?x, ?y).
-bob(?x, ?y, 1) :- k(?x, ?y).
-bob(?x, ?y, 2) :- g(?x, ?y).
-bob(?x, ?y, 3) :- identity(?x, ?y).
-
-% One concrete support path through the entangled pair and the two transforms.
-sdc_path(?n, ?m, path(?x, ?y, ?b)) :-
-  r(?x, ?y),
-  alice(?n, ?x, ?b),
-  bob(?b, ?y, ?m).
-
-% If another different support path gives the same answer, this answer cancels
-% in pairs in the finite superdense-coding table.
-duplicate_sdc_path(?n, ?m, ?proof) :-
-  sdc_path(?n, ?m, ?proof),
-  sdc_path(?n, ?m, ?other),
-  neq(?proof, ?other).
-
-sdcoding(?n, ?m) :-
-  sdc_path(?n, ?m, ?proof),
-  not(duplicate_sdc_path(?n, ?m, ?proof)).
-
-decodesAs(message(?n), ?m) :-
-  sdcoding(?n, ?m).
-
-preservesMessage(protocol, true) :-
-  sdcoding(0, 0),
-  sdcoding(1, 1),
-  sdcoding(2, 2),
-  sdcoding(3, 3).
-
-cancelsCrossTalk(protocol, true) :-
-  not(sdcoding(0, 1)),
-  not(sdcoding(1, 0)),
-  not(sdcoding(2, 3)),
-  not(sdcoding(3, 2)).

package/examples/symbolic-derivative.eye

@@ -1,39 +0,0 @@
-% Symbolic differentiation over explicit expression terms.
-%
-% The source derivative example uses Prolog operators such as `+`, `*`, `^`, and
-% cut.  Eyelang keeps expressions as ordinary terms: `add/2`, `mul/2`, `pow/2`,
-% `log/1`, and so on.  The result is intentionally unsimplified so the rule that
-% produced each part remains visible.
-
-materialize(derivative_result, 2).
-
-expr(square, mul(var(x), var(x))).
-expr(linear_plus_const, add(var(x), const(3))).
-expr(product, mul(add(var(x), const(1)), mul(add(pow(var(x), 2), const(2)), add(pow(var(x), 3), const(3))))).
-expr(nested_log, log(log(var(x)))).
-
-d(const(?_c), ?_x, const(0)).
-d(var(?x), ?x, const(1)).
-d(var(?y), ?x, const(0)) :-
-  neq(?x, ?y).
-d(add(?u, ?v), ?x, add(?du, ?dv)) :-
-  d(?u, ?x, ?du),
-  d(?v, ?x, ?dv).
-d(sub(?u, ?v), ?x, sub(?du, ?dv)) :-
-  d(?u, ?x, ?du),
-  d(?v, ?x, ?dv).
-d(mul(?u, ?v), ?x, add(mul(?du, ?v), mul(?u, ?dv))) :-
-  d(?u, ?x, ?du),
-  d(?v, ?x, ?dv).
-d(divide(?u, ?v), ?x, divide(sub(mul(?du, ?v), mul(?u, ?dv)), pow(?v, 2))) :-
-  d(?u, ?x, ?du),
-  d(?v, ?x, ?dv).
-d(pow(?u, ?n), ?x, mul(mul(const(?n), pow(?u, ?n1)), ?du)) :-
-  sub(?n, 1, ?n1),
-  d(?u, ?x, ?du).
-d(log(?u), ?x, divide(?du, ?u)) :-
-  d(?u, ?x, ?du).
-
-derivative_result(?name, ?derivative) :-
-  expr(?name, ?expr),
-  d(?expr, x, ?derivative).

package/examples/term-tools.eye

@@ -1,32 +0,0 @@
-% Term-tool builtins for inspecting, constructing, rendering, and validating
-% structured terms.
-%
-% Each report/2 answer demonstrates one meta-programming operation over ordinary
-% Eyelang terms: functor/3 and arg/3 inspect shape, compound_name_arguments/3 can
-% decompose or rebuild a compound, term_string/2 renders a term, and forall/2
-% validates all edge weights.
-%
-% This is a good reference example when writing rules that need to treat terms as
-% data rather than only as predicate calls.
-materialize(report, 2).
-
-edge(a, b, 3).
-edge(b, c, 4).
-
-report(shape, shape(?name, ?arity)) :-
-  functor(edge(a, b, 3), ?name, ?arity).
-
-report(second_argument, ?node) :-
-  arg(2, edge(a, b, 3), ?node).
-
-report(parts, parts(?name, ?args)) :-
-  compound_name_arguments(edge(a, b, 3), ?name, ?args).
-
-report(rebuilt, ?term) :-
-  compound_name_arguments(?term, edge, [c, d, 5]).
-
-report(rendered, ?text) :-
-  term_string(edge(a, [b, c]), ?text).
-
-report(all_weights_positive, yes) :-
-  forall(edge(?_from, ?_to, ?weight), gt(?weight, 0)).

package/examples/totient-summatory.eye

@@ -1,33 +0,0 @@
-% Euler totients and coprimality by tabled Euclidean gcd.
-%
-% phi(N) is modeled directly as the count of integers K in 1..N with gcd(N,K)=1.
-% The summatory query reuses many gcd/totient subgoals, so memoization keeps the
-% example responsive while preserving the relational presentation.
-materialize(totient_answer, 2).
-
-table(gcd, 3).
-table(totient, 2).
-
-% Euclid's algorithm is expressed recursively over remainders.
-gcd(?a, 0, ?a) :- ge(?a, 0).
-gcd(?a, ?b, ?g) :-
-  gt(?b, 0),
-  mod(?a, ?b, ?r),
-  gcd(?b, ?r, ?g).
-
-coprime_upto(?n, ?k) :-
-  between(1, ?n, ?k),
-  gcd(?n, ?k, 1).
-
-% Count the finite coprime generator instead of constructing an explicit list.
-totient(?n, ?count) :-
-  gt(?n, 0),
-  countall(coprime_upto(?n, ?_k), ?count).
-
-summatory_totient(?limit, ?sum) :-
-  sumall(?phi, (between(1, ?limit, ?n), totient(?n, ?phi)), ?sum).
-
-totient_answer(phi_36, ?phi) :- totient(36, ?phi).
-totient_answer(phi_97, ?phi) :- totient(97, ?phi).
-totient_answer(coprime_count_84, ?count) :- totient(84, ?count).
-totient_answer(summatory_phi_30, ?sum) :- summatory_totient(30, ?sum).

package/examples/trust-flow-provenance-threshold.eye

@@ -1,47 +0,0 @@
-% Provenance-derived trust-flow thresholding in Eyelang.
-%
-% Each message combines publisher trust, signature strength, and transform quality
-% into one confidence score.  Receiver-specific thresholds then classify messages
-% as accepted or quarantined and derive status/risk facts.
-%
-% The multiplication chain is intentionally explicit so proof output shows how a
-% provenance trail becomes a single trust decision.
-
-materialize(confidence, 2).
-materialize(trust_flow_state, 2).
-materialize(status, 2).
-materialize(risk, 2).
-
-message(message_a, publisher_a, transform_a, signature_a, receiver_app).
-message(message_b, publisher_b, transform_b, signature_b, receiver_app).
-
-publisher_trust(publisher_a, 0.95).
-publisher_trust(publisher_b, 0.70).
-signature_strength(signature_a, 0.98).
-signature_strength(signature_b, 0.75).
-quality_score(transform_a, 0.96).
-quality_score(transform_b, 0.80).
-acceptance_threshold(receiver_app, 0.85).
-
-confidence(?message, ?confidence) :-
-  message(?message, ?publisher, ?transform, ?signature, ?_receiver),
-  publisher_trust(?publisher, ?publishertrust),
-  signature_strength(?signature, ?signaturetrust),
-  quality_score(?transform, ?quality),
-  mul(?publishertrust, ?signaturetrust, ?a),
-  mul(?a, ?quality, ?confidence).
-
-trust_flow_state(?message, fpv_accepted) :-
-  message(?message, ?_publisher, ?_transform, ?_signature, ?receiver),
-  confidence(?message, ?confidence),
-  acceptance_threshold(?receiver, ?threshold),
-  ge(?confidence, ?threshold).
-
-trust_flow_state(?message, fpv_quarantine) :-
-  message(?message, ?_publisher, ?_transform, ?_signature, ?receiver),
-  confidence(?message, ?confidence),
-  acceptance_threshold(?receiver, ?threshold),
-  lt(?confidence, ?threshold).
-
-status(?message, fpv_high_trust_flow) :- trust_flow_state(?message, fpv_accepted).
-risk(?message, risk_low_trust_data_source) :- trust_flow_state(?message, fpv_quarantine).

package/examples/truth-maintenance-system.eye

@@ -1,62 +0,0 @@
-% A tiny assumption-based truth maintenance system.
-%
-% An environment is a set of assumptions.  Justifications derive beliefs from
-% assumptions and from other derived beliefs.  The TMS can therefore explain
-% which environments support a belief and which environments are inconsistent
-% because they support contradictory conclusions.
-
-materialize(tmsSupport, 2).
-materialize(tmsJustification, 3).
-materialize(tmsInconsistent, 1).
-materialize(tmsConclusion, 2).
-
-table(supported, 2).
-
-% Candidate environments.
-environment(clear_only, [sensor_clear]).
-environment(blocked_only, [sensor_blocked]).
-environment(conflicting_sensors, [sensor_clear, sensor_blocked]).
-environment(override_blocked, [sensor_blocked, operator_override]).
-
-assumes(?environment, ?assumption) :-
-  environment(?environment, ?assumptions),
-  member(?assumption, ?assumptions).
-
-% Justifications.  Preconditions are either assumption(Name) or another derived
-% belief.  The last justification says an operator override can permit motion
-% even when the blocked-path belief is also present.
-justification(j_clear_path, [assumption(sensor_clear)], clear_path).
-justification(j_blocked_path, [assumption(sensor_blocked)], blocked_path).
-justification(j_permit_from_clear, [clear_path], permit_go).
-justification(j_forbid_from_blocked, [blocked_path], forbid_go).
-justification(j_override, [assumption(operator_override), blocked_path], permit_go).
-
-all_hold(?, []).
-all_hold(?environment, [assumption(?assumption) | ?rest]) :-
-  assumes(?environment, ?assumption),
-  all_hold(?environment, ?rest).
-all_hold(?environment, [?belief | ?rest]) :-
-  supported(?environment, ?belief),
-  all_hold(?environment, ?rest).
-
-supported(?environment, ?belief) :-
-  justification(?, ?preconditions, ?belief),
-  all_hold(?environment, ?preconditions).
-
-contradicts(permit_go, forbid_go).
-contradicts(forbid_go, permit_go).
-inconsistent(?environment) :-
-  supported(?environment, ?left),
-  supported(?environment, ?right),
-  contradicts(?left, ?right).
-
-% Show the actual justifications that fired, not just the final supported beliefs.
-fires(?environment, ?justification, ?belief) :-
-  justification(?justification, ?preconditions, ?belief),
-  all_hold(?environment, ?preconditions).
-
-tmsSupport(?environment, ?belief) :- supported(?environment, ?belief).
-tmsJustification(?environment, ?justification, ?belief) :- fires(?environment, ?justification, ?belief).
-tmsInconsistent(?environment) :- inconsistent(?environment).
-tmsConclusion(case, "truth maintenance separates support from consistency across assumption environments") :-
-  inconsistent(conflicting_sensors).

package/examples/turing.eye

@@ -1,69 +0,0 @@
-% Universal Turing machine example adapted from Eyelet's input/turing.eye.
-%
-% The machine below adds 1 to a binary number represented as a list of bits.
-% A tape is split into a reversed left side, current cell, and right side; move/7
-% updates that zipper representation.  The blank tape symbol is #.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(input, 2).
-materialize(output, 2).
-materialize(addsOne, 2).
-
-% compute/2 initializes the tape and starts from the machine's start state.
-compute([], ?outtape) :-
-  start(?_machine, ?i),
-  find(?i, [], #, [], ?outtape).
-
-compute([?head|?tail], ?outtape) :-
-  start(?_machine, ?i),
-  find(?i, [], ?head, ?tail, ?outtape).
-
-% find/5 executes one transition, moves the head, and either halts or recurses.
-find(?state, ?left, ?cell, ?right, ?outtape) :-
-  t([?state, ?cell, ?write, ?move], ?next),
-  move(?move, ?left, ?write, ?right, ?a, ?b, ?c),
-  continue(?next, ?a, ?b, ?c, ?outtape).
-
-continue(halt, ?left, ?cell, ?right, ?outtape) :-
-  rever(?left, ?r),
-  append(?r, [?cell|?right], ?outtape).
-
-continue(?state, ?left, ?cell, ?right, ?outtape) :-
-  find(?state, ?left, ?cell, ?right, ?outtape).
-
-% Head movement defines the tape zipper update, including blank extension.
-move(l, [], ?cell, ?right, [], #, [?cell|?right]).
-move(l, [?head|?tail], ?cell, ?right, ?tail, ?head, [?cell|?right]).
-move(s, ?left, ?cell, ?right, ?left, ?cell, ?right).
-move(r, ?left, ?cell, [], [?cell|?left], #, []).
-move(r, ?left, ?cell, [?head|?tail], [?cell|?left], ?head, ?tail).
-
-rever([], []).
-rever([?a|?b], ?c) :-
-  rever(?b, ?d),
-  append(?d, [?a], ?c).
-
-% A Turing machine to add 1 to a binary number.
-start(add1, 0).
-t([0, 0, 0, r], 0).
-t([0, 1, 1, r], 0).
-t([0, #, #, l], 1).
-t([1, 0, 1, s], halt).
-t([1, 1, 0, l], 1).
-t([1, #, 1, s], halt).
-
-case(case1, [1, 0, 1, 0, 0, 1]).
-case(case2, [1, 0, 1, 1, 1, 1]).
-case(case3, [1, 1, 1, 1, 1, 1]).
-case(case4, []).
-
-input(?case, ?intape) :-
-  case(?case, ?intape).
-
-output(?case, ?outtape) :-
-  case(?case, ?intape),
-  compute(?intape, ?outtape).
-
-addsOne(?case, true) :-
-  case(?case, ?intape),
-  compute(?intape, ?_outtape).

package/examples/type-inference.eye

@@ -1,58 +0,0 @@
-% Hindley-Milner-style type inference for a tiny lambda language.
-%
-% The example is intentionally small and deterministic.  Lambda binders carry
-% explicit type variables or annotations, and ordinary logic unification solves
-% the constraints created by application, arithmetic, conditionals, and pairs.
-% The symbolic names t0, t1, and t2 stand for schematic type variables in the
-% displayed answers; concrete examples such as apply_id annotate the argument as
-% int so the application can be checked.
-materialize(type_answer, 2).
-materialize(type_reason, 2).
-
-table(type_expr, 3).
-
-% Tiny expression language: int_lit/1, bool_lit/1, var/1, lam/3, app/2,
-% add/2, if/3, pair/2, fst/1, and snd/1.
-program(id, lam(x, t0, var(x))).
-program(const, lam(x, t0, lam(y, t1, var(x)))).
-program(apply_id, app(lam(x, int, var(x)), int_lit(42))).
-program(compose,
-  lam(f, fun(t1, t2),
-    lam(g, fun(t0, t1),
-      lam(x, t0,
-        app(var(f), app(var(g), var(x))))))).
-program(branch,
-  if(bool_lit(true), add(int_lit(20), int_lit(22)), int_lit(0))).
-program(first_of_pair, fst(pair(bool_lit(true), int_lit(7)))).
-
-lookup(?name, [[?name, ?type] | ?], ?type).
-lookup(?name, [[?, ?] | ?rest], ?type) :- lookup(?name, ?rest, ?type).
-
-type_expr(?, int_lit(?), int).
-type_expr(?, bool_lit(?), bool).
-type_expr(?env, var(?name), ?type) :- lookup(?name, ?env, ?type).
-type_expr(?env, lam(?name, ?arg_type, ?body), fun(?arg_type, ?body_type)) :-
-  type_expr([[?name, ?arg_type] | ?env], ?body, ?body_type).
-type_expr(?env, app(?fn, ?arg), ?result_type) :-
-  type_expr(?env, ?fn, fun(?arg_type, ?result_type)),
-  type_expr(?env, ?arg, ?arg_type).
-type_expr(?env, add(?left, ?right), int) :-
-  type_expr(?env, ?left, int),
-  type_expr(?env, ?right, int).
-type_expr(?env, if(?cond, ?then, ?else), ?type) :-
-  type_expr(?env, ?cond, bool),
-  type_expr(?env, ?then, ?type),
-  type_expr(?env, ?else, ?type).
-type_expr(?env, pair(?left, ?right), pair(?left_type, ?right_type)) :-
-  type_expr(?env, ?left, ?left_type),
-  type_expr(?env, ?right, ?right_type).
-type_expr(?env, fst(?pair), ?left_type) :-
-  type_expr(?env, ?pair, pair(?left_type, ?)).
-type_expr(?env, snd(?pair), ?right_type) :-
-  type_expr(?env, ?pair, pair(?, ?right_type)).
-
-type_answer(?name, ?type) :- program(?name, ?expr), type_expr([], ?expr, ?type).
-type_reason(compose, "application unifies f with t1 -> t2 and g with t0 -> t1") :-
-  type_answer(compose, ?).
-type_reason(apply_id, "the identity function's parameter type is unified with int") :-
-  type_answer(apply_id, int).

package/examples/vector-similarity.eye

@@ -1,60 +0,0 @@
-% Vector dot product, Euclidean norm, and cosine similarity.
-%
-% Recursive list folds compute the dot product and squared-length sums.  The
-% public cosineSimilarity/2 report then combines those folds as
-% dot(A,B)/(norm(A)*norm(B)) for a named vector pair.
-%
-% The example keeps vectors as ordinary Eyelang lists, so it doubles as a compact
-% demonstration of numeric recursion over list structure.
-
-materialize(dotProduct, 2).
-materialize(normA, 2).
-materialize(normB, 2).
-materialize(cosineSimilarity, 2).
-
-% Two named vectors form the single cosine-similarity case.
-vector(pair1, a, [1.0, 2.0, 3.0]).
-vector(pair1, b, [4.0, -5.0, 6.0]).
-
-% Recursive list folds compute dot products and sums of squares.
-dot([], [], 0.0).
-dot([?a|?as], [?b|?bs], ?dot) :-
-  mul(?a, ?b, ?product),
-  dot(?as, ?bs, ?rest),
-  add(?product, ?rest, ?dot).
-
-sum_squares([], 0.0).
-sum_squares([?x|?xs], ?total) :-
-  pow(?x, 2.0, ?squared),
-  sum_squares(?xs, ?rest),
-  add(?squared, ?rest, ?total).
-
-norm(?vector, ?norm) :-
-  sum_squares(?vector, ?sumsquares),
-  pow(?sumsquares, 0.5, ?norm).
-
-% cosine = dot(A,B) / (norm(A) * norm(B)).
-cosine_similarity(?case, ?similarity) :-
-  vector(?case, a, ?a),
-  vector(?case, b, ?b),
-  dot(?a, ?b, ?dot),
-  norm(?a, ?norma),
-  norm(?b, ?normb),
-  mul(?norma, ?normb, ?denominator),
-  div(?dot, ?denominator, ?similarity).
-
-dotProduct(?case, ?dot) :-
-  vector(?case, a, ?a),
-  vector(?case, b, ?b),
-  dot(?a, ?b, ?dot).
-
-normA(?case, ?norma) :-
-  vector(?case, a, ?a),
-  norm(?a, ?norma).
-
-normB(?case, ?normb) :-
-  vector(?case, b, ?b),
-  norm(?b, ?normb).
-
-cosineSimilarity(?case, ?similarity) :-
-  cosine_similarity(?case, ?similarity).