Crystal

[Ary Borenszweig]

On 2/17/13 9:14 AM, Jacob Carlborg wrote:
> I find it very interesting. But actually I'm going to agree with Denis,
> mostly. If I was going to use Crystal I would probably use a lot more
> static typing than it's probably made for.
>
> I quite often miss static typing in Ruby. Often there are functions that
> are supposed to only work with a given type, I don't see why I shouldn't
> explicitly write that type out then.

As I replied to Denis, you can specify type restrictions in functions 
and methods.

def foo(x : Int)
   1
end

foo "Hello" # Gives a compile error

It works similar to overloaded templates: you don't specify the type of 
the function, but which types you can give to it. In the case of Int, of 
course it will always just accept an Int. But you can specify for example

def foo(x : Enumerable)
end

And there's a special restriction, self, that will only match for the 
owner of the method. This is used for example in the Comparable module:

https://github.com/manastech/crystal/blob/master/std/comparable.cr

>
> A couple of questions:
>
> * Executable code at class level, is that supported? If that's the case,
> when is it run? Example:
>
> class Foo
>    puts "asd"
> end

I thought it was supported but it's not. It would be very easy to 
support it, but it would execute at run time, as if you had put it 
before the class declaration.

However, there's another thing I didn't mention in that wiki page and 
that is macros. You can write;

---
macro define_something
   "def something; 1; end"
end

define_something() # This defines the "something" method

something() # And this invokes it
---

Again, this is different from Ruby.

Macros are executed at compile time. You can pass arguments to them, and 
their type will be the AST node of the expression you give them. They 
must return a String (for now), and it will be mixed in the program 
(later we'll support returning AST nodes directly).

We use macros for attr_accessor and the like:

https://github.com/manastech/crystal/blob/master/std/object.cr

Just note that this is an experimental feature, and for now only 
variables, strings and symbols are allowed for macros.

Macros can execute arbitrary code and have access to what you defined in 
your program. That means they can open a file, read/write a database and 
so on. I believe this can be very powerful for metaprogramming.

(this is inspired mainly from Lisp)

>
> * With a statically typed languages you quite soon get the need for
> interfaces, abstract classes and similar. How is this handled?

If you don't need them in Ruby I don't see why would you need them in 
Crystal.

The only use of interfaces is to satisfy the compiler. But since Crystal 
is mostly duck-typed interfaces have no use.

Another use is probably performance, and we are still considering how to 
fit everything together. We are writing code in Crystal and see where 
it's slow, and think of the most little change that's not a burden for 
the programmer that can help speed up compilation times.

>
> * Is Ruby code supposed to be able to run of out the box in Crystal?
> That is can I take arbitrary Ruby code and compile it with Crystal and
> expect it to work. If that's the case, what's currently supported and
> what's not supported?

You probably won't have eval, define_method and so on. You will be able 
to do some of those things with macros, but it's not the same.

Most Ruby code should run out of the box, unless something is missing 
from the standard library.

For example I tried running this code:

https://gist.github.com/havenwood/4724778

(removing the Time.now lines, because we don't have that yet)

and it just worked. And it was much faster than all of the other languages.

Our idea was to make a language as similar as Ruby, not with the 
intention of compiling Ruby. But accidentally (or not :-P) it is 
happening, slowly.

Thanks for your comments and questions!