Commit: 3247aeb375ae5c49ecaf6ff00059a8b5a96412ce - flitter-nix (git)

A Nix-friendly SQLite-enhanced fork of Flitter, a speedrunning split timer for Unix-style terminals

Commit MetaInfo

• Revision: 3247aeb375ae5c49ecaf6ff00059a8b5a96412ce (tree)
• Time: 2022-12-19 09:45:40
• Author: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Set up and invoke ocamlformat.

This was less than I expected! ocamlformat has improved greatly.

Change Summary

• add: .ocamlformat
• add: shell.nix
• modified: src/big.ml
• modified: src/colors.ml
• modified: src/display.ml
• modified: src/duration.ml
• modified: src/event_loop.ml
• modified: src/flitter.ml
• modified: src/hotkeys.ml
• modified: src/loadsave.ml
• modified: src/splits.ml
• modified: src/timer_types.ml

Incremental Difference

--- /dev/null
+++ b/shell.nix
@@ -0,0 +1,12 @@
+{ nixpkgs ? import <nixpkgs> {} }:
+let
+  inherit (nixpkgs) pkgs;
+in pkgs.stdenv.mkDerivation {
+  name = "flitter-dev-env";
+  buildInputs = with pkgs; [
+    # working with S-expressions
+    ocamlPackages.sexp
+    # maintaining OCaml code
+    ocamlformat
+  ];
+}

--- a/src/big.ml
+++ b/src/big.ml
@@ -2,15 +2,17 @@ open Core
 open Notty
 
 let big_font_map =
-  let font = [
-    "00000111112222233333444445555566666777778888899999  !!::..";
-    ".^^.  .|  .^^. .^^. .  | |^^^ .^^  ^^^| .^^. .^^.   |     ";
-    "|  |   |    .^   .^ |..| |..  |..    ][ ^..^ ^..|   | ^   ";
-    "|  |   |  .^   .  |    |    | |  |   |  |  |    |   ^ ^   ";
-    " ^^   ^^^ ^^^^  ^^     ^ ^^^   ^^    ^   ^^   ^^    ^   ^ ";
-  ] in
-
-  let uchar_of_char = 
+  let font =
+    [
+      "00000111112222233333444445555566666777778888899999  !!::..";
+      ".^^.  .|  .^^. .^^. .  | |^^^ .^^  ^^^| .^^. .^^.   |     ";
+      "|  |   |    .^   .^ |..| |..  |..    ][ ^..^ ^..|   | ^   ";
+      "|  |   |  .^   .  |    |    | |  |   |  |  |    |   ^ ^   ";
+      " ^^   ^^^ ^^^^  ^^     ^ ^^^   ^^    ^   ^^   ^^    ^   ^ ";
+    ]
+  in
+
+  let uchar_of_char =
     let open Caml.Uchar in
     function
     | '[' -> of_int 0x258C
@@ -25,18 +27,20 @@ let big_font_map =
 
   let extract_char_at start_idx =
     let ch = String.get fst_line start_idx in
-    let end_idx = (String.rindex_exn fst_line ch) + 1 in
-    let char_rows = List.map (List.tl_exn font) ~f:(fun line ->
-        let row_str = String.(drop_prefix (prefix line end_idx) start_idx) in
-        let row_list = String.to_list row_str in
-        Array.of_list_map row_list ~f:uchar_of_char
-      ) in
+    let end_idx = String.rindex_exn fst_line ch + 1 in
+    let char_rows =
+      List.map (List.tl_exn font) ~f:(fun line ->
+          let row_str = String.(drop_prefix (prefix line end_idx) start_idx) in
+          let row_list = String.to_list row_str in
+          Array.of_list_map row_list ~f:uchar_of_char)
+    in
 
     (char_rows, end_idx)
   in
 
   let rec map_chars_at map idx =
-    if idx >= String.length fst_line then map else
+    if idx >= String.length fst_line then map
+    else
       let img, next_idx = extract_char_at idx in
       let ch = String.get fst_line idx in
       map_chars_at (Map.add_exn map ~key:ch ~data:img) next_idx
@@ -46,6 +50,5 @@ let big_font_map =
 
 let image_of_string attr str =
   List.map (String.to_list str) ~f:(fun ch ->
-      List.map (Map.find_exn big_font_map ch) ~f:(I.uchars attr)
-      |> I.vcat
-    ) |> I.hcat
\ No newline at end of file
+      List.map (Map.find_exn big_font_map ch) ~f:(I.uchars attr) |> I.vcat)
+  |> I.hcat

--- a/src/colors.ml
+++ b/src/colors.ml
@@ -5,19 +5,17 @@ let color_of_hexstring str =
   match Color.of_hexstring str with
   | None -> failwith "Failed to derive color from hexstring"
   | Some color ->
-    let rgba = Color.to_rgba color in
-    A.rgb_888 ~r:rgba.r ~g:rgba.g ~b:rgba.b
+      let rgba = Color.to_rgba color in
+      A.rgb_888 ~r:rgba.r ~g:rgba.g ~b:rgba.b
 
 let color_of_hsl h s l =
   let hsl = Color.of_hsl h s l in
   let rgba = Color.to_rgba hsl in
   A.rgb_888 ~r:rgba.r ~g:rgba.g ~b:rgba.b
 
-let default_bg = A.(bg (color_of_hexstring "#2f3542")) 
-let selection_bg = A.(bg (color_of_hexstring "#485460")) 
-
-let attr_of_hexstring str =
-  A.(fg (color_of_hexstring str) ++ default_bg)
+let default_bg = A.(bg (color_of_hexstring "#2f3542"))
+let selection_bg = A.(bg (color_of_hexstring "#485460"))
+let attr_of_hexstring str = A.(fg (color_of_hexstring str) ++ default_bg)
 
 (* https://flatuicolors.com/palette/cn *)
 (* TODO Find better color palette *)
@@ -31,6 +29,8 @@ let label = attr_of_hexstring "#a4b0be"
 
 let rainbow () =
   let period = 3. in
-  let h = Float.mod_float (Core_unix.gettimeofday ()) period /. period *. 360. in
+  let h =
+    Float.mod_float (Core_unix.gettimeofday ()) period /. period *. 360.
+  in
   let rb = color_of_hsl h 1. 0.7 in
-  A.(fg rb ++ default_bg ++ st bold)
\ No newline at end of file
+  A.(fg rb ++ default_bg ++ st bold)

--- a/src/display.ml
+++ b/src/display.ml
@@ -9,10 +9,9 @@ let left_pad width i =
   I.hpad (width - I.width i) 0 i
 
 let center_pad width i =
-  if I.width i > width
-  then I.hcrop 0 (I.width i - width) i
+  if I.width i > width then I.hcrop 0 (I.width i - width) i
   else
-    let pad = (width - I.width i) in
+    let pad = width - I.width i in
     let lpad = pad / 2 in
     let rpad = pad - lpad in
     I.hpad lpad rpad i
@@ -31,9 +30,10 @@ let preamble timer width =
   I.(title <-> category)
 
 let splits_header timer width =
-  let labels = match timer.wr with
-    | Some _ -> ["Delta"; "Sgmt"; "Time"; "WR"] 
-    | None -> ["Delta"; "Sgmt"; "Time"]
+  let labels =
+    match timer.wr with
+    | Some _ -> [ "Delta"; "Sgmt"; "Time"; "WR" ]
+    | None -> [ "Delta"; "Sgmt"; "Time" ]
   in
 
   let colored = List.map ~f:(I.string Colors.label) labels in
@@ -58,18 +58,18 @@ let time_status timer split_num =
     else
       color depends on whether currently ahead and how lead/loss compares to last available lead/loss
   *)
