9
votes

Existe-t-il un moyen de spécifier un sous-ensemble de paramètres de type dans Scala, en inférant le reste?

J'ai une classe qui ressemble à ceci:

val x = new X[AssertionError](3, 4)
val x = new X[AssertionError, _, _](3, 4)
val x = new X[AssertionError,,](3, 4)

scala type-inference

0 commentaires

5 Réponses :

3
votes

Si vous n'avez pas peur de la syntaxe hardcore TERSE, vous voudrez peut-être utiliser 4 commentaires

Et la grande chose à ce sujet est que vous puissiez toujours spécifier explicitement les paramètres de type restants: val x = nouveau p [int, long] (1, 2) compilera et être correctement de type comme X [assertionError, int, long] au lieu du x [assertionError, int, int]


                                                
                                                                                            
                                                    On dirait que vous utilisez une version instantanée de Scala 2.10 ... Vous voudrez peut-être obtenir la version finale 2.10.0!                                                
                                                
                                                                                            
                                                    Je me demande s'il existe des différences pratiques entre votre alias de type  p  et mon  XassertionError . Ne sont-ils pas identiques à des fins pratiques?                                                

                                                
                                                                                            
                                                    @ Franks.Thomas Lorsque vous utilisez les deux alias de type, il n'y a aucune différence en effet (autre que la vôtre est plus lisible). Sinon, il existe une différence: le type Lambdas peut être utilisé comme des types, sans alias supplémentaires. Par exemple. déclarant un   monad comme  monad [({type l [α] = [A, α]}) # l]   vs  première création un alias de type, puis déclarant une instance  monad  pour cela.


                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                     Vous pouvez définir un alias de type où votre premier paramètre de type est fixé à  assertionError :  xxx                                  


                                                                    
                                    
                                    
                                        4 commentaires
                                        
                                                                                            
                                                    +1. C'est cool, mais si je spécifie un type d'exception différent à chaque point d'utilisation, c'est un peu verbeux.                                                
                                                
                                                                                            
                                                    C'est à peu près ce que j'ai suggéré, ajouter un commentaire au lieu d'une solution séparée aurait été un geste gentil. Va supprimer ma réponse pour plus de clarté ...                                                
                                                
                                                                                            
                                                    @ bluenote10 Vous avez suggéré une sous-classe qui est plus poids lourdement (existe au moment de l'exécution). La solution de type alias est notamment plus propre (est résolue au moment de la compilation)                                                
                                                
                                                                                            
                                                    Je suis totalement avec vous là-bas (bien qu'il puisse y avoir des cas où le sous-classement pourrait être souhaitable?). C'est pourquoi j'ai supprimé ma réponse. Mais ce n'est rien qui ne peut être résolu par un édition / commentaire ...                                                
                                                
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                     Mon principale préoccupation était de rendre cela facile au point d'utilisation (je préférerais ne pas avoir à définir de nouveaux types pour chaque utilisation, car les types d'exception sont souvent différents). J'ai constaté que je peux utiliser l'objet compagnon vers l'usine une usine intermédiaire:  xxx  
 Le seul inconvénient que je peux voir, c'est que vous devez épeler "Appliquer".                                  

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    4
 votes
                                
                            
                            
                                
                                     Voici ma solution: 
scala> class X[A <: Throwable, B, C](b: B, c: C)
defined class X

scala> class Builder[A <: Throwable] {
     |   def apply[B, C](b: B, c: C) = new X[A,B,C](b,c)
     | }
defined class Builder

scala> def X[A <: Throwable]: Builder[A] = new Builder[A]
X: [A <: Throwable]=> Builder[A]

scala> val x = X[AssertionError](3, 4)
x: X[AssertionError,Int,Int] = X@2fc709

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Vous pouvez simplement définir un constructeur avec un argument par défaut. 
scala> class X[A <: Throwable, B, C](b: B, c: C, clz:Class[_ <: A] = classOf[Nothing])
defined class X

scala> new X(1,2)
res0: X[Nothing,Int,Int] = X@16de4e1

scala> new X(1,2, classOf[AssertionError])
res1: X[AssertionError,Int,Int] = X@1e41869

                                

                                                                    
                                    
                                    
                                        0 commentaires

Articles qui pourrait vous intéresser : Comment tester un cas d'exception avec zio-test Qu'est-ce que l'homomorphisme monoïde exactement? Le travail de traitement des données échoue avec l'exception de classe introuvable L'extraction de la structure du projet s'exécute indéfiniment