Questions: How can we define a non-generic class that extends from a generic class?

[nanachi-code]

I know we can define a class as generic using @generic tag, but I want to implement something like this:

# @generic T
class LinkedList
  # @yieldparam element [generic<T>]
  # @return [void]
  def each
  end
end

class Face < LinkedList # LinkedList<Edge>
  # I don't want to rewrite every generic methods like this:
  # @yieldparam element [Edge]
  # @return [void]
  def each
  end
end

face = Face.new
face.each { |e| e }
#               ^ should be Edge

[nanachi-code]

after messing with it for a bit, the closest I can come up with is just cast Face instance.

# @type [Face<Edge>]
face = Face.new
face.each { |e| e }
#               ^ Edge

which is still tedious but I guess it works for now. If there is any better way please let me know.

[castwide]

Your second example is closer to the intended usage of generics. Another example using a parameterized array:

class Face
  # @return [Array<Edge>]
  def edges; end
end

face = Face.new
face.edges.each do |e|
  e # => Edge
end

In your case, I'd be tempted to bite the bullet and tag Face#each with @yieldparam [Edge], but it depends on the rest of the implementation. I'm not sure of the intent behind Face extending LinkedList.

[apiology]

You ought to be able to patch this up by supplying RBS for it via the RBS collection config; haven't tested it, though. Hoping in the future we'll have inline RBS you can dive into when YARD syntax doesn't give you the control you need.

[nanachi-code]

well I was exploring the limitation of the LSP, and in my example LinkedList is happens to including Enumerable. what I meant was the equivalent of this:

class A<T> {
  foo(): T {}
}
class B extends A<number> {} //  non generic class extends generic class
class C<T> extends A<T> {} // generic class extends generic class

instead of patching type of foo in each subclass.

[nanachi-code]

# @type [Face<Edge>]
face = Face.new
face.each { |e| e }
#               ^ Edge

this is fine if we create an new instance, but if we call that generic method inside the class then I havent figured out a way to do it without patching type.

# @generic T
class A
  # @yieldparam param0 [generic<T>]
  def foo
  end
end

class B < A # A<Integer>
  def bar
    foo { |param0| }
#          ^ generic<T> when I want Integer here
  end

# solution: patch type, either through actual method declaration, or @!method macro
# which is very tedious since we can have many generic methods
  # @yieldparam param0 [Integer]
  def foo
  end
end

[nanachi-code]

just a suggestion, maybe we can support inline RBS, or a custom tag to specialize generic for inherited class.

[castwide]

just a suggestion, maybe we can support inline RBS, or a custom tag to specialize generic for inherited class.

Inline RBS is in development as of #1173. Your particular use case might not be solved by the first iteration, but I hope to get there. Any feedback you can provide is welcome.