# tricu

## Introduction

tricu (pronounced "tree-shoe") is an experimental programming language written in Haskell. It is fundamentally based on the application of [Triage Calculus](https://olydis.medium.com/a-visual-introduction-to-tree-calculus-2f4a34ceffc2), an extended form of [Tree Calculus](https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf). I refer to this "family" of calculi as TC below.

tricu is the word for "tree" in Lojban: `(x1) is a tree of species/cultivar (x2)`.

In the `ext/` directory there are implementations of TC evaluators and tooling in other languages. Here be dragons; beware.

I have fully embraced the slopmachine (LLM-assisted development) for this project. Nothing is stable or sacred. We will discover sanity at the end of the journey but we won't strive for it until then.

This README.md is 100% human written. No other .md file will be until stabilization.

## Acknowledgements 

Tree Calculus was discovered by [Barry Jay](https://github.com/barry-jay-personal/blog). The addition of Triage rules were suggested by [Johannes Bader](https://johannes-bader.com/). Johannes is also the creator of [treecalcul.us](https://treecalcul.us) which has a great intuitive code playground using his language LambAda.

## REPL examples

```
tricu < -- Anything after `--` on a single line is a comment
tricu < id = (a : a) -- Lambda abstraction is eliminated to tree calculus terms
tricu < head (map (i : append i " world!") [("Hello, ")])
tricu > "Hello,  world!"
tricu < id (head (map (i : append i " world!") [("Hello, ")]))
tricu > "Hello,  world!"

tricu < -- Intensionality! We can inspect the structure of a function or data.
tricu < triage = (a b c : t (t a b) c)
tricu < test = triage "Leaf" (z : "Stem") (a b : "Fork")
tricu < test (t t)
tricu > "Stem"
tricu < -- We can even convert a term back to source code (/demos/toSource.tri)
tricu < toSource not?
tricu > "(t (t (t t) (t t t)) (t t (t t t)))"
tricu < -- or calculate its size (/demos/size.tri)
tricu < size not?
tricu > 12
```

## Installation and Use

You can easily build and run this project using [Nix](https://nixos.org/download/).

- Quick Start (REPL): 
  - `nix run git+https://git.eversole.co/James/tricu`
- Build executable in `./result/bin`: 
  - `nix build git+https://git.eversole.co/James/tricu`

`./result/bin/tricu --help`

## Usage

### CLI

Evaluate one or more files:

```sh
tricu eval program.tri
tricu eval --format decode program.tri
tricu eval --output result.txt program.tri
```

Annotated programs run normally under `eval`; annotations are metadata, not
runtime types. If you want evaluation to ignore View Contracts completely while
loading workspace modules, use unchecked mode:

```sh
tricu eval --unchecked program.tri
```

Unchecked eval parses annotation syntax, discards contract metadata, skips
producer-side View Contract checks during workspace module auto-builds, and does
not publish unchecked View refs. Executable module exports may still be cached in
the content store.

Check View Contract annotations explicitly:

```sh
tricu check program.tri
tricu check --store ./.tricu-store program.tri
```

Compile/import/export Arboricx bundles:

```sh
tricu arboricx compile --file program.tri --output program.arboricx
tricu arboricx import --file program.arboricx --module program
tricu arboricx export --module prelude --output prelude.arboricx
```

Inspect store aliases:

```sh
tricu store alias list --kind modules
tricu store alias get --kind modules prelude
```

### REPL

Running `tricu` with no subcommand starts the REPL. The REPL uses the same
filesystem content store and workspace module loader as the CLI.

Useful commands:

```text
!load FILE          load/evaluate a .tri file without printing a result
!check FILE         run View Contract checking for a file
!store [PATH]       show or set the content-addressed store
!unchecked on       evaluate loaded files without contract checking/publishing refs
!unchecked off      return to normal producer-checked module loading
!format decode      set output format by name
!env                list current in-memory bindings
```

`!load` and `!check` support filename tab completion. Normal REPL input also
supports tab completion for names currently in the REPL environment.