Hi Lorenzo,

On Wed, Jan 31, 2018 at 4:14 PM, Lorenzo Pomili <lorenzo.pomili85@gmail.com>
wrote:

> Friend of mine, pointed out to me a case in Reason who cause no compile
> time error but run time error, I had reimplemented similar case in OCaml:
>

Runtime errors are very much possible in OCaml/Reason, OCaml does not make
any guarantees about runtime errors in general. The only guarantee OCaml
makes is that you won't get runtime *type* errors (with a couple of known
exceptions). In other words, if your program compiles (passes typechecking)
it won't throw a type error when it runs.

exception Generic_exc;;
>
> let string_of_string s = string_of_int (int_of_string s)
>
> let foo = string_of_string "foo"
>
> let fun_exeption x =
>     match x with
>     0 -> 0
>     | _ -> raise Generic_exc
> ;;
>
> let bar = string_of_int (fun_exeption 5)
>
> both foo and bar don't fail at compile time fail at run time,
>

Yeah, it makes sense that they don't fail at compile time, because they
pass typechecking according to the OCaml typing rules.


> me and my friend also try to reimplement similar case (the first one with
> string and int) in Elm, and Elm compiler just say you have to manage
> exeption, because function can actualy return exeption instead of int.
>

Elm tries to disallow *all* runtime errors (not just runtime type errors),
so it uses various techniques like using the Maybe and Result types to
indicate failed operations. And it makes you handle the possibility of
failure up-front. This is really nice, and you can also do this in OCaml,
but generally it is opt-in, e.g. you can use List.find (which raises an
exception if it doesn't find the item) or List.find_opt (which returns an
option containing the result of the list search).

There is a compile params or similar for check this kind of error? is a
> side effect of have a multi-paradigm? and if is it, how to manage it?
>

You have to manage it manually, and use various techniques to help. For
example, there's a nice pattern-matching technique you can use to return
values even after handling exceptions:

    let bar = string_of_int (match fun_exeption 5 with
    | int -> int
    | exception Generic_exc -> 0)


> I belive I can use OCaml in functional way without just making attention
> to not use side effect but if use of function like int_of_string can make
> run time error, I probably approac to OCaml in wrong way, and I wanna
> understand how to correct it.
>

OCaml is a mix between safety and pragmatism, it doesn't take the extreme
safety approach that Elm does. There are ups and downs to both approaches,
you would have to decide which is best for you.

Regards,

Yawar