Safe previous_def

[vladfaust]

class Array(T)
  def self.parse(string) : self | Nil forall T
    previous_def

    {% if T == Int32 %}
      return string.split(", ").map{ |s| s.to_i }
    {% end %}
  end
end

class Array(T)
  def self.parse(string) : self | Nil forall T
    previous_def

    {% if T == Float32 %}
      return string.split(", ").map{ |s| s.to_f32 }
    {% end %}
  end
end

class Array(T)
  def self.parse(string) : self | Nil forall T
    previous_def

    {% if T == URI %}
      return string.split(", ").map{ |s| URI.parse(s) }
    {% end %}
  end
end

pp! Array(Int32).parse("1, 2")
pp! Array(Float32).parse("0.5, 42")
pp! Array(URI).parse("foo, bar")

there is no previous definition of 'parse'

I'm trying to achieve an extensible Array parsing, when users of my shard could define their own .parse methods for their needs. So writing every possible type in one file is not an option.

It would be awesome if we could safely call previous_def? or at least rescue it.

I've tried {% if @type.has_method?("parse") %} and if reponds_to?(:parse) - they both return true, but the error is still raised - I guess it's because at the moment when previous_def is looked up in the first method, the second and the third are already defined? IDK.

[vladfaust]

I've found a solution:

require "uri"

class Array(T)
  def self.parse(string, type _type : Int32.class)
    return string.split(", ").map { |s| s.to_i }
  end
end

class Array(T)
  def self.parse(string, type _type : Float32.class)
    return string.split(", ").map { |s| s.to_f32 }
  end
end

class Array(T)
  def self.parse(string, type _type : URI.class)
    return string.split(", ").map { |s| URI.parse(s) }
  end
end

pp! Array(Int32).parse("1, 2", type: Int32)
pp! Array(Float32).parse("0.5, 42", type: Float32)
pp! Array(URI).parse("foo, bar", type: URI)

But there is code duplication.

[vladfaust]

I'll close this, because it's a specific project question. Any help would be appreciated, though.

[vladfaust]

My use-case is related to #3298