[ANN] Ppx_untype: An end to type errors in OCaml

Community
1

Hello dear people reading this!

Today, I am overly excited to announce one of the greatest and simplest tool, that will fix the biggest of all OCaml flaws.

Consider Javascript:

$ node
Welcome to Node.js v22.14.0.
Type ".help" for more information.
> 1 + 3.5
4.5

Simple and elegant, don’t we all agree?

Now, the same with OCaml:

$ ocaml
OCaml version 5.3.0
Enter #help;; for help.
# 1 + 3.5 ;;
Error: The constant 3.5 has type float but an expression was expected of type
         int

What does this even mean?

The PPX that I lovingly share with you all is ppx_untype. It finally fully removes the OCaml type system that has plagued it since its inception.

The PPX can be used very simply. Add it to your opam switch:

$ opam pin add ppx_untype https://github.com/panglesd/ppx_untype.git\#main

and then add it to your dune (or other build system) file:

(...
 (preprocess (pps ppx_untype))
 ...)

And you can now enjoy OCaml!

$ cat bin.main.ml
let () = print_float (1 + 3.5)
$ dune exec bin/main.exe
3.47922429887e-310

Pros:

  • All programs that was working before, still works.
  • Blazingly fast!
  • Finally integers and floats can be added.
  • All warnings are also removed.

Cons:

  • None (apart from some unexpected behaviour at runtime)
35 Likes
2

I see that a cheat engine for roguetype has been published on the very first day of the release!

15 Likes
3

Thank you, this looks lovely!

Once this has been proved useful, and although I do not see how this
could be not happening, I would like to encourage you to go one step
further in this direction by opening a PR to the compiler itself to
basically get rid of its typiing/ subdirectory, which will, by your
magic, contain only dead code.

How many headaches will we save…

1 Like
4

Very nice! I often use the ocaml REPL as a calculator.

It’s totally improductive because of the number of type errors I make but remains faster than using a calculator app with hidden state or another language that is not as hardwired in my brain as OCaml is.

So I actually contemplated more than once adding a Down.calculator () mode that would do exactly that:

  1. Redefine integer operators to work on floats (easy)
  2. Transforms integer literals into floating point ones (unclear).

Just never got the time to get to it yet. No joke. (PR’s welcome as they say)

:–)

1 Like
5

bc is old but it still a good friend for that (in my opinion).

1 Like
6

bc has not let :scream:

1 Like
7

I just wanted to clarify that ppx_untype allows much more than computing with ints and floats. You can easily add functions together!

$ cat bin/main.ml
let () =
  let x = (fun x -> x + 1) + (fun x -> x - 1) in
  print_int x
$ dune exec bin/main.exe
109934791872403
9 Likes
8

Now that makes sense!

1 Like
9

Very nice. I’m so sick of warnings!

10

It is funny… Ada is even more picky about types (we do have many Integer types and need explicit conversion when doing something with 2 different types). It is seen as a feature, not a flaw.

But sure REPL inputs and code saved in a file have different constraints.

Being to extreme with implicit type conversion make “11”+1 = “111” and “11”-1 = 10 in JavaScript. We just need to get the good compromise.

11

Conclusion: After using OCaml without type system for the whole of April 1st, facing multiple runtime bugs, I realized that the type system is actually helpful! I’ll train my skills playing roguetype instead of writing not-serious PPXes…

@SebHash thanks for the support! I may open a PR for that at the anniversary of the ppx_untype release, be prepared to merge it before anyone realize!

As a technical note, this PPX bypass the type system by wrapping every expression in a call to Obj.magic. So please, do not use this joke in production :slight_smile:

7 Likes
12

I was honestly wondering what the point of this library was when I already wrap all my code in Obj.magic

5 Likes