Re: [Caml-list] [batteries] ... how to create (format) directives

[oleg@okmij.org]

Matej Kosik wrote:
> I would be grateful if you (or somebody) sent a few links to things
> that might be regarded as combinator libraries and perhaps, if given
> combinator library existed, that would solve my problem, how it would
> make my_life_easier & my_code_more_compact than the (somewhat verbose)
> approach I am currently using (string concatenation).

Enclosed is one example of a combinator library for formatting, in
plain OCaml (even Caml-lite, probably), with no extensions, GADTs,
type classes, etc. Here is a simple demo

let ex1 = let open PrintComp in 
  pr s"1" s"2" printf

(* prints: 12 *)

(* Look!  No string concatenation operations! We separate operations
  with mere white space (and often even it is not needed
*)

let ex2 = let open PrintComp in 
  pr s"1" s"2" b"3" i 4 
  sprintf
(*
    val ex2 : string = "12<bold>3</bold>4"
*)


(* The format is really typed *)
let ex3 = let open PrintComp in 
  pr s"1" s"2" i "x" b"3" i 4 
  sprintf
(*
    Characters 50-53:
    pr s"1" s"2" i "x" b"3" i 4 
                   ^^^
Error: This expression has type string but an expression was expected of type
         int
*)


(* It is possible to avoid s" " below, so to insert interworld space
   automatically
*)

let ex4 = let open PrintComp in pr
  b"mdx" s" " it "command" br
  s"Perform a given " it "command" br
  s"Section COMMANDS describes all the supported commands."
  sprintf

(*
val ex4 : string =
  "<bold>mdx</bold> <i>command</i>\n\nPerform a given <i>command</i>\n\nSection COMMANDS describes all the supported commands."
*)

(* The formatting sequence can be interrupted, e.g.,
   to bind some common subexpressions or to perform some computations
*)

let ra = fun x f -> f x

let ex5 = let open PrintComp in pr
  b"mdx" s" " 
  (* interrupt the flow *)
  begin let cmd st = ra st it "command" in 
  fun st -> ra st (* continue with the flow *)
  cmd br
  s"Perform a given " cmd br
  s"Section COMMANDS describes all the supported commands." end
  sprintf

(*
val ex5 : string =
  "<bold>mdx</bold> <i>command</i>\n\nPerform a given <i>command</i>\n\nSection COMMANDS describes all the supported commands."
*)


Here is the implementation, of a FORTH like language for formatting.
Polyvariadic functions are possible even in plain OCaml. 

module PrintComp = struct
  (* Put this at the beginning *)
  let pr k = k []

  (* to format a string *)
  let s = fun st (str:string) k -> k (str :: st)

  (* to format a string in bold *)
  let b = fun st (str:string) k -> k ("</bold>" :: str :: "<bold>" :: st)

  (* to format a string in italics *)
  let it = fun st (str:string) k -> k ("</i>" :: str :: "<i>" :: st)

  (* to format an integer *)
  let i = fun st n k -> k (string_of_int n :: st)

  (* generate a line break *)
  let br = fun st k -> k ("\n\n" :: st)

  (* To finally print as a string *)
  let sprintf st = String.concat "" (List.rev st)

  (* To finally print on stdout *)
  let printf st = List.iter print_string (List.rev st)

  (* To finally print on channel *)
  (* similarly *)
end;;