# tricu

## Introduction

tricu (pronounced "tree-shoe") is a purely functional interpreted language implemented in Haskell. It is fundamentally based on the application of [Tree Calculus](https://github.com/barry-jay-personal/typed_tree_calculus/blob/main/typed_program_analysis.pdf) terms, but minimal syntax sugar is included to provide a useful programming tool. 

*tricu is under active development and you should expect breaking changes with every commit.*

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

## Features

- Tree Calculus operator: `t`
- Immutable definitions: `x = t t`
- Lambda abstraction: `id = (a : a)`
- List, Number, and String literals: `[(2) ("Hello")]` 
- Function application: `not (not false)`
- Higher order/first-class functions: `map (a : append a "!") [("Hello")]`
- Intensionality blurs the distinction between functions and data (see REPL examples)
- Simple module system for code organization

## 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

tricu < -- REPL Commands:
tricu < !definitions  -- Lists all available definitions
tricu < !output       -- Change output format (Tree, FSL, AST, etc.)
tricu < !import       -- Import definitions from a file
tricu < !exit         -- Exit the REPL
tricu < !clear        -- ANSI screen clear
tricu < !save         -- Save all REPL definitions to a file that you can !import
tricu < !reset        -- Clear all REPL definitions
tricu < !version      -- Print tricu version
```

## 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`

```
tricu Evaluator and REPL

tricu [COMMAND] ... [OPTIONS]
  tricu: Exploring Tree Calculus

Common flags:
  -? --help       Display help message
  -V --version    Print version information

tricu [repl] [OPTIONS]
  Start interactive REPL

tricu eval [OPTIONS]
  Evaluate tricu and return the result of the final expression.

  -f --file=FILE  Input file path(s) for evaluation.
                    Defaults to stdin.
  -t --form=FORM  Optional output form: (tree|fsl|ast|ternary|ascii|decode).
                    Defaults to tricu-compatible `t` tree form.

tricu decode [OPTIONS]
  Decode a Tree Calculus value into a string representation.

  -f --file=FILE  Optional input file path to attempt decoding.
                    Defaults to stdin.
```

## Collaborating

I am happy to accept issue reports, pull requests, or questions about tricu [via email](mailto:james@eversole.co).

If you want to collaborate but don't want to email back-and-forth, please reach out via email once to let me know and I will provision a git.eversole.co account for you.

## Acknowledgements 

Tree Calculus was discovered by [Barry Jay](https://github.com/barry-jay-personal/blog). 

[treecalcul.us](https://treecalcul.us) is an excellent website with an intuitive Tree Calculus code playground created by [Johannes Bader](https://johannes-bader.com/) that introduced me to Tree Calculus.