Class inheritance from Array(T) with YAML.mapping in T

[AlexWayfer]

Hello!

I have a code:

require "yaml"

class Child
  YAML.mapping(
    name: String,
    age: Int32
  )
end

class Children < Array(Child)
end

yaml = <<-END
- name: Alex
  age: 6
- name: Jessy
  age: 8
END

Children.from_yaml yaml

And I have a problem:

Error in line 20: instantiating 'Children:Class#from_yaml(String)'

in ./src/yaml/from_yaml.cr:3: instantiating 'YAML::PullParser#read_stream()'

  parser.read_stream do
         ^~~~~~~~~~~

in ./src/yaml/from_yaml.cr:3: instantiating 'YAML::PullParser#read_stream()'

  parser.read_stream do
         ^~~~~~~~~~~

in ./src/yaml/from_yaml.cr:4: instantiating 'YAML::PullParser#read_document()'

    parser.read_document do
           ^~~~~~~~~~~~~

in ./src/yaml/from_yaml.cr:4: instantiating 'YAML::PullParser#read_document()'

    parser.read_document do
           ^~~~~~~~~~~~~

in ./src/yaml/from_yaml.cr:5: no overload matches 'Children.new' with type YAML::PullParser
Overloads are:
 - Children.new(size : Int, value : T)
 - Children.new(initial_capacity : Int)
 - Children.new()

      new parser
      ^~~

How I can do that Children class?

Reproducible on master branch.

Crystal 0.18.7 (2016-07-04) on Arch Linux.

Thanks.

[asterite]

More generally, this works:

class Foo
  def initialize(x : Int32)
  end

  def self.new(x : Char)
  end
end

class Bar < Foo
end

Bar.new('a')

But this doesn't:

class Foo(T)
  def initialize(x : Int32)
  end

  def self.new(x : Char)
  end
end

class Bar < Foo(Int32)
end

Bar.new('a')

Something to do with generic classes.

As a workaround, you can use this:

class Children < Array(Child)
  def self.new(pull : YAML::PullParser)
    super
  end

  def self.new(pull : YAML::PullParser)
    super do |elem|
      yield elem
    end
  end
end

Alternatively, just using alias Children = Array(Child) should be enough. I personally consider subclassing containers like Array and Hash a bad practice or a bad design, and would try to use composition instead of inheritance in these cases.

[AlexWayfer]

Alternatively, just using alias Children = Array(Child) should be enough.

I want to add method like concat for Children class, where Child will be compare by one attribute and update from another Children:

children # => [#<Child @name="Rob", @age=8>, #<Child @name="Alice", @town="New York", @age=7>]
other_children # => [#<Child @name="Alice", @age=9>, #<Child @name="John", @age=6>]
# some magic method
children | other_children # => [#<Child @name="Rob", @age=8>, #<Child @name="Alice", @town="New York", @age=9>, #<Child @name="John", @age=6>]

and would try to use composition instead of inheritance in these cases

What do you mean?

[asterite]

I mean that you are defining a | method that basically has nothing to do with what Array#| does. Why not simply use Array(Child) and define, somewhere, a merge_children methods that does the operation? Less classes around, more explicit names, etc.

I would always think twice (or maybe many more times) before subclassing a generic type, specially when subclassing containers.

[AlexWayfer]

| is just example.

merge_children is FP, not OOP :) It's accessible, but is not so beautiful (for me).

Okay, thanks.