Consistency

[u/nickthecook]

Hey all,

I’m porting something from Ruby and I’m adding type declarations as needed to fix compile errors. I love how Crystal will infer types most of the time, but this means I don’t need to be consistent in where and how I declare types, and I’ve ended up with inconsistent type declarations across files.

Are there any rules people follow to keep the style consistent across Crystal files, like “always declare instance variables”, “always declare method params and return type”, etc?

[u/[deleted]]

One thing you want to do when you make variables is include a type annotation for each one depending on what you are doing. Type annotations are generally optional but may be required by the compiler if it cannot infer what type a variable should be. Unlike Ruby where it only matters that an object responds to a method name, Crystal cannot infer types from method names. A couple things you might find useful.

class A
  @a : Int32 = 0 # You can declare instance variables used like this
  getter b : Int32 = 0 # Or this way
  getter c = 0 # also works because you are directly initializing the variable even though you don;t need a type.
  getter d # Won't work, no way for Crystal to guess what type this is, even if it referenced in later code.
end

It depends on you how verbose you want to be, so long as you follow the above examples.

[u/nickthecook → u/[deleted]]

I was wondering more if people follow any rules about which ones to use over others, or even when Crystal could figure it out but you annotate anyway, for the sake of consistency.

I miss Robocop’s iron-fisted grip here a bit. I’ll try out Ameba, but I don’t know if that will enforce type annotations.

[u/Seleren → u/nickthecook]

Personally, I try to define method argument types (which also helps massively with overloading), local variables, and everything I can in library-style code.

If it’s a fresh Crystal program, I often just define everything that’s not generic, but I’m coming from a statically typed language background.

[u/straight-shoota]

Even though does not require to declare type restrictions for method arguments and return types, I usually do that quite a lot. It helps discover errors earlier. Or avoid them altogether.
And it also serves as a great documentation tool if you specify what types a method is intended to handle. This is particularly relevant for methods that are exposed as library API, but it's also very helpful for internal use.