-
-  if Splits.is_gold timer split_num then Gold else
+  if Splits.is_gold timer split_num then Gold
+  else
     match Splits.ahead_by timer split_num with
     | None -> Ahead_gain
-    | Some delta ->
-      match Splits.ahead_by timer (split_num - 1) with
-      | None -> (if delta < 0 then Ahead_gain else Behind_loss)
-      | Some prev_delta -> (
-          if delta < 0
-          then if delta < prev_delta then Ahead_gain else Ahead_loss
-          else if delta > prev_delta then Behind_loss else Behind_gain
-        )
+    | Some delta -> (
+        match Splits.ahead_by timer (split_num - 1) with
+        | None -> if delta < 0 then Ahead_gain else Behind_loss
+        | Some prev_delta ->
+            if delta < 0 then
+              if delta < prev_delta then Ahead_gain else Ahead_loss
+            else if delta > prev_delta then Behind_loss
+            else Behind_gain)
 
 let time_color timer split_num =
   match time_status timer split_num with
@@ -80,39 +80,39 @@ let time_color timer split_num =
   | Gold -> Colors.rainbow ()
 
 let show_delta timer split_num =
-  (* if previous split or behind or 
-      (if gold available and segment time avail and seg slower than gold): 
+  (* if previous split or behind or
+      (if gold available and segment time avail and seg slower than gold):
        show
-     else 
-       hide 
+     else
+       hide
   *)
   match timer.state with
   | Idle -> false
-  | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) ->
-    if split_num < Array.length splits then true else
-      (match time_status timer split_num with
-       | Behind_gain | Behind_loss -> true
-       | Ahead_gain | Ahead_loss | Gold ->
-         let sgmt = Splits.segment_time timer split_num in
-         let gold = timer.golds.(split_num).duration in
-         (match sgmt, gold with
-          | Some s, Some g -> s > g
-          | _ -> false
-         )
-      )
+  | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) -> (
+      if split_num < Array.length splits then true
+      else
+        match time_status timer split_num with
+        | Behind_gain | Behind_loss -> true
+        | Ahead_gain | Ahead_loss | Gold -> (
+            let sgmt = Splits.segment_time timer split_num in
+            let gold = timer.golds.(split_num).duration in
+            match (sgmt, gold) with Some s, Some g -> s > g | _ -> false))
 
 let split_row timer width i =
-  let bg_attr = match timer.state with
+  let bg_attr =
+    match timer.state with
     | Idle | Done _ -> Colors.default_bg
     | Timing (splits, _) | Paused (splits, _, _) ->
-      if i = Array.length splits then Colors.selection_bg else Colors.default_bg
+        if i = Array.length splits then Colors.selection_bg
+        else Colors.default_bg
   in
   let uncolored_attr = A.(Colors.text ++ bg_attr) in
 
-  let curr_split = match timer.state with
+  let curr_split =
+    match timer.state with
     | Idle -> -1
     | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) ->
-      Array.length splits
+        Array.length splits
   in
   let show_comparison = i > curr_split in
 
