andreypopp / rrun Goto Github PK

[WIP] rrun allows to seamlessly run Reason/OCaml code with native speed

OCaml 99.24% Makefile 0.76%

rrun's Introduction

rrun

WIP: DO NOT USE, this piece of software isn't ready for general consumption, some things are not implemented, some things are not working properly.

rrun allows to seamlessly run Reason/OCaml code with native speed.

Motivation

rrun aims to implement the following workflow for engineering software with Reason/OCaml language:

Start writing code by opening a plain *.re or *.ml file
- ... with autocomplete and real time error reporting available
- ... having a good set of standard libraries for interacting with a system
- ... reusing 3rd party code from a local file system or from the network
Code can be run with a single command invocation rrun ./myapp.re
- ... which builds the code and caches the result
- ... and sandboxes (configurable) execution by preventing it from reading/writing to disk or accessing network

Installation (not implemented yet)

Install rrun via npm:

% npm install -g rrun

Usage

Running Code

Run Reason/OCaml code with:

% rrun ./app.re
% rrun ./app.ml

rrun uses ocamlopt to compile sources and then caches compiled artifacts, on second invocation there will be no recompilation.

Dependencies

You can specify dependencies between modules with [%import "..."] syntax:

module Url = [%import "./Url.re"]
module Chalk = [%import "https://example.com/Chalk.re"]

let url = Url.make("http://example.com");
print_endline(Chalk.red(Url.show(url)));

IDE support

There's rrun edit command which will run your configured editor (via $EDITOR) in a properly configured environment:

% rrun edit ./app.re

Sandboxed Execution

TODO

Internals

TODO

Development

Workflow

% npm install -g esy
% git clone https://github.com/andreypopp/rrun.git
% cd rrun
% esy install
% esy build
% esy "$EDITOR"

Roadmap

Sandboxed execution
Support interfaces
Build Reason code
Build OCaml code
Support [%import "./relative/path.ml"] dependencies
Support [%import "https://secure/url.ml"] dependencies

rrun's People

Contributors

Stargazers

Watchers

rrun's Issues

stdlib

We want to ship a set of libraries with rrun, I'm now thinking more about
libraries which implement portable APIs to operating system facilities rather
than data structures (though we should explore this topic too).

How to expose stdlib to user code

I think we should use [%import "..."] syntax which is used already for user
code. Currently such syntax only allows relative paths and https URLs, that
means we can use plain (non-path) strings for stdlib:

module Path = [%import "path"]
module Cmd = [%import "cmd"]

CamelCase or snake_case

Definitely CamelCase.

Concurrency primitive

All I/O should be concurrent, like in Node.

Decide what we should use:

lwt
async
repromise

I'd like to explore repromise but we might need to sync up with aantron on
that - is it ready for experimentation at least?

Proposed modules to include in stdlib

Promise - concurrency primitive exposed (repromise or whatever we've chosen).
- Promise.return
- Promise.join
- Promise.sleep
- Promise.List.map
- Promise.List.iter
Path - working with filesystem paths, I like how fpath is designed, we
might just take it and use.
Cmd - compose command invocations and execute them, I like how bos
library has Bos.Cmd and Bos.OS.Cmd, few notes regarding them though:
- While bos has two separate modules for constructing commands and running
  commands, I think we should go with a single Cmd module.
- Bos.Cmd allows to construct and empty command invocation which is then
  fails if you try executing it. I think we should disallow that and I already
  have such Cmd implementation in esy-lib/Cmd, we could take it.
- I like how bos allows you to compose command invocations with combinators
  (modified bos API in the example below):
```
let catString = (s) =>
  Cmd.(inString(s) |> run v("cat") |> outString);
```
Fs - access to file system:
- Fs.readFile
- Fs.writeFile
- Fs.listDir
- Fs.createDir
- ...
Json
Http - HTTP protocol
- Http.Fetch - HTTP client
- Http.Serve - HTTP server
CommandLine - parsing command line arguments/options. Take a look at
cmdliner maybe? Though it's not as trivial to use, might take something more
simple.