Converting a Ruby Class to Crystal

If you’re a Ruby developer, converting classes is a place where the differences between the languages are especially visible. Walking through the transition from Ruby to Crystal with explanations of the error messages along the way can make it easier to see how Crystal’s use of types changes the story. (If you’re not a Ruby developer, feel free to skip to the next section.)

Here’s a simple class in Ruby:

Now let’s add some test data and see if it works:

Running this program in a terminal with $ ruby mineral.rb shows the following:

Everything seems okay, but what if no mineral with the specified crystal structure exists in your array?

Ruby throws a runtime error at you because find returns nil when it can’t find a match. Forgetting to check for a nil return value isn’t always as obvious as it is here.

Crystal would prefer to spare you those problems. While converting this Ruby code to Crystal, you’ll run into a lot of errors. Don’t worry—it’s all for the good, and you’ll learn to appreciate Crystal’s character!

Let’s now look at how Crystal deals with this: Save your Ruby code in mineral.cr and build it with $ crystal mineral.cr.

Crystal syntax isn’t quite Ruby syntax, so you’ll run into an error immediately:

Ruby allows both single and double quotes for strings, but Crystal does not! You’ll need to replace all single-quoted strings with double-quoted ones and then compile again:

An error reports another difference:

Crystal uses the getter keyword (in fact, it’s a macro, see ​DRY Your Code with Macros​ ) instead of attr_reader, setter instead of attr_writer, and property instead of attr_accessor. (There are a few other superficial differences between Ruby and Crystal, but not that many. For an overview, see Appendix 2, ​Porting Ruby Code to Crystal​.)

You can use the name for the property. It doesn’t need to be a symbol. Replacing attr_reader with getter and compiling for the third time yields yet another error, which now points us to an essential difference with Ruby. This message is verbose. Don’t worry—we’ll only show this once:

Here, Crystal clearly can’t figure out the type of the instance variable @name, and it wants us to specify it. We specified @name = name, and that’s not enough. You can fix this by declaring the type of @name as follows: getter name : String. You should do it for the other properties as well:

Yet another compile-time error emerges:

Okay, wolframite has a hardness of 4.5, and this isn’t an integer. You can replace the @hardness declaration with: getter hardness : Float64, but then the compiler complains that the hardness for the other minerals is still Int32. Better convert the hardness data to floating point numbers.

Another compile run shows us a new error at the “hexagonal” test-data:

This will remind you of the nil runtime error you got with Ruby. Crystal gives you more in-depth info when you compile with the following:

$ crystal mineral.cr --error-trace

namely, a so-called Nil trace:

A Nil trace backtracks through the code, starting from the undefined method indication to where the offending type came up. This occurred in the find method in enumerable.cr:

This code shows that find returns nil as a default value for the case where nothing is found.

Crystal Is Written in Crystal
	By the way, the Crystal code standard library is entirely implemented in Crystal itself. For example, you can look at how Crystal codes all of the Enumerable methods if you’d like to at https://github.com/crystal-lang/crystal/blob/master/src/enumerable.cr. Go ahead, I’ll wait here.

The compiler signals a possible occurrence of a null-reference exception but without running the code. This avoids complaints from customers about creepy errors, at least this kind of error. As discussed earlier in ​No to the Billion-Dollar Mistake​, this is one of the highlights of Crystal. The error message also says that the compile-time type is Mineral | Nil.

This is a union-type (see ​Using Arrays​): normally the variable min references a Mineral object, but if you have no mineral of that specific crystal structure in your data collection, min is nil. Crystal checks whether every method called on min is available for all the types in the union type. If not, bingo: an error.

You can fix this in the same way that you would in Ruby:

If this looks strange to you, revisit our discussion on falsy and truthy at ​Controlling the Flow​. When min is nil, this amounts to false, and the first branch of the if statement isn’t executed. So inside the first branch, we know that the type of min is Mineral and not Nil. In the else branch, it’s Nil and not Mineral.

At last, everything works and you get the same output as Ruby did:

Finally, let’s introduce a nice shorthand code syntax (borrowed from CoffeeScript). Instead of:

you can write:

Instance variables get their value directly from creating the object, @name becomes “gold,” @hardness gets value 1.0, and so on:

You could also type the properties in the initialize method instead of in the getter clause, like this:

That wasn’t so bad, was it?

Here’s the complete Crystal code for our program:

Crystal guides you firmly and expects a higher level of quality and thoroughness in your code than Ruby does. When you use Ruby, you have to rely more on your test suite’s completeness in order to detect and avoid that kind of mistake.