@@ -120,24 +120,22 @@ let split_row timer width i =
 
   (* Compute the split's ahead/behind time image *)
   let delta_image =
-    if show_comparison then
-      I.string uncolored_attr "-"
+    if show_comparison then I.string uncolored_attr "-"
     else
       match Splits.ahead_by timer i with
       | None -> I.string uncolored_attr "-"
-      | Some delta -> (
-          if not (show_delta timer i) then I.string uncolored_attr "" else
+      | Some delta ->
+          if not (show_delta timer i) then I.string uncolored_attr ""
+          else
             let time_str = Duration.to_string_plus delta 1 in
             let color = A.(time_color timer i ++ bg_attr) in
             I.string color time_str
-        )
   in
 
   (* Compute the image of the split's segment time *)
   let sgmt_image =
     let seg_time =
-      if show_comparison
-      then Splits.archived_segment_time timer i
+      if show_comparison then Splits.archived_segment_time timer i
       else Splits.segment_time timer i
     in
 
@@ -148,50 +146,50 @@ let split_row timer width i =
 
   (* Compute the image of the split's absolute time *)
   let time =
-    if show_comparison
-    then Splits.archived_split_time timer i
+    if show_comparison then Splits.archived_split_time timer i
     else Splits.split_time timer i
   in
-  let time_str = match time with
-    | Some t -> Duration.to_string t 1
-    | None -> "-"
+  let time_str =
+    match time with Some t -> Duration.to_string t 1 | None -> "-"
   in
   let time_image = I.string uncolored_attr time_str in
 
   (* Compute the image of the WR comparison cell *)
-  let wr_image = match timer.wr with
+  let wr_image =
+    match timer.wr with
     | None -> None
-    | Some wr_run ->
-      let default_img = 
-        match wr_run.splits.(i).time with
-        | Some t -> Some (I.string uncolored_attr (Duration.to_string t 2))
-        | None -> Some (I.string uncolored_attr "-")
-      in
-
-      if i >= curr_split then default_img else
-
-        (* Determine how much we're ahead or behind WR *)
-        match timer.state with
-        | Idle -> default_img
-        | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) -> (
-            match splits.(i), wr_run.splits.(i).time with
-            | Some curr_t, Some wr_t ->
-              let delta = curr_t - wr_t in
-              let delta_str = Duration.to_string_plus delta 2 in
-              let delta_color = if delta < 0 then Colors.ahead_gain else Colors.behind_gain in
-              Some (I.string delta_color delta_str)
-            | _ -> Some (I.string uncolored_attr "-")
-          )
+    | Some wr_run -> (
+        let default_img =
+          match wr_run.splits.(i).time with
+          | Some t -> Some (I.string uncolored_attr (Duration.to_string t 2))
+          | None -> Some (I.string uncolored_attr "-")
+        in
+
+        if i >= curr_split then default_img
+        else
+          (* Determine how much we're ahead or behind WR *)
+          match timer.state with
+          | Idle -> default_img
+          | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) -> (
+              match (splits.(i), wr_run.splits.(i).time) with
+              | Some curr_t, Some wr_t ->
+                  let delta = curr_t - wr_t in
+                  let delta_str = Duration.to_string_plus delta 2 in
+                  let delta_color =
+                    if delta < 0 then Colors.ahead_gain else Colors.behind_gain
+                  in
+                  Some (I.string delta_color delta_str)
+              | _ -> Some (I.string uncolored_attr "-")))
   in
 
   (* Combine the three time columns together with proper padding *)
-  let time_cells = match wr_image with
-    | Some wr -> [delta_image; sgmt_image; time_image; wr]
-    | None -> [delta_image; sgmt_image; time_image]
+  let time_cells =
+    match wr_image with
+    | Some wr -> [ delta_image; sgmt_image; time_image; wr ]
+    | None -> [ delta_image; sgmt_image; time_image ]
   in
   let time_cols_combined =
-    List.map time_cells ~f:(left_pad time_col_width)
-    |> I.hcat
+    List.map time_cells ~f:(left_pad time_col_width) |> I.hcat
   in
 
   (* Add the split title and background color to fill in the padding *)
@@ -204,87 +202,91 @@ let splits timer width =
   |> Array.to_list |> I.vcat
 
 let big_timer timer width =
-  let time, color = match timer.state with
-    | Idle -> 0, Colors.idle
-
+  let time, color =
+    match timer.state with
+    | Idle -> (0, Colors.idle)
     | Timing (splits, start_time) ->
-      let time = Duration.since start_time in
-      let color = time_color timer (Array.length splits) in
-      time, color
-
+        let time = Duration.since start_time in
+        let color = time_color timer (Array.length splits) in
+        (time, color)
     | Paused (splits, start_time, pause_time) ->
-      let time = Duration.between start_time pause_time in
-      let color = time_color timer (Array.length splits) in
-      time, color
-
+        let time = Duration.between start_time pause_time in
+        let color = time_color timer (Array.length splits) in
+        (time, color)
     | Done (splits, _) -> (
         let last_split_num = Array.length splits - 1 in
         match splits.(last_split_num) with
         | None -> failwith "Last split found empty on done"
         | Some time -> (
             match timer.comparison with
-            | None -> time, Colors.ahead_gain
+            | None -> (time, Colors.ahead_gain)
             | Some comp -> (
                 match comp.splits.(last_split_num).time with
                 | None -> failwith "Last split of comparison found empty"
                 | Some comp_time ->
-                  let color = if time < comp_time then Colors.rainbow () else Colors.behind_loss in
-                  time, color
-              )
-          )
-      )
+                    let color =
+                      if time < comp_time then Colors.rainbow ()
+                      else Colors.behind_loss
+                    in
+                    (time, color))))
   in
 
-  Duration.to_string time 2
-  |> Big.image_of_string color
-  |> left_pad width
+  Duration.to_string time 2 |> Big.image_of_string color |> left_pad width
 
 let previous_segment timer width =
   let desc_img = I.string Colors.default_bg "Previous Segment" in
   let empty_time_img = I.string Colors.default_bg "-" in
 
-  let time_img = match timer.state with
+  let time_img =
+    match timer.state with
     | Idle -> empty_time_img
-    | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) ->
-      let curr_split = Array.length splits in
-      let prev_delta = Splits.ahead_by timer (curr_split - 1) in
-      let prev_prev_delta = Splits.ahead_by timer (curr_split - 2) in
-      (match prev_delta, prev_prev_delta with
-       | Some pd, Some ppd ->
-         let diff = pd - ppd in
-         let diff_str = Duration.to_string_plus diff 2 in
-         let color = if diff < 0 then Colors.ahead_gain else Colors.behind_loss in
-         I.string color diff_str
-       | _ -> empty_time_img
-      )
+    | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) -> (
+        let curr_split = Array.length splits in
+        let prev_delta = Splits.ahead_by timer (curr_split - 1) in
+        let prev_prev_delta = Splits.ahead_by timer (curr_split - 2) in
+        match (prev_delta, prev_prev_delta) with
+        | Some pd, Some ppd ->
+            let diff = pd - ppd in
+            let diff_str = Duration.to_string_plus diff 2 in
+            let color =
+              if diff < 0 then Colors.ahead_gain else Colors.behind_loss
+            in
+            I.string color diff_str
+        | _ -> empty_time_img)
   in
 
   join_pad width desc_img time_img
 
 let best_possible_time timer width =
-  let t = match timer.state with
+  let t =
+    match timer.state with
     | Idle -> Splits.gold_sum timer 0 (Array.length timer.split_names)
