Why do you prefer Int32 type-name instead of i32 (like it's in Rust) or int32 (numpy/pyarrow)

[toiletsandpaper]

Hi! I don't really have any access to playground, but when I saw Mojo's docs - I've noticed that your team picked Int8 (and probably something like Float32) with first capital letters. In my opinion - this could cause some social problems, because Mojo is python's superset and probably should follow some of the PEP rules (not all of them, ofc, but as much as possible). Python was always used snake_case and even types should be lowercase.

• Numpy and PyArrow follows PEP rules and use int32/float32
• Rust (that also in snake_case) use i32/f32 that is also shorten

And Mojo, IMHO, should have types like these too, just to correlate with other pythonic types, so the final look can look like this:

# `pytype` is imaginary module for accessing python's types
let python_variable: pytype.int = pytype.int(42)
let mojo_variable: int16 = 42
let pyarrow_variable: pyarrow.int16 = pyarrow.int16(42)
let numpy_varibale: numpy.int16 = numpy.int16(42)

# this looks odd when compared to previous types :)
let old_mojo_variable: Int16 = 42 

In this example we can see that all python's external modules uses fully-lowercase types and Mojo probably should use lowercase too.

So, my general question - is it possible to switch type naming from PascalCase to pythonic snake_case at this stage of Mojo's developing? (and why did you decided to use PascalCase?)

---

Anyways, thank you for you job! Great language with great goals!

[timmermansjoy]

well just like in python Int is a object. I don't know where you have seen Int16? but in Dtype there are the dtypes and all of these are lower case. and then you can also use the Aliasses to define your own types and I think you got confused there with capital F16 or UI8? But please share where you have seen Int16

[toiletsandpaper]

well just like in python Int is a object

maybe I didn't understood you correctly, but Python never had Int, only int objects (but I see that Mojo does)

In [5]: b: int = int(42)

In [6]: c: Int = Int(42)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-6-e99b6924069a> in <module>
----> 1 c: Int = Int(42)

NameError: name 'Int' is not defined

but in Dtype there are the dtypes and all of these are lower case. and then you can also use the Aliasses to define your own types

oh, that's cool, did not saw that, thx

But please share where you have seen Int16

Almost in every code-cell in https://docs.modular.com/mojo/programming-manual.html

let x: Int8 = 42
let y: Int64 = 17
let z: Int8
...
var first: Int
var second: Int
...
let data = Pointer[Int8].alloc(input.length+1)

[HelifeWasTaken]

It's not an Int16 ?? It's literally written Int8 and Int64.
But maybe you talk about SI16 which is the SIMD type but I does not seem that literal Int16 is a thing in Mojo

[toiletsandpaper]

It's not an Int16 ?? It's literally written Int8 and Int64.

But maybe you talk about SI16 which is the SIMD type but I does not seem that literal Int16 is a thing in Mojo

Discussion is about style of type names, so probably I've just made a typo in numbers. You can just switch to Int32 in all examples (Int32 to int32)

[dom96]

Coming from a language like Haskell, PascalCase for types makes sense. Since Mojo needs its own types that don't conflict with Python's own types it makes sense to use PascalCase here.

[toiletsandpaper]

Interesting point, but this probably should not have any problems with using Python int without size-postfix, and Mojo with size-postfix (int8).

[lattner]

Python types are generally capitalized. The type-annotations-for-objects are lowercase. We use names like "F32" and "Int" and "UInt8" as to make things more clear and not overly concise. For example, while "I8" is unambiguous, it isn't clear it is an integer, and we definitely cannot call "Int" just "I". :-)

[dom96]

That does make F32 inconsistent with Int32, but I guess consistency isn't everything :)

[toiletsandpaper]

So, Mojo will not use lowercase typing and stays with Int32 instead of int32?

[lattner]

Yes, arguably we should be using Float32 and Float64. The major difference is that we don't have "F" vs "Float" ambiguity like we would on the integer side of things.

[timmermansjoy]

I do see a problem in the future when libraries are using F themselves. I've seen in it pytorch and fiftyone

from fiftyone import ViewField as F
import torch.nn.functional as F

[marco-zan]

I see clear types like Float64 instead of F64 be and advantage of Mojo over other system programming languages

[cirqol]

Shorter is better...

i8 - u8
f32 - f64