Division operator (/) and int.divide have different behavior.

[TrentSlaton]

When dividing by 0 using the division operator, it will return 0.

When dividing by 0 using the int.divide() function, it will return a Result.

According to this section in the FAQ, this is intentional.

However this inconsistency caused a problem for me when creating a generic print function. The function was a helper for a programming challenge/exercise I was working on... here's the code

fn exercise05() {
  let first_num =
    read_line_retry(
      "What is the first number? ",
      "Please enter a valid integer...",
      int.parse,
    )

  let second_num =
    read_line_retry(
      "What is the second number? ",
      "Please enter a valid integer...",
      int.parse,
    )

  let first_num_string = int.to_string(first_num)
  let second_num_string = int.to_string(second_num)

  //   io.println(
  //     first_num_string
  //     <> " + "
  //     <> second_num_string
  //     <> " = "
  //     <> int.to_string(first_num + second_num),
  //   )

  //   io.println(
  //     first_num_string
  //     <> " - "
  //     <> second_num_string
  //     <> " = "
  //     <> int.to_string(first_num - second_num),
  //   )

  //   io.println(
  //     first_num_string
  //     <> " * "
  //     <> second_num_string
  //     <> " = "
  //     <> int.to_string(first_num * second_num),
  //   )

  //   io.println(
  //     first_num_string
  //     <> " / "
  //     <> second_num_string
  //     <> " = "
  //     <> int.to_string(first_num / second_num),
  //   )

  print_arith(first_num, second_num, "+", int.add, int.to_string)
  print_arith(first_num, second_num, "-", int.subtract, int.to_string)
  print_arith(first_num, second_num, "*", int.multiply, int.to_string)
  print_arith(first_num, second_num, "/", int.divide, int.to_string) // type error!
}

fn print_arith(
  first: a,
  second: a,
  arith_str: String,
  op: fn(a, a) -> a,
  to_string: fn(a) -> String,
) {
  let cleaned_arith_str =
    arith_str
    |> string.trim
    |> string.pad_end(2, " ")
    |> string.pad_start(3, " ")

  let result = op(first, second)

  io.println(
    to_string(first)
    <> cleaned_arith_str
    <> to_string(second)
    <> " = "
    <> to_string(result),
  )
}

As you can see, the point was to create this generic print function to avoid boilerplate... really what I wanted to do was to pass the operators themselves into the function, but I suppose that is not possible?

Here are my questions:

1. Would changing the api for int.divide to return an Int instead of a Result be a good idea or bad idea?
2. Is the passing of the operators themselves possible? If possible, why is it not done in this obvious way? Or if it is not possible, why not?
3. string.pad_* is rather unintuitive. I would expect string.pad_end(1, " ") to pad the end of the string with one space character. Why is it done in relation to the length of the string and not an absolute number of paddings?
4. I could not define print_arith within exercise05. Am I not able to define functions within another function? Why or why not? In this case, it would keep the code clean by not polluting the module with helper functions that are only needed within a single function...
5. This code is probably bad. How would you improve it?

I'm not poo-pooing the language... I understand and appreciate very much the principled approach to keeping the language small, simple and functional. I've been enjoying the language for the most part but I've felt a bit limited in some things and I'm not sure what the proper/idiomatic way is to address these things. I appreciate any help in understanding how to view the language :)

Thanks for your consideration.

[GearsDatapacks]

1. No, we would not change the behaviour of int.divide now. This would be quite a large breaking change and break many existing packages. It's meant to be a different API from the division operator, so that you can either have absolute safety and get an Error when the division fails, or not have to think about it and just receive zero.
2. No, operators are not values, they are just syntax. If you want to pass an operator like this, I suggest you use an anonymous function: fn(a, b) { a / b }
3. String padding functions are in almost every language I know and their purpose is always the same: Pad a string until it is at least a certain length. If you want to pad a fixed length, you should use string.repeat: some_string <> string.repeat(" ", 4) will pad the end of the string with 4 spaces. In your case, you probably just want " " <> arith_str <> " "
4. You can define anonymous functions as local variables, let print_arith = fn(first, second, ...) { ... } however in this case I would keep it in the global scope. Functions in Gleam are private by default so it won't affect the public API of your package/module, but only be accessible within that module.
5. This code looks fine to me. I personally might not go fully generic with this, and just specify Int in print_arith instead of a, because you're not using it for any other type as far as I can see. Your way is fine too though

Hopefully this answers some of your questions. Let me know if you have further doubts

[TrentSlaton]

Thank you so much for this great response. This really cleared things up for me, especially for 2. and 4.