-    | Timing (splits, _) | Paused (splits, _, _) ->
-      let curr_split = Array.length splits in
-      let total_splits = Array.length timer.split_names in
-
-      let future_sob = Splits.gold_sum timer (curr_split + 1) (total_splits) in
-      let curr_gold = (Splits.updated_golds timer).(curr_split).duration in
-      let last_split_time = if curr_split = 0 then Some 0 else splits.(curr_split - 1) in
-      let curr_seg = Splits.segment_time timer curr_split in
-
-      (match future_sob, curr_gold, last_split_time, curr_seg with
-       | Some future_sob', Some curr_gold', Some last_split_time', Some curr_seg' ->
-         Some (last_split_time' + max curr_seg' curr_gold' + future_sob')
-       | _ -> None
-      )
+    | Timing (splits, _) | Paused (splits, _, _) -> (
+        let curr_split = Array.length splits in
+        let total_splits = Array.length timer.split_names in
+
+        let future_sob = Splits.gold_sum timer (curr_split + 1) total_splits in
+        let curr_gold = (Splits.updated_golds timer).(curr_split).duration in
+        let last_split_time =
+          if curr_split = 0 then Some 0 else splits.(curr_split - 1)
+        in
+        let curr_seg = Splits.segment_time timer curr_split in
+
+        match (future_sob, curr_gold, last_split_time, curr_seg) with
+        | ( Some future_sob',
+            Some curr_gold',
+            Some last_split_time',
+            Some curr_seg' ) ->
+            Some (last_split_time' + max curr_seg' curr_gold' + future_sob')
+        | _ -> None)
     | Done (splits, _) -> splits.(Array.length splits - 1)
   in
 
-  let time_img = match t with
+  let time_img =
+    match t with
     | Some t' ->
-      let time_str = Duration.to_string t' 2 in
-      I.string Colors.text time_str
+        let time_str = Duration.to_string t' 2 in
+        I.string Colors.text time_str
     | None -> I.string Colors.text "-"
   in
 
@@ -293,7 +295,8 @@ let best_possible_time timer width =
 
 let sob timer width =
   let sob_time = Splits.gold_sum timer 0 (Array.length timer.split_names) in
-  let sob_img = match sob_time with
+  let sob_img =
+    match sob_time with
     | Some sob -> I.string Colors.text (Duration.to_string sob 2)
     | None -> I.empty
   in
@@ -304,10 +307,9 @@ let sob timer width =
 (* Result might be slightly bigger than given size *)
 let rec subdivide_space color w h max_size =
   if w > max_size || h > max_size then
-    let subspace = subdivide_space color (w / 2 + 1) (h / 2 + 1) max_size in
-    I.((subspace <|> subspace) <-> (subspace <|> subspace))
-  else
-    I.char color ' ' w h
+    let subspace = subdivide_space color ((w / 2) + 1) ((h / 2) + 1) max_size in
+    I.(subspace <|> subspace <-> (subspace <|> subspace))
+  else I.char color ' ' w h
 
 let display timer (w, h) =
   (* TODO remedy this Notty bug workaround
@@ -319,28 +321,18 @@ let display timer (w, h) =
      a few different terminals (Gnome-terminal, Termite, urxvt, not xterm though)
   *)
   I.(
-    (
-      preamble timer w <->
-      void w 1 <->
-      splits_header timer w <->
-      splits timer w <->
-      void w 1 <->
-      big_timer timer w <->
-      previous_segment timer w <->
-      sob timer w <->
-      best_possible_time timer w
-    ) </> subdivide_space Colors.default_bg w h 10
-  )
+    preamble timer w <-> void w 1 <-> splits_header timer w <-> splits timer w
+    <-> void w 1 <-> big_timer timer w <-> previous_segment timer w
+    <-> sob timer w <-> best_possible_time timer w
+    </> subdivide_space Colors.default_bg w h 10)
 
 type t = Notty_unix.Term.t
 
-let make () =
-  Notty_unix.Term.create ()
+let make () = Notty_unix.Term.create ()
 
 let draw term timer =
   let open Notty_unix in
   let image = display timer (Term.size term) in
   Term.image term image
 
-let close term =
-  Notty_unix.Term.release term
+let close term = Notty_unix.Term.release term

--- a/src/duration.ml
+++ b/src/duration.ml
@@ -10,8 +10,8 @@ let hour : t = minute * 60
 let day : t = hour * 60
 
 let compiled_re =
-  {|^(?:(?:(?:(\d+):)?(\d+):)?(\d+):)?(\d+)(?:\.(\d{1,3}))?$|}
-  |> Re.Perl.re |> Re.compile
+  {|^(?:(?:(?:(\d+):)?(\d+):)?(\d+):)?(\d+)(?:\.(\d{1,3}))?$|} |> Re.Perl.re
+  |> Re.compile
 
 let string_valid = Re.execp compiled_re
 
@@ -22,36 +22,35 @@ let left_pad_zeros_char_list str size =
   prepend (String.to_list str) (size - String.length str)
 
 let left_pad_zeros size str =
-  left_pad_zeros_char_list str size
-  |> String.of_char_list
+  left_pad_zeros_char_list str size |> String.of_char_list
 
 let of_string str =
   match Re.exec_opt compiled_re str with
   | None -> None
   | Some groups ->
-    let group_strs = Re.Group.all groups in
+      let group_strs = Re.Group.all groups in
 
-    let to_int_default x = if String.length x = 0 then 0 else Int.of_string x in
+      let to_int_default x =
+        if String.length x = 0 then 0 else Int.of_string x
+      in
 
-    let days = group_strs.(1) |> to_int_default in
-    let hours = group_strs.(2) |> to_int_default in
-    let minutes = group_strs.(3) |> to_int_default in
-    let seconds = group_strs.(4) |> to_int_default in
-    let millis = group_strs.(5) |> left_pad_zeros 3 |> to_int_default in
+      let days = group_strs.(1) |> to_int_default in
+      let hours = group_strs.(2) |> to_int_default in
+      let minutes = group_strs.(3) |> to_int_default in
+      let seconds = group_strs.(4) |> to_int_default in
+      let millis = group_strs.(5) |> left_pad_zeros 3 |> to_int_default in
 
-    Some (
-      day * days +
-      hour * hours +
-      minute * minutes +
-      second * seconds +
-      milli * millis
-    )
+      Some
+        ((day * days) + (hour * hours) + (minute * minutes) + (second * seconds)
+       + (milli * millis))
 
-let t_of_sexp sexp = match sexp with
+let t_of_sexp sexp =
+  match sexp with
   | Sexp.List _ -> of_sexp_error "Durations should be strings, not lists" sexp
-  | Sexp.Atom s -> match of_string s with
-    | None -> of_sexp_error "Invalid duration string" sexp
-    | Some d -> d
+  | Sexp.Atom s -> (
+      match of_string s with
+      | None -> of_sexp_error "Invalid duration string" sexp
+      | Some d -> d)
 
 let to_string_pos duration decimals =
   let days = duration / day in
@@ -66,37 +65,31 @@ let to_string_pos duration decimals =
   let seconds = duration_minute / second in
   let millis = duration_minute % second in
 
-  let millis_str = 
+  let millis_str =
     let zero_padded = left_pad_zeros 3 (Int.to_string millis) in
     String.prefix zero_padded decimals
   in
-  let seconds_str = 
+  let seconds_str =
     let str = Int.to_string seconds in
     if duration >= minute then left_pad_zeros 2 str else str
   in
 
   let minutes_str =
-    if duration >= hour
-    then (Int.to_string minutes |> left_pad_zeros 2) ^ ":"
-    else if duration >= minute then Int.to_string minutes ^ ":" else ""
+    if duration >= hour then (Int.to_string minutes |> left_pad_zeros 2) ^ ":"
+    else if duration >= minute then Int.to_string minutes ^ ":"
+    else ""
   in
 
   let hours_str =
-    if duration >= day
-    then (Int.to_string hours |> left_pad_zeros 2) ^ ":"
-    else if duration >= hour then Int.to_string hours ^ ":" else ""
+    if duration >= day then (Int.to_string hours |> left_pad_zeros 2) ^ ":"
+    else if duration >= hour then Int.to_string hours ^ ":"
+    else ""
   in
 
   let days_str = if duration >= day then Int.to_string days ^ ":" else "" in
 
