Source file builtins_bool.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
(*****************************************************************************

  Liquidsoap, a programmable stream generator.
  Copyright 2003-2026 Savonet team

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program 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 General Public License for more details, fully stated in the COPYING
  file at the root of the liquidsoap distribution.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

 *****************************************************************************)

type op = {
  name : string;
  value_op : int -> bool;
  ground_op : 'a. 'a -> 'a -> bool;
}

let operators =
  [
    {
      name = "==";
      value_op = (fun c -> c = 0);
      ground_op = (fun c c' -> c = c');
    };
    {
      name = "!=";
      value_op = (fun c -> c <> 0);
      ground_op = (fun c c' -> c <> c');
    };
    {
      name = "<";
      value_op = (fun c -> c = -1);
      ground_op = (fun c c' -> c < c');
    };
    {
      name = "<=";
      value_op = (fun c -> c <> 1);
      ground_op = (fun c c' -> c <= c');
    };
    {
      name = ">=";
      value_op = (fun c -> c <> -1);
      ground_op = (fun c c' -> c >= c');
    };
    {
      name = ">";
      value_op = (fun c -> c = 1);
      ground_op = (fun c c' -> c > c');
    };
  ]

let () =
  let t = Lang.univ_t ~constraints:[Type.ord_constr] () in
  List.iter
    (fun { name; value_op; ground_op } ->
      ignore
        (Lang.add_builtin name ~category:`Bool
           ~descr:"Comparison of comparable values."
           [("", t, None, None); ("", t, None, None)]
           Lang.bool_t
           (fun p ->
             let v = Lang.assoc "" 1 p in
             let v' = Lang.assoc "" 2 p in
             Lang.bool
               (match (v, v') with
                 | Custom { value = g }, Custom { value = g' } ->
                     value_op (Term.Custom.compare g g')
                 | Int { value = v }, Int { value = v' } -> ground_op v v'
                 | Float { value = v }, Float { value = v' } -> ground_op v v'
                 | String { value = v }, String { value = v' } -> ground_op v v'
                 | Bool { value = v }, Bool { value = v' } -> ground_op v v'
                 | _ -> value_op (Value.compare v v')))))
    operators

let _ =
  Lang.add_builtin "and" ~category:`Bool
    ~descr:"Return the conjunction of its arguments"
    [
      ("", Lang.getter_t Lang.bool_t, None, None);
      ("", Lang.getter_t Lang.bool_t, None, None);
    ]
    Lang.bool_t
    (fun p ->
      let a = Lang.to_bool_getter (Lang.assoc "" 1 p) in
      let b = Lang.to_bool_getter (Lang.assoc "" 2 p) in
      Lang.bool (if a () then b () else false))

let _ =
  Lang.add_builtin "or" ~category:`Bool
    ~descr:"Return the disjunction of its arguments"
    [
      ("", Lang.getter_t Lang.bool_t, None, None);
      ("", Lang.getter_t Lang.bool_t, None, None);
    ]
    Lang.bool_t
    (fun p ->
      let a = Lang.to_bool_getter (Lang.assoc "" 1 p) in
      let b = Lang.to_bool_getter (Lang.assoc "" 2 p) in
      Lang.bool (if a () then true else b ()))

let _ =
  Lang.add_builtin "not" ~category:`Bool
    ~descr:"Returns the negation of its argument."
    [("", Lang.bool_t, None, None)]
    Lang.bool_t
    (fun p -> Lang.bool (not (Lang.to_bool (List.assoc "" p))))