gregerssr / asynchronous-rattus

A modal FRP language embedded in Haskell.

Introduciton

Asynchronous Rattus is a programming language embedded into GHC. It is built on top of Rattus by utilizing the Async RaTT calculus.

Usage

Asynchronous Rattus has been tested with GHC version 9.2.5. To get started with Asynchronous Rattus two different examples are included; a simple spreadsheet and a text writer. They can be accessed through following commands:

cd examples/simple-sheet
cabal run

and

cd examples/textwriter
cabal run

To run the test-suite of Asynchronous Rattus, simply run the the command cabal test

asynchronous-rattus's Issues

Standard library: O

Implement relevant standard library functionality for manipulating plain O values.

Code cleanup

• remove countAdvSelect
• remove obsolete stuff

Clock inference

We would like to implement the following.
When we're in a delay, find the clock of the delay. For adv v, this is equal to cl(v). For select x y, this is equal to the union of cl(x) and cl(y). For context: later, cl will be used at runtime.

Transform Core based on clocks

This is where the language begins to actually work. We have to swap delay for Delay, adv for adv' etc.

Code example usage

Should clearly demonstrate the async nature. And it would also be nice if the concept of clocks is easily explained from the program.

Ideas:

• Tom&Jerry
• Text editor
• Spreadsheet app

Update README and documentation

At least, reference the Async RaTT paper in README

Better error reporting

SelectMany use strict pair instead of laze tuples.

Make sure that selectMany' in Later.hs uses the strict pair from the strict module instead of the lazy tuple type

Find out how to make streams from input channels

Maybe migrate to clean repo?

Ensure Rattus guarantees hold

For instance:

• does stable checking and strictness checking still hold?
• do we check that non-stable types are not in scope under delay?

Standard library: Future

Implement a Future value and accompanying standard library. A Future value is one that can have a value now or any point later in the future, not restricted to next time step. If we implement streams on top of this, we can allow filtering on streams.

Refactor checking algorithm

We would like it to be a bit cleaner

Make test cases

Demonstrate valid and invalid programs.

Nice-to-have: allow recursion using annotation

We have hard-coded recursion to always be false, and we have chosen not to handle recursion at all. This could be a problem.

Scope checking is broken

It turns out that CheckSingleTick has limited scope checking compared to ScopeCheck. That means that the more restrictive scope rules of Rattus and Async Rattus are not enforced. We have 3 options:

1. leave it be. Explain in the report what's not working
2. re-enable ScopeCheck. This requires making ScopeCheck understand select
3. Implement scope checking in CheckSingleTick (checkExpr)

Rebranding

Make it clear that this is Async Rattus, not Rattus.

Standard library: interface between Haskell and Async Rattus

There needs to be a way to manipulate input channels. As part of this, also make stuff private again (e.g. in Primitives)

Standard library: streams

Adjust existing library and implement new functions to create a nice standard library for Asynchronous Rattus.

Should we test memory leaks somehow?

Currently, the memory leak tests are disabled, since they cannot be reproduced in Asynchronous Rattus. Do we want to port them to Asynchronous Rattus?