-  String.concat [
-    days_str; 
-    hours_str;
-    minutes_str; 
-    seconds_str;
-    ".";
-    millis_str;
-  ]
+  String.concat
+    [ days_str; hours_str; minutes_str; seconds_str; "."; millis_str ]
 
 let to_string duration decimals =
   if duration < 0 then "-" ^ to_string_pos (-duration) decimals
@@ -108,8 +101,5 @@ let to_string_plus duration decimals =
   let str = to_string duration decimals in
   if duration >= 0 then "+" ^ str else str
 
-let between start finish =
-  (finish -. start) *. 1000. |> Int.of_float
-
-let since time_float =
-  between time_float (Core_unix.gettimeofday ())
+let between start finish = (finish -. start) *. 1000. |> Int.of_float
+let since time_float = between time_float (Core_unix.gettimeofday ())

--- a/src/event_loop.ml
+++ b/src/event_loop.ml
@@ -17,7 +17,9 @@ let draw_event flitter =
 
   let deadline = flitter.last_draw +. period in
   let delay = deadline -. Core_unix.gettimeofday () in
-  let%lwt () = if Float.(delay > 0.) then Lwt_unix.sleep delay else Lwt.return_unit in
+  let%lwt () =
+    if Float.(delay > 0.) then Lwt_unix.sleep delay else Lwt.return_unit
+  in
   Lwt.return Draw_tick
 
 let keyboard_event flitter =
@@ -32,143 +34,131 @@ let array_replace arr i value =
 
 let handle_key flitter (t, key_str) =
   let timer = flitter.timer in
-  let new_timer = match flitter.timer.state with
+  let new_timer =
+    match flitter.timer.state with
     | Idle -> (
         match key_str with
-        | "space" | "j" -> {
-            timer with
-            state = Timing ([||], t)
-          }
+        | "space" | "j" -> { timer with state = Timing ([||], t) }
         | "q" -> raise Stdlib.Exit
-        | _ -> timer
-      )
-
+        | _ -> timer)
     | Timing (splits, start_time) -> (
         let curr_split = Array.length splits in
         match key_str with
-        | "space" | "j" -> 
-          let curr_split_time = Some (Duration.between start_time t) in
-          let new_splits = Array.append splits [|curr_split_time|] in
-
-          let new_state = 
-            if Array.length new_splits = Array.length timer.split_names
-            then Done (new_splits, start_time)
-            else Timing (new_splits, start_time)
-          in
-          {timer with state = new_state}
-
-        | "k" -> 
-          let new_state =
-            match curr_split with
-            | 0 -> Idle
-            | 1 -> Timing ([||], start_time)
-            | _ -> Timing ((Array.slice splits 0 (curr_split - 1)), start_time)
-          in
-          {timer with state = new_state}
-
-        | "backspace" | "delete" -> {timer with state = Paused (splits, start_time, t)}
-
-        | "d" -> 
-          let new_state =
-            if curr_split > 0 then
-              let new_splits = array_replace splits (curr_split - 1) None in
-              Timing (new_splits, start_time)
-            else
-              Idle
-          in
-          {timer with state = new_state}
-
-        | _ -> timer
-      )
-
+        | "space" | "j" ->
+            let curr_split_time = Some (Duration.between start_time t) in
+            let new_splits = Array.append splits [| curr_split_time |] in
+
+            let new_state =
+              if Array.length new_splits = Array.length timer.split_names then
+                Done (new_splits, start_time)
+              else Timing (new_splits, start_time)
+            in
+            { timer with state = new_state }
+        | "k" ->
+            let new_state =
+              match curr_split with
+              | 0 -> Idle
+              | 1 -> Timing ([||], start_time)
+              | _ -> Timing (Array.slice splits 0 (curr_split - 1), start_time)
+            in
+            { timer with state = new_state }
+        | "backspace" | "delete" ->
+            { timer with state = Paused (splits, start_time, t) }
+        | "d" ->
+            let new_state =
+              if curr_split > 0 then
+                let new_splits = array_replace splits (curr_split - 1) None in
+                Timing (new_splits, start_time)
+              else Idle
+            in
+            { timer with state = new_state }
+        | _ -> timer)
     | Paused (splits, start_time, pause_time) -> (
         match key_str with
-        | "space" | "j" -> 
-          let new_state = Timing (splits, start_time +. t -. pause_time) in
-          {timer with state = new_state}
-
-        | "backspace" -> 
-          let new_timer = {
-            timer with 
-            state = Idle;
-            golds = Splits.updated_golds timer;
-            attempts = timer.attempts + 1;
-          } in
-          Loadsave.save new_timer;
-          new_timer
-
-        | "delete" -> {timer with state = Idle}
-        | _ -> timer
-      )
-
+        | "space" | "j" ->
+            let new_state = Timing (splits, start_time +. t -. pause_time) in
+            { timer with state = new_state }
+        | "backspace" ->
+            let new_timer =
+              {
+                timer with
+                state = Idle;
+                golds = Splits.updated_golds timer;
+                attempts = timer.attempts + 1;
+              }
+            in
+            Loadsave.save new_timer;
+            new_timer
+        | "delete" -> { timer with state = Idle }
+        | _ -> timer)
     | Done (splits, start_time) -> (
         match key_str with
         | "space" | "backspace" ->
-          let archived_run = Splits.archive_done_run timer splits in
-          let pb = Splits.updated_pb timer in
-
-          let new_timer = {
-            timer with
-            state = Idle;
-            golds = Splits.updated_golds timer;
-            attempts = timer.attempts + 1;
-            completed = timer.completed + 1;
-            history = archived_run :: timer.history; 
-            pb = pb;
-            comparison = pb;
-          } in
-
-          Loadsave.save new_timer;
-          new_timer
-
-        | "delete" -> {timer with state = Idle}
-
-        | "k" -> 
-          let new_splits = if Array.length splits = 1 
-            then [||] 
-            else Array.(slice splits 0 (length splits - 1)) 
-          in
-          {timer with state = Timing (new_splits, start_time)}
-
+            let archived_run = Splits.archive_done_run timer splits in
+            let pb = Splits.updated_pb timer in
+
+            let new_timer =
+              {
+                timer with
+                state = Idle;
+                golds = Splits.updated_golds timer;
+                attempts = timer.attempts + 1;
+                completed = timer.completed + 1;
+                history = archived_run :: timer.history;
+                pb;
+                comparison = pb;
+              }
+            in
+
+            Loadsave.save new_timer;
+            new_timer
+        | "delete" -> { timer with state = Idle }
+        | "k" ->
+            let new_splits =
+              if Array.length splits = 1 then [||]
+              else Array.(slice splits 0 (length splits - 1))
+            in
+            { timer with state = Timing (new_splits, start_time) }
         | "q" -> raise Stdlib.Exit
-        | _ -> timer
-      )
+        | _ -> timer)
   in
