Miscellaneous additions

lib/any.ml

@@ -0,0 +1,7 @@
+module type Any = sig
+  type t
+end
+
+implicit module Any_Int = struct type t = int end
+implicit module Any_String = struct type t = string end
+implicit module Any_Pair { A : Any } {B : Any } = struct type t = A.t * B.t end

lib/control.ml

@@ -1,3 +1,5 @@
+open Any
+
 (* Functor, Applicative and Monad module types *)
 module type Functor = sig
   type 'a t
@@ -176,3 +178,28 @@ end = struct
     let cons x ys = F.apply (F.fmap (fun x xs -> x :: xs) (f x)) ys in
     List.fold_right cons t (F.return [])
 end
+
+implicit module Function {A : Any} : sig
+  include Functor with type 'b t = A.t -> 'b
+  include Applicative with type 'b t := 'b t
+  include Monad with type 'b t := 'b t
+end = struct
+  type 'b t = A.t -> 'b
+
+  (* Functor *)
+  let fmap m f x = m (f x)
+
+  (* Applicative *)
+  let return x _ = x
+  let apply f g x = f x (g x)
+
+  (* Monad *)
+  let bind g f x = f (g x) x
+end
+(** (a -> b) is an instance of Monad b - it behaves like the reader monad *)
+
+implicit module Pair {A : Any} : Functor with type 'b t = A.t * 'b = struct
+  type 'b t = A.t * 'b
+
+  let fmap m (a, b) = (a, m b)
+end

lib/data.ml

@@ -1,6 +1,4 @@
-module type Any = sig
-  type t
-end
+open Any
 
 module type Show = sig
   type t

lib/dune

@@ -1,4 +1,4 @@
 (library
  (public_name imp)
- (modules Control Data Num Scope Show)
+ (modules Any Control Data Num Scope Show)
  (synopsis "Experimental library using modular implicits"))

tests/test.ml

@@ -72,3 +72,17 @@ let () =
   assert (Foldable.fold ( * ) (Some 5) 1 = 5);
   assert (Foldable.fold ( * ) None 1234 = 1234);
   assert (Traversable.traverse (fun x -> [x; x + 1]) (Some 3) = [Some 3; Some 4])
+
+let () =
+  let open Imp.Control in
+  let open implicit Imp.Any in
+  let pair x y = (x, y) in
+  assert ((fmap (fun x -> x + 1) (int_of_string)) "3" = 4);
+  assert ((return 4) "3" = 4);
+  assert ((apply pair (fun x -> x * x)) 3 = (3, 9));
+  assert ((bind (fun x -> x * x) pair) 3 = (9, 3))
+
+let () =
+  let open Imp.Control in
+  let open implicit Imp.Any in
+  assert (fmap (fun x -> x + 1) ("hello", 3) = ("hello", 4))