Allow implicit int to float conversion.

CHANGES.md

@@ -81,6 +81,7 @@ Changed:
   `youtube-dl` protocol (#2827). Use `yt-dlp` as default binary for the
   protocol.
 - The `sleeper` operator is now scripted (#2899).
+- Allow implicit casting of an integer as a float (#2887).
 
 Fixed:
 

doc/content/language.md

@@ -74,6 +74,9 @@ so that `3` and `3.` are not the same thing: the former is an integer and the
 latter is a float. This is a source of errors for beginners, but is necessary for
 typing to work well.
 
+Since version 2.2 of Liquidsoap, you can use an integer where a float is
+expected, for instance you can type `sin(3)` instead of `sin(3.)`.
+
 ### Strings
 
 Strings are written between double or single quotes,

src/lang/builtins_math.ml

@@ -86,7 +86,8 @@ let () =
            match (a, b) with
              | `Int a, `Int b -> Lang.int (op_int a b)
              | `Float a, `Float b -> Lang.float (op_float a b)
-             | _ -> assert false))
+             | `Int a, `Float b -> Lang.float (op_float (float a) b)
+             | `Float a, `Int b -> Lang.float (op_float a (float b))))
   in
   register_op "Multiplication" "*" ( * ) ( *. );
   register_op "Division" "/" ( / ) ( /. );

src/lang/lang_core.ml

@@ -292,11 +292,17 @@ let to_string_getter t =
     | _ -> assert false
 
 let to_float t =
-  match (demeth t).value with Ground (Float s) -> s | _ -> assert false
+  match (demeth t).value with
+    | Ground (Float s) -> s
+    | Ground (Int n) -> float_of_int n
+    | _ -> assert false
 
 let to_float_getter t =
   match (demeth t).value with
     | Ground (Float s) -> fun () -> s
+    | Ground (Int n) ->
+        let n = float_of_int n in
+        fun () -> n
     | Fun _ | FFI _ -> (
         fun () ->
           match (apply t []).value with

src/lang/types/ground_type.ml

@@ -37,6 +37,7 @@ module Make (S : Spec) = struct
   type Type_base.custom += Type
 
   let () = types := Type :: !types
+  let typ = Type
   let get = function Type -> Type | _ -> assert false
 
   let is_descr = function
@@ -74,18 +75,33 @@ module Make (S : Spec) = struct
         Type_base.make (Type_base.Custom handler))
 end
 
-module Int = Make (struct
-  let name = "int"
-end)
-
-let int = Int.descr
-
 module Float = Make (struct
   let name = "float"
 end)
 
 let float = Float.descr
 
+module Int = struct
+  module Int = Make (struct
+    let name = "int"
+  end)
+
+  include Int
+
+  (* Add int <: float subtyping. *)
+  let handler =
+    let subtype _ _ c = assert (c = Int.typ || c = Float.typ) in
+    { handler with subtype }
+
+  let descr = Type_base.Custom handler
+
+  let () =
+    Type_base.register_type "int" (fun () ->
+        Type_base.make (Type_base.Custom handler))
+end
+
+let int = Int.descr
+
 module String = Make (struct
   let name = "string"
 end)

tests/core/meth.ml

@@ -34,12 +34,12 @@ let () =
 (* Test subtyping. *)
 let () =
   (* Make sure unifying variables sees top-level methods:
-     We do: t = ('a).{ f : int } <: t' = int.{ ff : int, f : float }
+     We do: t = ('a).{ f : int } <: t' = int.{ ff : int, f : string }
      and make sure that this fails. *)
   let t = Type.var () in
   let t = Type.meth "f" ([], Type.make Type.Ground.int) t in
   let t' = Type.make Type.Ground.int in
-  let t' = Type.meth "f" ([], Type.make Type.Ground.float) t' in
+  let t' = Type.meth "f" ([], Type.make Type.Ground.string) t' in
   let t' = Type.meth "ff" ([], Type.make Type.Ground.int) t' in
   assert (
     try

tests/language/casting.liq

@@ -0,0 +1,65 @@
+#!../../liquidsoap ../test.liq
+
+def t(x, y)
+  if x != y then
+    print("Failure: got #{x} instead of #{y}")
+    test.fail()
+  end
+end
+
+def incorrect(expr)
+  print("Incorrect expression #{expr}...\n")
+
+  try
+    let eval _ = expr
+    test.fail()
+  catch err do
+    print("Got err: #{err}")
+  end
+
+  print("\n")
+end
+
+def f() =
+  def double(x) = 2. * x end
+
+  t(double(3), 6.)
+
+  ignore(if false then 1. else 2 end)
+
+  incorrect("if false then 1 else 2. end")
+
+  def f(l) =
+    l = [1, ...l]
+    l = [2., ...l]
+    l
+  end
+
+  incorrect("
+  def f(l) =
+    l = [2., ...l]
+    l = [1, ...l]
+    l
+  end
+  ")
+
+  def f(l) =
+    let [x] = l
+    ignore(x + 2.)
+    let [x] = l
+    ignore(x + 1)
+  end
+
+  incorrect("
+  def f(l) =
+    let [x] = l
+    ignore(x + 1)
+    let [x] = l
+    ignore(x + 2.)
+  end
+  ")
+
+  test.pass()
+end
+
+test.check(f)