Fwd: [Caml-list] [ANN] OCamp - Reactive programming in the shell

[Pierre-Alexandre Voye]

Salut tout le monde, je vous transfert cette contribution d'un cameliste qui m'a bien fait marrer. Ca ressemble à un beau poisson d'avril, mais il l'a vraiment codé !

Admirez la fibonacci à la fin !

https://github.com/def-lkb/ocamp

---------- Forwarded message ----------
From: Frédéric Bour <freder...@lakaban.net>
Date: 2015-04-01 22:32 GMT+02:00
Subject: [Caml-list] [ANN] OCamp - Reactive programming in the shell
To: caml...@inria.fr


OCamp extends unix shells with constructions to express memoization, sharing of computations and reactive programming.

# Subcommands

## fire

Just wrap a unix command with "ocamp fire" to enable the extension:
  $ ocamp fire bash

This will spawn a new bash session where the following subcommands are enabled.

## hipp

  $ ocamp hipp <command>

Will memoize the output and exit status of <command>.
Later calls to the same <command> won't lead to actual execution, but just to a duplication of its previous output.
Concurrent calls to <command> will just share the same process, the beginning of the output being replayed to later callers.

The identity of a command is defined by its arguments and working directory.

## stir

  $ ocamp stir <command>

Indicate potential changes in the output if <command> was rerun.
Later calls to `hipp` will recompute <command> as if it was not yet memoized.

## (un)follow

  $ ocamp follow <command>

First, <command> is memoized if it was not the case yet.
Then changes to dependencies of <command> will trigger a reevaluation.
Use `stir` to notify a change.

(to follow is an hipp/stir reactivity).

## pull

  $ ocamp pull <command>

Closely related to `hipp`, but instead of marking dependency on the output of <command>, the dependency applies to the "effects" of <command>.

Thus, if `stir` is used:
- all pullers will be reevaluated.
- hippers will be reevaluated only if the output is different.

## Summary

  $ ocamp fire <command> - setup a new session alive until <command> exits
          pull <command> - mark dependency on effects of <command>
          hipp <command> - mark dependency on output of <command>
          stir <command> - notify that <command> might have been updated
          follow <command> - eval <command>, and reactively recompute it
                             whenever one of its dependencies change.
          unfollow <command> - stop recomputing <command> when dependencies
                               change

hipp and pull provide memoization.
stir and follow bring a flavor of reactive programming.

# Examples

## Fibonacci

  $ cat fib.sh
  #!/bin/sh
  ARG="$1"
  if [ "$ARG" -le 1 ]; then
    echo "$ARG"
  else
    A=`ocamp hipp ./fib.sh $((ARG-1))`
    B=`ocamp hipp ./fib.sh $((ARG-2))`
    echo $((A+B))
  fi

  $ time ocamp fire ./fib.sh 50
  12586269025
    real    0m0.391s
  user    0m0.153s
  sys     0m0.060s

## Build-system

`ocamp` provides simple primitives to construct and manage a dependency graph.

This might be a saner foundation to base a build-system on than make(1):
- the command focus on one specific problem
- no dsl is involved; rules can be plain unix commands, including a shell, rather than a make-flavored simulation of shell
- nothing is provided for resolving goals; indeed this is better left to tools specifically built for goal-search.

A quick'n'dirty script building ocamp itself is provided as an example.

# Future

The current release is a proof-of-concept and should be considered alpha quality.
The two features planned next are a way to make the graph persistent (all data is kept in memory atm) and an interface to debug and/or observe graph construction.

Note: code is undergoing legal review and should be available soon \o/

--
Caml-list mailing list.  Subscription management and archives:
https://sympa.inria.fr/sympa/arc/caml-list
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs

--

---------------------
https://twitter.com/#!/ontologiae/
http://linuxfr.org/users/montaigne

[Florent Marchand de Kerchove]

Dans le même ordre d’idée, il y a Parsed, un parsec pour le shell.

https://github.com/mikeizbicki/parsed/

> https://sympa.inria.fr/sympa/__arc/caml-list
> <https://sympa.inria.fr/sympa/arc/caml-list>
> Beginner's list: http://groups.yahoo.com/group/__ocaml_beginners
> <http://groups.yahoo.com/group/ocaml_beginners>
> Bug reports: http://caml.inria.fr/bin/caml-__bugs
> <http://caml.inria.fr/bin/caml-bugs>
>
>
>
> --
> ---------------------
> https://twitter.com/#!/ontologiae/ <https://twitter.com/#%21/ontologiae/>
> http://linuxfr.org/users/montaigne
>
> --
> Vous recevez ce message, car vous êtes abonné au groupe Google Groupes
> "Nantes FP".
> Pour vous désabonner de ce groupe et ne plus recevoir d'e-mails le
> concernant, envoyez un e-mail à l'adresse
> nantes-fp+...@googlegroups.com
> <mailto:nantes-fp+...@googlegroups.com>.
> Pour envoyer un message à ce groupe, envoyez un e-mail à l'adresse
> nant...@googlegroups.com <mailto:nant...@googlegroups.com>.
> Visitez ce groupe à l'adresse http://groups.google.com/group/nantes-fp.
> Pour obtenir davantage d'options, consultez la page
> https://groups.google.com/d/optout.

--
fmdkdd