Ways to have operators for both normal and floor division

Question

I want to have an operator for true division (like / in python) giving a float as the result and floor division (like // in python) giving an integer regardless of the input data types.
For example, 5 / 2 = 2.5 and 5.0 // 2.0 = 2.

I would prefer not to use // as I'm using that for line comments (with /* ... */ for block comments). What other options are there to have both true/'real' division and floor division operators?

Answer 1

You can expand the operator to be more than a single character. For example you could do /int~ and /float~ to disambiguate which division operation to use. It's pretty verbose but if you can find a shorter term to signify which operation you can use that.

This can then be expanded to other operations to for example ensure that overflow behavior is specified for integer addition +sat32~.

Answer 2

Some options that don't involve namespaces:

• Python: a // b
• Visual Basic: a \ b
• Pascal: a div b

Normal division is a / b in all the cases.

Answer 3

Julia's approach to this is to use ÷ for floor division (with div as an ascii alias)

Answer 4

The Verse language has an interesting approach to this problem, where division of integers returns a value of type rational, further use of which demands explicit conversion via Ceil or Floor functions. This approach could also be expanded to allow conversion to double and operations within the rational type.

Answer 5

In case you don't mind a small frame challenge: does truncating/flooring division really deserve to be an operator? It could be exposed as a function.

That:

• Probably prevents the typical "I divided 2 by 3 and got zero, this language is broken" pitfall.
• You can make it abundantly clear whether the division floors or truncates. But you can also not do that, for example Haskells div vs quot is completely opaque..
• Maybe makes it more reasonable for the division to participate in "checked exceptions", if you have such a feature.
• Maybe makes it more reasonable for the division to return an either or maybe that hold the quotient or an error/nothing, if you have such a feature.
• Maybe makes it more reasonable for the division to return a tuple of quotient and remainder.

Those last three are based on the general idea that operators should be simple and any "advanced language features" should be reserved for functions, but of course you may not hold that view.

As with bitwise operators, there is also the commonality argument: how often do you really use truncating/flooring division? Frankly I use it far less often than bitwise operators.

Answer 6

Scoped configuration

The interesting thing of having various divisions is that the code tends to use only one per compilation unit or function.

Instead of creating a lot of cruft uncommon operators, you could configure your division usage. For example:

// All divisions are compiled to int floor by default
use lang.math.div.intfloor;

def ReplicateResult
{
    def MachineXDiv()
    {
        use lang.math.div.inttruncate; // Because reasons
        var x = a / b;
    }
}

There is a lot of rounding modes, and creating syntax for every one of then is infeasible.