ocaml-mm-v2, Ocaml

Language: Layout:

(*The OCaml compiler, version 4.05.0*)

module type Machine =
  sig
    type data = int array
    val init : ?data:data -> unit -> unit
    val dump : unit -> data

type process = unit -> unit
    val process_1 : process
    val process_2 : process
    val process_3 : process
    val process_4 : process
    val process_5 : process

type decision = unit -> bool
    val decision_1 : decision
    val decision_2 : decision
    val decision_3 : decision
    val decision_4 : decision
    val decision_5 : decision
  end

module Program (M : Machine) =
  struct

let ( --> ) = ( |> )

let yes y ~no:n decision = if decision then y else n

let rec run count state =
      log_state count state ;
      let loop = run (count + 1) in
      match state with
      | Proc_1 -> () --> M.process_1 --> M.decision_1 --> yes Proc_4 ~no:Proc_3 --> loop
      | Proc_2 -> () --> M.process_2 --> M.decision_2 --> yes Proc_3 ~no:Proc_5 --> loop
      | Proc_3 -> () --> M.process_3 --> M.decision_3 --> yes Proc_2 ~no:Proc_1 --> loop
      | Proc_4 -> () --> M.process_4 --> M.decision_4 --> yes Stop   ~no:Proc_2 --> loop
      | Proc_5 -> () --> M.process_5 --> M.decision_5 --> yes Proc_4 ~no:Proc_3 --> loop
      | Stop   -> ()

and log_state count state =
      let data = M.dump () in
      Printf.printf "Step: %2d   %s   %s\n" count (state_string state) (data_string data)

and data_string data =
      data --> Array.map (Printf.sprintf " %2d") --> Array.to_list --> String.concat " "

end

module Majestio_machine : Machine =
  struct

let size = 5

let cell = Array.make size 0

type data = int array

let init ?(data=[||]) () =
      let n = min size (Array.length data) in
      if n = 0
        then Array.fill cell 0 size 0
        else Array.blit data 0 cell 0 n

let dump () = Array.copy cell

type process = unit -> unit

let process_1 () =
      cell.(0) <- cell.(0) + 1

let process_2 () =
      cell.(1) <- cell.(1) + cell.(3) + 1

let process_3 () =
      let sum_0_1 = cell.(0) + cell.(1) in
      if sum_0_1 mod 3 <> 0 then
        cell.(2) <- cell.(2) + 7

let process_4 () =
      let sum_0_2 = cell.(0) + cell.(2) in
      if sum_0_2 mod 5 <> 4 then
        cell.(3) <- cell.(3) + 1

let process_5 () =
      cell.(4) <- cell.(4) + 1

type decision = unit -> bool

let sum = Array.fold_left (+) 0

let decision_1 () = sum cell mod 2 = 0

let decision_2 () = sum cell mod 7 > 0

let decision_3 () =
      let is_even x = x mod 2 = 0 in
      Array.for_all is_even cell

let decision_4 () = sum cell > 24

let decision_5 () = cell.(4) > 0

end

let main () =
  let module Machine = Majestio_machine in
  let module Program = Program (Machine) in

Machine.init () ;
  Program.run 1 Program.Proc_1 ;
  print_endline "----------------------------------------------------------------" ;

Machine.init ~data:[| 3; 1; 14; 1; 0 |] () ;
  Program.run 9 Program.Proc_2 ;
  print_endline "----------------------------------------------------------------" ;

print_endline "done"

let () = main ()

Show compiler warnings [ + ] Show input
Compilation time: 0.11 sec, absolute running time: 0.16 sec, cpu time: 0.01 sec, memory peak: 6 Mb, absolute service time: 0,32 sec