mbarbin / fingerboard / 116

Committed 23 Dec 2025 04:57PM UTC coverage: 95.087% (-0.5%) from 95.592%

Build # 116

Build Type

push

github

Committed by

mbarbin

Commit Message

Use Code_error.raise

Run Details

40 of 84 new or added lines in 8 files covered. (47.62%)

77 existing lines in 10 files now uncovered.

3716 of 3908 relevant lines covered (95.09%)

18681.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.3

/src/note.ml

(**********************************************************************************)
(*  Fingerboard - a microtonal geography of the cello fingerboard                 *)
(*  Copyright (C) 2022-2024 Mathieu Barbin <mathieu.barbin@gmail.com>             *)
(*                                                                                *)
(*  This file is part of Fingerboard.                                             *)
(*                                                                                *)
(*  Fingerboard is free software: you can redistribute it and/or modify it under  *)
(*  the terms of the GNU Affero General Public License as published by the Free   *)
(*  Software Foundation, either version 3 of the License, or any later version.   *)
(*                                                                                *)
(*  Fingerboard is distributed in the hope that it will be useful, but WITHOUT    *)
(*  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or         *)
(*  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License   *)
(*  for more details.                                                             *)
(*                                                                                *)
(*  You should have received a copy of the GNU Affero General Public License      *)
(*  along with Fingerboard. If not, see <https://www.gnu.org/licenses/>.          *)
(**********************************************************************************)

module Letter_name = struct
  type t =
    | A
    | B
    | C
    | D
    | E
    | F
    | G
  [@@deriving compare, enumerate, equal, hash]

  let constructor_name = function
    | A -> "A"
    | B -> "B"
    | C -> "C"
    | D -> "D"
    | E -> "E"
    | F -> "F"
    | G -> "G"
  ;;

  let to_dyn t = Dyn.variant (constructor_name t) []
  let to_string = constructor_name

  let succ = function
    | A -> B
    | B -> C
    | C -> D
    | D -> E
    | E -> F
    | F -> G
    | G -> A
  ;;

  let pred = function
    | A -> G
    | B -> A
    | C -> B
    | D -> C
    | E -> D
    | F -> E
    | G -> F
  ;;

  let semitons_step ~from =
    match from with
    | A -> 2
    | B -> 1
    | C -> 2
    | D -> 2
    | E -> 1
    | F -> 2
    | G -> 2
  ;;

  let succ_octave_designation t ~octave_designation =
    octave_designation + if equal t B then 1 else 0
  ;;

  let pred_octave_designation t ~octave_designation =
    octave_designation - if equal t C then 1 else 0
  ;;
end

module Symbol = struct
  type t =
    | Triple_flat
    | Double_flat
    | Flat
    | Natural
    | Sharp
    | Double_sharp
    | Triple_sharp
  [@@deriving compare, enumerate, equal, hash]

  let constructor_name = function
    | Triple_flat -> "Triple_flat"
    | Double_flat -> "Double_flat"
    | Flat -> "Flat"
    | Natural -> "Natural"
    | Sharp -> "Sharp"
    | Double_sharp -> "Double_sharp"
    | Triple_sharp -> "Triple_sharp"
  ;;

  let to_dyn t = Dyn.variant (constructor_name t) []

  let to_string = function
    | Triple_flat -> "bbb"
    | Double_flat -> "bb"
    | Flat -> "b"
    | Natural -> ""
    | Sharp -> "#"
    | Double_sharp -> "##"
    | Triple_sharp -> "###"
  ;;

  let prefix_notation = function
    | Triple_flat -> "bbb"
    | Double_flat -> "bb"
    | Flat -> "b"
    | Natural -> ""
    | Sharp -> "#"
    | Double_sharp -> "x"
    | Triple_sharp -> "#x"
  ;;

  let semitons_shift = function
    | Triple_flat -> -3
    | Double_flat -> -2
    | Flat -> -1
    | Natural -> 0
    | Sharp -> 1
    | Double_sharp -> 2
    | Triple_sharp -> 3
  ;;

  let succ = function
    | Triple_flat -> Some Double_flat
    | Double_flat -> Some Flat
    | Flat -> Some Natural
    | Natural -> Some Sharp
    | Sharp -> Some Double_sharp
    | Double_sharp -> Some Triple_sharp
    | Triple_sharp -> None
  ;;

  let pred = function
    | Triple_flat -> None
    | Double_flat -> Some Triple_flat
    | Flat -> Some Double_flat
    | Natural -> Some Flat
    | Sharp -> Some Natural
    | Double_sharp -> Some Sharp
    | Triple_sharp -> Some Double_sharp
  ;;
end

type t =
  { letter_name : Letter_name.t
  ; symbol : Symbol.t
  ; octave_designation : Octave_designation.t
  }
[@@deriving compare, equal, hash]

let to_dyn { letter_name; symbol; octave_designation } =
  Dyn.record
    [ "letter_name", letter_name |> Letter_name.to_dyn
    ; "symbol", symbol |> Symbol.to_dyn
    ; "octave_designation", octave_designation |> Octave_designation.to_dyn
    ]
;;

let to_string { letter_name; symbol; octave_designation } =
  Letter_name.to_string letter_name
  ^ Symbol.to_string symbol
  ^ Int.to_string octave_designation
;;

1	(**********************************************************************************)
2	(* Fingerboard - a microtonal geography of the cello fingerboard *)
3	(* Copyright (C) 2022-2024 Mathieu Barbin <mathieu.barbin@gmail.com> *)
4	(* *)
5	(* This file is part of Fingerboard. *)
6	(* *)
7	(* Fingerboard is free software: you can redistribute it and/or modify it under *)
8	(* the terms of the GNU Affero General Public License as published by the Free *)
9	(* Software Foundation, either version 3 of the License, or any later version. *)
10	(* *)
11	(* Fingerboard is distributed in the hope that it will be useful, but WITHOUT *)
12	(* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *)
13	(* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License *)
14	(* for more details. *)
15	(* *)
16	(* You should have received a copy of the GNU Affero General Public License *)
17	(* along with Fingerboard. If not, see <https://www.gnu.org/licenses/>. *)
18	(**********************************************************************************)
19
20	module Letter_name = struct
21	type t =	1,182,255✔
22	\| A	×
23	\| B	×
24	\| C	×
25	\| D	×
26	\| E	×
27	\| F	×
28	\| G	×
29	[@@deriving compare, enumerate, equal, hash]
30
31	let constructor_name = function
32	\| A -> "A"	5,218✔
33	\| B -> "B"	5,216✔
34	\| C -> "C"	5,313✔
35	\| D -> "D"	5,284✔
36	\| E -> "E"	5,309✔
37	\| F -> "F"	5,171✔
38	\| G -> "G"	5,199✔
39	;;
40
41	let to_dyn t = Dyn.variant (constructor_name t) []	92✔
42	let to_string = constructor_name
43
44	let succ = function
45	\| A -> B	79,480✔
46	\| B -> C	77,306✔
47	\| C -> D	76,130✔
48	\| D -> E	78,590✔
49	\| E -> F	80,443✔
50	\| F -> G	80,893✔
51	\| G -> A	80,772✔
52	;;
53
54	let pred = function
55	\| A -> G	15,988✔
56	\| B -> A	15,377✔
57	\| C -> B	14,632✔
58	\| D -> C	15,498✔
59	\| E -> D	15,994✔
60	\| F -> E	16,215✔
61	\| G -> F	16,221✔
62	;;
63
64	let semitons_step ~from =
65	match from with	437,125✔
66	\| A -> 2	63,098✔
67	\| B -> 1	61,628✔
68	\| C -> 2	59,666✔
69	\| D -> 2	61,588✔
70	\| E -> 1	63,353✔
71	\| F -> 2	63,856✔
72	\| G -> 2	63,936✔
73	;;
74
75	let succ_octave_designation t ~octave_designation =
76	octave_designation + if equal t B then 1 else 0	77,304✔
77	;;
78
79	let pred_octave_designation t ~octave_designation =
80	octave_designation - if equal t C then 1 else 0	14,632✔
81	;;
82	end
83
84	module Symbol = struct
85	type t =	23,720✔
UNCOV 86	\| Triple_flat	×
87	\| Double_flat	×
88	\| Flat	×
89	\| Natural	×
90	\| Sharp	×
91	\| Double_sharp	×
92	\| Triple_sharp	×
93	[@@deriving compare, enumerate, equal, hash]
94
95	let constructor_name = function
UNCOV 96	\| Triple_flat -> "Triple_flat"	×
97	\| Double_flat -> "Double_flat"	×
98	\| Flat -> "Flat"	×
99	\| Natural -> "Natural"	91✔
100	\| Sharp -> "Sharp"	1✔
UNCOV 101	\| Double_sharp -> "Double_sharp"	×
102	\| Triple_sharp -> "Triple_sharp"	×
103	;;
104
105	let to_dyn t = Dyn.variant (constructor_name t) []	92✔
106
107	let to_string = function
108	\| Triple_flat -> "bbb"	2,496✔
109	\| Double_flat -> "bb"	3,281✔
110	\| Flat -> "b"	6,960✔
111	\| Natural -> ""	10,890✔
112	\| Sharp -> "#"	7,200✔
113	\| Double_sharp -> "##"	3,295✔
114	\| Triple_sharp -> "###"	2,496✔
115	;;
116
117	let prefix_notation = function
UNCOV 118	\| Triple_flat -> "bbb"	×
UNCOV 119	\| Double_flat -> "bb"	×
120	\| Flat -> "b"	×
121	\| Natural -> ""	×
122	\| Sharp -> "#"	×
123	\| Double_sharp -> "x"	×
124	\| Triple_sharp -> "#x"	×
125	;;
126
127	let semitons_shift = function
128	\| Triple_flat -> -3	10,676✔
129	\| Double_flat -> -2	12,246✔
130	\| Flat -> -1	20,055✔
131	\| Natural -> 0	29,135✔
132	\| Sharp -> 1	20,330✔
133	\| Double_sharp -> 2	12,274✔
134	\| Triple_sharp -> 3	10,676✔
135	;;
136
137	let succ = function
138	\| Triple_flat -> Some Double_flat	1,684✔
139	\| Double_flat -> Some Flat	2,621✔
140	\| Flat -> Some Natural	3,765✔
141	\| Natural -> Some Sharp	3,577✔
142	\| Sharp -> Some Double_sharp	2,629✔
143	\| Double_sharp -> Some Triple_sharp	1,684✔
UNCOV 144	\| Triple_sharp -> None	×
145	;;
146
147	let pred = function
UNCOV 148	\| Triple_flat -> None	×
149	\| Double_flat -> Some Triple_flat	1,684✔
150	\| Flat -> Some Double_flat	2,621✔
151	\| Natural -> Some Flat	3,656✔
152	\| Sharp -> Some Natural	3,577✔
153	\| Double_sharp -> Some Sharp	2,629✔
154	\| Triple_sharp -> Some Double_sharp	1,684✔
155	;;
156	end
157
UNCOV 158	type t =	×
159	{ letter_name : Letter_name.t	47,800✔
160	; symbol : Symbol.t	×
161	; octave_designation : Octave_designation.t
162	}
163	[@@deriving compare, equal, hash]
164
165	let to_dyn { letter_name; symbol; octave_designation } =
166	Dyn.record	92✔
167	[ "letter_name", letter_name \|> Letter_name.to_dyn	92✔
168	; "symbol", symbol \|> Symbol.to_dyn	92✔
169	; "octave_designation", octave_designation \|> Octave_designation.to_dyn	92✔
170	]
171	;;
172
173	let to_string { letter_name; symbol; octave_designation } =
174	Letter_name.to_string letter_name	36,618✔
175	^ Symbol.to_string symbol	36,618✔
176	^ Int.to_string octave_designation	36,618✔
177	;;

mbarbin / fingerboard / 116

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous