Add type constraints to classgenerics in methods

Ouverte
#2,868 3 commentaires 0 réactions 0 personnes assignées Voir sur GitHub

Les mainteneurs répondent en général sous 1 jour

Personne n'a encore pris cette issue.

Évaluation

Difficulté
5/5
Temps estimé
Plus d'une semaine
Accessibilité débutants
30/100
Type d'issue
Fonctionnalité
Clarté
Plutôt claire
Activité
À l'abandon
Stack technique
ruby
Domaine
tooling

Piste de recherche

Aucun fichier d’implémentation ni aucun test n’est indiqué. Commencez par examiner la gestion existante des contraintes génériques de méthode dans RBS à partir des exemples de l’issue ; le travail est considéré comme terminé lorsqu’une syntaxe est définie et que les contraintes sur les génériques de classe dans les signatures de méthode sont prises en charge, avec une couverture des cas Array et Enumerable.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

RBS currently only lets you add type constraints to generic variables when they're declared. (For class/modules, it looks like class Foo[P < _ToS] and for methods it looks like def print: [T < _ToS] (T) -> T).

I propose expanding the method form of this to support arbitrary constraints of class generics:

class CardboardBox[Contents]
  def add: (Contents) -> void
  def submerge!: {Contents < _Waterproof} () -> void
end

There's a lot of motivating examples of this in the stdlib. Here's a select few:

class Array[E]
  # `Array#join` requires the `E` to respond to `to_s`
  def join: {E < _ToS} (?string separator) -> String

  # `Array#sum` without a default argument requires `E`
  # to coerce with integers
  def sum: [R < _Add] {E < _Coerce[Integer, R]} () -> R
         | [I < _Add[E, O], O < _Add] (I default) -> O
end

module Enumerable[E] : _Each[E]
  # `Enumerable#include?` goes `element == object`,
  # which requires that `E` implements `==`, not `T`.
  def include?: [T] {E < _Equals[T]} (T object) -> bool
end

Few things to note:

  1. I'm not wed to the syntax—in fact, I'd probably prefer it if it were a part of the [] expression (eg def include?: [T, E < _Equals[T]]). But that might be difficult to implement, and the braces are currently unused before arguments
  2. This proposal only talks class generics, as that's a somewhat pressing need. However, it might be nice (and if it's easy to do), extend this syntax to support any form of constraints
Langage dominant
Ruby
Étoiles
2.2k
Forks
263
Merge moyen
1 j 20 h
PR mergées (30 j)
64

Préparer son environnement

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de ruby/rbs

Toutes les issues de ruby/rbs

Issues similaires

Plus d'issues Ruby

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.