Module PrimaveraSource

As mentioned in the following article, sometimes the trivial ways of abstracting effects or dependencies in OCaml offer ‘too much power’ (type construction through modules or continuation control for effects).

The goal of Primavera is to provide an approach compatible with inference to control its dependencies by taking advantage of OCaml's type inference and using objects.

This approach, although more limited than effects and modules, allows operations to be captured as handlers using row polymorphism of objects.

Identity

Primavera is built on top of an identity monad to abstract dependencies whose normal form is a regular value.

Prebuilt

Common monads that are already preconfigured as standard forms of effect abstraction.

Requirements

Building a Reader

Example

As is often the case, to demonstrate abstraction of effects or dependency injection, we use the usual teletype example. A programme capable of interacting with the console to print and read.

We begin by describing all possible interactions in our programme, the primitives read_line and print in an Fx module using the function Primavera.perform:

module Fx = struct
  open Primavera

  let print message = perform (fun handler -> handler#print message)
  let print_line message = print (message ^ "\n")
  let read_line () = perform (fun handler -> handler#read_line)
end

The handler passed via the Primavera.perform function is used to call one of its methods (and allow inference to track the operations that can be executed).

We can observe the signature of our module to understand how operations propagate through the type system.

  # #show_module Fx;;
  module Fx :
    sig
      val print : 'a -> ('b, < print : 'a -> 'b; .. >) Primavera.t
      val print_line : string -> ('a, < print : string -> 'a; .. >) Primavera.t
      val read_line : unit -> ('a, < read_line : 'a; .. >) Primavera.t
    end

Now that we have our operations, we can use them to describe the ancient teletype programme! To do this, we use the let* (Primavera.bind) operator to sequence operations with effects.

let teletype () =
  let open Primavera in
  let* () = Fx.print_line "What is your name?" in
  let* name = Fx.read_line () in
  Fx.print_line ("Hello " ^ name)
;;

If we inspect the type of our teletype programme, we can observe several things:

  # let t = teletype ;;
  val t :
    unit ->
    (unit, < print : string -> unit; read_line : string; .. >) Primavera.t =
    <fun>

A primavera programme generally takes the following form: 'input -> ('outpout, <set_of_operation; ..> t).

Here, we can see that our programme takes unit and returns unit, and that it propagates the following operations:

• print which takes a string and returns unit
• read_line which returns a string.

Now that we have described a programme, we need to execute it, providing concrete implementations for the operations that can be propagated, using Primavera.run and giving an object to the flag handler:

    # Primavera.run
       ~handler:object
         method print message =
           print_string message

           (* Here we hook the call of read_line to
              works in test-context  *)
           method read_line =
            "Xavier"
        end
       teletype
       ()
    What is your name?
    Hello Xavier
    - : unit = ()

Internal Modules