-  {flitter with timer = new_timer}
+  { flitter with timer = new_timer }
 
 let handle_draw flitter =
   let draw_time = Core_unix.gettimeofday () in
   Display.draw flitter.display flitter.timer;
-  {flitter with last_draw = draw_time}
+  { flitter with last_draw = draw_time }
 
 let rec handle_events flitter events =
   match events with
-  | evt :: remaining_evts -> (
-      let new_flitter = match evt with
+  | evt :: remaining_evts ->
+      let new_flitter =
+        match evt with
         | Draw_tick -> handle_draw flitter
         | Key keypress -> handle_key flitter keypress
       in
 
       handle_events new_flitter remaining_evts
-    )
-
   | [] -> flitter
 
 let make timer =
   let%lwt hotkeys_stream = Hotkeys.make_stream () in
-  Lwt.return {
-    timer = timer;
-    display = Display.make ();
-    (* Make sure we're due for a draw *)
-    last_draw = Core_unix.gettimeofday () -. (1. /. draw_rate);
-    hotkeys_stream = hotkeys_stream;
-  }
+  Lwt.return
+    {
+      timer;
+      display = Display.make ();
+      (* Make sure we're due for a draw *)
+      last_draw = Core_unix.gettimeofday () -. (1. /. draw_rate);
+      hotkeys_stream;
+    }
 
 let loop flitter =
   let rec loop' flitter =
-    let%lwt events = Lwt.npick [(draw_event flitter); (keyboard_event flitter)] in
+    let%lwt events = Lwt.npick [ draw_event flitter; keyboard_event flitter ] in
     match handle_events flitter events with
     | new_flitter -> loop' new_flitter
-    | exception Stdlib.Exit -> Display.close flitter.display; Lwt.return ()
+    | exception Stdlib.Exit ->
+        Display.close flitter.display;
+        Lwt.return ()
   in
-  loop' flitter
\ No newline at end of file
+  loop' flitter

--- a/src/flitter.ml
+++ b/src/flitter.ml
@@ -1,8 +1,6 @@
-let usage = 
-  "Usage:\n" ^
-
-  "flitter <splits_path>\n" ^
-  "Open the splits file pointed to by `splits_path`.\n"
+let usage =
+  "Usage:\n" ^ "flitter <splits_path>\n"
+  ^ "Open the splits file pointed to by `splits_path`.\n"
 
 let run_event_loop timer =
   let%lwt event_loop = Event_loop.make timer in
@@ -10,8 +8,7 @@ let run_event_loop timer =
 
 let run () =
   match Sys.argv with
-  | [|_; path|] ->
-    let timer = Loadsave.load path in
-    Lwt_main.run (run_event_loop timer)
-
-  | _ -> print_string usage
\ No newline at end of file
+  | [| _; path |] ->
+      let timer = Loadsave.load path in
+      Lwt_main.run (run_event_loop timer)
+  | _ -> print_string usage

--- a/src/hotkeys.ml
+++ b/src/hotkeys.ml
@@ -3,7 +3,8 @@ open Core
 type keypress = float * string
 type t = keypress Lwt_stream.t
 
-let python_detect_keys = {|
+let python_detect_keys =
+  {|
 import time
 import sys
 from pynput import keyboard
@@ -35,33 +36,33 @@ with keyboard.Listener(on_press=on_press) as listener:
 |}
 
 let stream_of_python python_src =
-  let cmd = "", [|"python3"; "-"|] in
+  let cmd = ("", [| "python3"; "-" |]) in
   let pipe_out_fd, pipe_out_fd_unix = Lwt_unix.pipe_out () in
   let () = Lwt_unix.set_close_on_exec pipe_out_fd_unix in
   let redir = `FD_move pipe_out_fd in
 
   let py_stream = Lwt_process.pread_lines ~stdin:redir cmd in
 
-  let%lwt n = Lwt_unix.write_string pipe_out_fd_unix python_src 0 (String.length python_src) in
-  if n < String.length python_src then failwith "Failed to write python to pipe" 
-  else 
+  let%lwt n =
+    Lwt_unix.write_string pipe_out_fd_unix python_src 0
+      (String.length python_src)
+  in
+  if n < String.length python_src then failwith "Failed to write python to pipe"
+  else
     let%lwt () = Lwt_unix.close pipe_out_fd_unix in
     Lwt.return py_stream
 
 let make_stream () =
   let%lwt str_stream = stream_of_python python_detect_keys in
-  let stream = Lwt_stream.from (fun () ->
-      match%lwt Lwt_stream.get str_stream with
-      | Some str -> (
-          match String.split str ~on:' ' with
-          | time_str :: key_str :: [] -> 
-            Lwt.return (Some ((Float.of_string time_str), key_str))
-
-          | _ -> failwith "Invalid output from Python keypress server"
-
-        )
-      | None -> Lwt.return None
-    )
+  let stream =
+    Lwt_stream.from (fun () ->
+        match%lwt Lwt_stream.get str_stream with
+        | Some str -> (
+            match String.split str ~on:' ' with
+            | [ time_str; key_str ] ->
+                Lwt.return (Some (Float.of_string time_str, key_str))
+            | _ -> failwith "Invalid output from Python keypress server")
+        | None -> Lwt.return None)
   in
 
-  Lwt.return stream
\ No newline at end of file
+  Lwt.return stream

--- a/src/loadsave.ml
+++ b/src/loadsave.ml
@@ -4,34 +4,24 @@ open Core
 type split = {
   title : string;
   time : Duration.t;
-  is_gold : bool [@default false];
+  is_gold : bool; [@default false]
 }
 [@@deriving sexp]
 
 (* A gold split. *)
-type gold = {
-  title : string;
-  duration : Duration.t;
-}
-[@@deriving sexp]
-
-type archived_run = {
-  attempt : int;
-  splits : split array;
-}
-[@@deriving sexp]
+type gold = { title : string; duration : Duration.t } [@@deriving sexp]
+type archived_run = { attempt : int; splits : split array } [@@deriving sexp]
 
 type game = {
   title : string;
   category : string;
   attempts : int;
   completed : int;
-
   split_names : string array;
-  golds : gold array [@sexp.omit_nil];
-  personal_best : archived_run option [@sexp.option];
-  world_record : archived_run option [@sexp.option];
-  history : archived_run list [@sexp.omit_nil];
+  golds : gold array; [@sexp.omit_nil]
+  personal_best : archived_run option; [@sexp.option]
+  world_record : archived_run option; [@sexp.option]
+  history : archived_run list; [@sexp.omit_nil]
 }
 [@@deriving sexp]
 
@@ -40,56 +30,52 @@ let game_of_sexp sexp =
   let num_splits = Array.length game.split_names in
   if num_splits = 0 then of_sexp_error "No split names defined" sexp
   else
-
     let check_run run name =
-      let pb_ok = match run with
+      let pb_ok =
+        match run with
         | Some r -> Array.length r.splits = num_splits
         | None -> true
       in
-      if not pb_ok 
-      then of_sexp_error (name ^ " has different number of splits than split_names") sexp
+      if not pb_ok then
+        of_sexp_error
+          (name ^ " has different number of splits than split_names")
+          sexp
       else ()
     in
 
     check_run game.personal_best "Personal best";
     check_run game.world_record "World record";
 
-    let history_runs_ok = List.fold game.history ~init:true ~f:(
-        fun all_ok run -> all_ok && Array.length run.splits = num_splits
-      )
+    let history_runs_ok =
+      List.fold game.history ~init:true ~f:(fun all_ok run ->
+          all_ok && Array.length run.splits = num_splits)
     in
-    if not history_runs_ok 
-    then of_sexp_error "Not all history runs have same number of splits as split_names" sexp
+    if not history_runs_ok then
+      of_sexp_error
+        "Not all history runs have same number of splits as split_names" sexp
     else game
 
 let load_golds parsed_game =
-        if Int.equal (Array.length parsed_game.golds) 0 then
+  if Int.equal (Array.length parsed_game.golds) 0 then
     Array.map parsed_game.split_names ~f:(fun name ->
-        {Timer_types.title = name; duration = None}
-      )
-        else
+        { Timer_types.title = name; duration = None })
+  else
     Array.map parsed_game.golds ~f:(fun seg ->
-        {
-                Timer_types.title = seg.title;
-                duration = Some seg.duration;
-              }
-      )
+        { Timer_types.title = seg.title; duration = Some seg.duration })
 
 let load_run parsed_run =
-  let splits = Array.map parsed_run.splits ~f:(fun split ->
-      {
-              Timer_types.title = split.title;
-              time = Some split.time;
-              is_gold = split.is_gold;
-            }
-    )
+  let splits =
+    Array.map parsed_run.splits ~f:(fun split ->
+        {
+          Timer_types.title = split.title;
+          time = Some split.time;
+          is_gold = split.is_gold;
+        })
   in
 
-  {Timer_types.attempt = parsed_run.attempt; splits = splits}
+  { Timer_types.attempt = parsed_run.attempt; splits }
 
-let load_run_opt = function 
-  | Some run -> Some (load_run run) 
-  | None -> None
+let load_run_opt = function Some run -> Some (load_run run) | None -> None
 
 let load filepath =
   let game = Sexp.load_sexp_conv_exn filepath game_of_sexp in
@@ -103,46 +89,38 @@ let load filepath =
     category = game.category;
     attempts = game.attempts;
     completed = game.completed;
-
     split_names = game.split_names;
-    golds = golds;
-    history = history;
-
+    golds;
+    history;
     comparison = pb;
-    pb = pb;
-    wr = wr;
+    pb;
+    wr;
     state = Idle;
-
     splits_file = filepath;
   }
 
-let export_run (run : Timer_types.archived_run) = 
+let export_run (run : Timer_types.archived_run) =
   {
     attempt = run.attempt;
-    splits = Array.map run.splits ~f:(fun split -> 
-        {
-          title = split.title;
-          time = (
-            match split.time with 
-            | Some t -> t
-            | None -> assert false
-          );
-          is_gold = split.is_gold;
-        }
-      );
-  } 
+    splits =
+      Array.map run.splits ~f:(fun split ->
+          {
+            title = split.title;
+            time = (match split.time with Some t -> t | None -> assert false);
+            is_gold = split.is_gold;
+          });
+  }
 
-let map_run_opt = function
-  | Some run -> Some (export_run run)
-  | None -> None
+let map_run_opt = function Some run -> Some (export_run run) | None -> None
 
 let save (timer : Timer_types.timer) =
   let map_gold (gold : Timer_types.gold) =
     {
       title = gold.title;
-      duration = match gold.duration with
+      duration =
+        (match gold.duration with
         | Some duration -> duration
-        | None -> assert false;
+        | None -> assert false);
     }
   in
 
@@ -151,18 +129,19 @@ let save (timer : Timer_types.timer) =
 
   let history = List.map timer.history ~f:export_run in
 
-  let game = {
-    title = timer.title;
-    category = timer.category;
-    attempts = timer.attempts;
-    completed = timer.completed;
-
-    split_names = timer.split_names;
-    golds = Array.map timer.golds ~f:map_gold;
-    history = history;
-    personal_best = pb;
-    world_record = wr;
-  } in
+  let game =
+    {
+      title = timer.title;
+      category = timer.category;
+      attempts = timer.attempts;
+      completed = timer.completed;
+      split_names = timer.split_names;
+      golds = Array.map timer.golds ~f:map_gold;
+      history;
+      personal_best = pb;
+      world_record = wr;
+    }
+  in
 
   let sexp = sexp_of_game game in
   let sexp_string = Sexp_pretty.sexp_to_string sexp in

--- a/src/splits.ml
+++ b/src/splits.ml
@@ -2,23 +2,24 @@ open Core
 open Timer_types
 
 let split_time timer ?now split_num =
-  if split_num < 0 then Some 0 else
-    let curr_time = match now with Some t -> t | None -> Core_unix.gettimeofday () in
+  if split_num < 0 then Some 0
+  else
+    let curr_time =
+      match now with Some t -> t | None -> Core_unix.gettimeofday ()
+    in
 
     match timer.state with
     | Idle -> None
-
     | Paused (splits, start_time, pause_time) ->
-      if split_num > Array.length splits then None
-      else if split_num = Array.length splits
-      then Some (Duration.between start_time pause_time)
-      else splits.(split_num)
-
+        if split_num > Array.length splits then None
+        else if split_num = Array.length splits then
+          Some (Duration.between start_time pause_time)
+        else splits.(split_num)
     | Timing (splits, start_time) | Done (splits, start_time) ->
-      if split_num > Array.length splits then None
-      else if split_num = Array.length splits
-      then Some (Duration.between start_time curr_time)
-      else splits.(split_num)
+        if split_num > Array.length splits then None
+        else if split_num = Array.length splits then
+          Some (Duration.between start_time curr_time)
+        else splits.(split_num)
 
 let duration timer =
   match timer.state with
@@ -26,18 +27,19 @@ let duration timer =
   | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) -> (
       match split_time timer (Array.length splits) with
       | Some t -> t
-      | None -> assert false
-    )
+      | None -> assert false)
 
 let ahead_by timer ?now split_num =
-  if split_num < 0 then None else
+  if split_num < 0 then None
+  else
     let split_time = split_time timer ?now split_num in
-    let comp_time = match timer.comparison with
+    let comp_time =
+      match timer.comparison with
       | None -> None
       | Some comp -> comp.splits.(split_num).time
     in
 
-    match split_time, comp_time with
+    match (split_time, comp_time) with
     | Some st, Some ct -> Some (st - ct)
     | _ -> None
 
@@ -45,60 +47,57 @@ let segment_time timer ?now split_num =
   let t0 = split_time timer ?now (split_num - 1) in
   let t1 = split_time timer ?now split_num in
 
-  match t0, t1 with
-  | Some t0', Some t1' -> Some (t1' - t0')
-  | _ -> None
+  match (t0, t1) with Some t0', Some t1' -> Some (t1' - t0') | _ -> None
 
 let current_split timer =
   match timer.state with
   | Idle -> None
   | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) ->
-    Some (Array.length splits)
+      Some (Array.length splits)
 
 let is_gold timer split_num =
-  match current_split timer, segment_time timer split_num with
+  match (current_split timer, segment_time timer split_num) with
   | Some n, Some seg_time -> (
-      if split_num >= n then false else
+      if split_num >= n then false
+      else
         match timer.golds.(split_num).duration with
         | Some duration -> seg_time < duration
-        | None -> true
-    )
+        | None -> true)
   | _ -> false
 
 let updated_golds timer =
   match timer.state with
   | Idle -> timer.golds
   | Timing (splits, _) | Paused (splits, _, _) | Done (splits, _) ->
-    let seg_durations = Array.mapi splits ~f:(fun i _ ->
-        segment_time timer i
-      ) in
-    let old_durations = Array.map timer.golds ~f:(fun g -> g.duration) in
-
-    let new_durations = Array.mapi timer.split_names ~f:(fun i _ ->
-        if i >= Array.length splits
-        then old_durations.(i)
-        else
-          match seg_durations.(i), old_durations.(i) with
-          | Some n, Some o -> if n < o then Some n else Some o
-          | Some n, None -> Some n
-          | None, Some o -> Some o
-          | None, None -> None
-      ) in
-
-    Array.map2_exn timer.split_names new_durations ~f:(fun name dur ->
-        {title = name; duration = dur}
-      )
+      let seg_durations =
+        Array.mapi splits ~f:(fun i _ -> segment_time timer i)
+      in
+      let old_durations = Array.map timer.golds ~f:(fun g -> g.duration) in
+
+      let new_durations =
+        Array.mapi timer.split_names ~f:(fun i _ ->
+            if i >= Array.length splits then old_durations.(i)
+            else
+              match (seg_durations.(i), old_durations.(i)) with
+              | Some n, Some o -> if n < o then Some n else Some o
+              | Some n, None -> Some n
+              | None, Some o -> Some o
+              | None, None -> None)
+      in
+
+      Array.map2_exn timer.split_names new_durations ~f:(fun name dur ->
+          { title = name; duration = dur })
 
 let gold_sum timer start bound =
   let gold_array = Array.slice (updated_golds timer) start bound in
   Array.fold gold_array ~init:(Some 0) ~f:(fun sum gold ->
-      match sum, gold.duration with
+      match (sum, gold.duration) with
       | Some x, Some y -> Some (x + y)
-      | _ -> None
-    )
+      | _ -> None)
 
 let archived_split_time run split_num =
-  if split_num < 0 then Some 0 else
+  if split_num < 0 then Some 0
+  else
     match run.comparison with
     | Some comp -> comp.splits.(split_num).time
     | None -> None
@@ -106,23 +105,15 @@ let archived_split_time run split_num =
 let archived_segment_time run split_num =
   let t0 = archived_split_time run (split_num - 1) in
   let t1 = archived_split_time run split_num in
-  match t0, t1 with
-  | Some t0', Some t1' -> Some (t1' - t0')
-  | _ -> None
+  match (t0, t1) with Some t0', Some t1' -> Some (t1' - t0') | _ -> None
 
 let archive_done_run timer splits =
-  let run_splits = Array.mapi timer.split_names ~f:(fun i name ->
-      {
-        title = name;
-        time = splits.(i);
-        is_gold = is_gold timer i;
-      }
-    ) in
-
-  {
-    attempt = timer.attempts;
-    splits = run_splits;
-  }
+  let run_splits =
+    Array.mapi timer.split_names ~f:(fun i name ->
+        { title = name; time = splits.(i); is_gold = is_gold timer i })
+  in
+
+  { attempt = timer.attempts; splits = run_splits }
 
 let updated_pb timer =
   match timer.state with
@@ -132,9 +123,8 @@ let updated_pb timer =
       | None -> None
       | Some pb_run -> (
           let last_idx = Array.length splits - 1 in
-          match splits.(last_idx), pb_run.splits.(last_idx).time with
-          | Some new_t, Some old_t -> 
-            if new_t < old_t then Some (archive_done_run timer splits) else timer.pb
-          | _ -> None
-        )
-    )
\ No newline at end of file
+          match (splits.(last_idx), pb_run.splits.(last_idx).time) with
+          | Some new_t, Some old_t ->
+              if new_t < old_t then Some (archive_done_run timer splits)
+              else timer.pb
+          | _ -> None))

--- a/src/timer_types.ml
+++ b/src/timer_types.ml
@@ -1,25 +1,13 @@
-type split = {
-  title : string;
-  time : Duration.t option;
-  is_gold: bool;
-}
-
-type gold = {
-  title : string;
-  duration : Duration.t option;
-}
-
-type archived_run = {
-  attempt : int;
-  splits : split array;
-}
-
+type split = { title : string; time : Duration.t option; is_gold : bool }
+type gold = { title : string; duration : Duration.t option }
+type archived_run = { attempt : int; splits : split array }
 type live_splits = Duration.t option array
 
-type timer_state = 
+type timer_state =
   | Idle
   | Timing of live_splits * float (* splits * start time *)
-  | Paused of live_splits * float * float (* splits * start time * paused time *)
+  | Paused of
+      live_splits * float * float (* splits * start time * paused time *)
   | Done of live_splits * float (* completed splits * start time *)
 
 (* Most of timer state is bundled together in this single package.
@@ -30,15 +18,12 @@ type timer = {
   category : string;
   attempts : int;
   completed : int;
-
   split_names : string array;
   golds : gold array;
   history : archived_run list;
   comparison : archived_run option;
   pb : archived_run option;
   wr : archived_run option;
-
   state : timer_state;
-
   splits_file : string;
-}
\ No newline at end of file
+}