A Robust Standard library for Relog is important because it allows for nominally typed side effects.

Syntax

• ✓ Newlines are Ok

CLI

• ✓ accept file names as input if they end with .rl (this is enforced)

data structures and primitive operators

• String, Integer, Tuple, List, Set, Map

FFI

• Files, Network, Processes, Unix

entry points

• eval-soft: referentially transparent, no side-effects
• eval-hard: free

Optimize Relog reduction strategy (closed forms can already be fast, but it would be nice if standard reduction was quick too)

The main bottleneck right now for this is to build an efficient data structure for contexts

• cloning into inner scopes are currently a deep copy
• similarly destructive bindings are also a deep copy

gradually introduce Prolog features into unification w/ restriction that nothing diverges.

RosettaCode, Code Golf etc. hav some programming problems which would be fun to try to solve with a non-turing-complete language.

The reduction rules at the heart of this are

$$reify \ bound \ var \ \ \frac{a↦B⊢a}{a⇻B⊢reify(B)}$$

and

$$apply \ \ \frac{unify(f,fx)⊢r}{f⇻r⊢reify(apply(r))}$$

which locally delete each bound variable or function-case before entering any sort of recursive call. This effectively prevents divergence, but practically how much does this impact logic programming?

Examples examples examples

No one should accidentally use this.

A<b,C<d>>:=R<b,d>;A<1,C<2>>
R<1,2>

This would make some rule expansions more intuitive.

This would build on the unification/reification pyramid to permit fairly generic natural algorithm expressions. This would help add to the list of RosettaCode type problems that can be solved with Relog.