Recursive alias, cast

[Nephos]

Hello,

cf: #3803 , #2665

Is there a way to cast something using a recursive type ?

alias Type = Int32 | Array(Type)
[1].as(Type)

Error:

can't cast Array(Int32) to Type

Note: my aim is no to be able to cast it, it is to have a defined return type (def XXX : Type)

[RX14]

[1].map(&.as(Type)).

[lbguilherme]

Actually you should do [1].map(&.as(Type)) to first go from Array(Int32) to Array(Type). Then do [1].map(&.as(Type)).as(Type) to get a Type on the end. A little bit verbose, but makes sense.

[Nephos]

Thank you, I see what you mean, but if the problem was to cast a simple Array, I would not have open an issue. The [1] is a simple example, but it should work with any valid Type.
Let me give you a complete example (I should have done that in the first place):

alias Type = Int32 | Array(Type)

def foo(a : Type) : Type
  a.as(Type)
end

foo 1
foo [1]
foo [1, [2]]

can't cast Array(Int32) to Type

Of course, you can remove the cast, but the problem becomes type must be Type, not Array(Int32)

The context is the following:

"I want to choose some functions to call at runtime. These functions can return several types of objects (its very generic)."

def foo
  "foo"
end

def bar
  0xba5
end

runtime = Hash(String, Proc(String | Int32)).new
runtime["foo"] = -> foo
runtime["bar"] = -> bar

But foo returns a String and bar a Int32, and they don't match (String | Int32).

So I could just cast the result of my functions.

alias Type = Int32 | String | Array(Int32)

def foo
  "foo".as(Type)
end

def bar
  0xba5.as(Type)
end

runtime = Hash(String, Proc(Type)).new
runtime["foo"] = -> foo
runtime["bar"] = -> bar

It also works with Generics but if there are recursive generics...
When "foo" and "bar" will become real functions, I do no want to finish my it with return X.map(.....) which might actually become VERY verbose when I'll come with Array(Hash(String, Hash(String, Float64)))

alias Type = Int32 | Array(Type)

def foo
  [0xf00].as(Type)
end

def bar
  0xba5.as(Type)
end

runtime = Hash(String, Proc(Type)).new
runtime["foo"] = -> foo
runtime["bar"] = -> bar

can't cast Array(Int32) to Type

Maybe I could workarround and declare
runtime = { "foo" => -> foo, ... } in one time so I have a big fat union, but its more tricky (requires me to do more macro for my project, because I have to keep a list of ALL the type I want in my union) and ugly. It requires to have a compile type array (size defined during the compilation itself) that keep a track of all the functions we want to add to the runtime list, so I can define the union of all of them using it.

macro runtime_init()
  RUNTIME = [] of String
end

macro runtime_def(name, &block)
  def _runtime_{{name.id}}
    {{yield}}
  end
  {{RUNTIME << name}}
end

macro runtime_end()
  CALLS = {
    {% for name in RUNTIME %}
      {{name}} => -> _runtime_{{name.id}},
    {% end %}
  }
end

macro call(name)
  CALLS[{{name}}].call()
end

runtime_init

runtime_def "foo" do
  [0xf00]
end

runtime_def "bar" do
  0xba5
end

runtime_end

pp call STDIN.gets.to_s.chomp

tell me there is another way

[asterite]

[1] of Type

[Nephos]

That's nice!
But the return of the function is not always as simple.

def foo(param1, param2) : Type
  param1.operate(param2) # well... can't define the type of "operate".
end

[lbguilherme]

I usually do this with a helper function:

alias Type = String | Int32 | Array(Type) | Hash(String, Type)

def cast_to_type(x :  Array)
  return x.map { |e| cast_to_type(e).as(Type) }.as(Type)
end

def cast_to_type(x : Hash)
  h = Hash(String, Type).new
  x.each do |(k, v)|
    h[k] = cast_to_type(v).as(Type)
  end
  h.as(Type)
end

def cast_to_type(x)
  x.as(Type)
end

p cast_to_type(10)
p cast_to_type([10])
p cast_to_type({"hm" => [10, ["", 2, {"a" => "b"}]]})

[Nephos]

That would work yes! But isn't it expensive to reallocate every Array/Hash just to do a cast ?

[lbguilherme]

You have to. Because the memory layout of a Array(Int32) is different than Array(Type). The first always store elements of 4 bytes, while the later uses more space. Whatever you do, the whole array must be reallocated to the new format. This is why this process is not automatic, but explicit.

[Nephos]

Yes, I should have learned my lessons :) Sometimes I forget that we care about memory in this langage.
Thanks for your time, you teach me something!