Comment effectuer une correspondance de modèle avec les classes de cas vararg?

Question

J'ai un ensemble de classes de cas comme celui-ci

abstract class Shape 
case class Rectangle(width: Int, height: Int) extends Shape 
case class Location(x: Int, y: Int, shape: Shape) extends Shape 
case class Circle(radius: Int) extends Shape 
case class Group(shape: Shape*) extends Shape 

où le Groupe est essentiellement un tableau de formes. J'ai besoin de définir une méthode de taille pour calculer les tailles pour rectangle, cercle et l'emplacement de son simple retour juste un. Mais j'ai de la difficulté pour le groupe. Je sais pour le groupe que je dois employer la carte et plier à gauche, mais je ne peux vraiment pas créer une logique pour cela. Remerciements

Answer 1

La syntaxe pour la correspondance de modèle vararg est quelque peu strange.

def size(s: Shape) : Int = s match{ 
    case Rectangle(x,y) => 1 
    case Circle(r) => 1 
    case Location(x,y,shape) => 1 
    case Group(shapes @ _*) => (0 /: shapes) { _ + size(_) } 
} 

Notez que dans la dernière ligne, vous additionnez les tailles de tous les sous-shapes à partir de zéro en utilisant la /: -notation pour les plis.

---

Comment folds travail: Plis accumulent les éléments d'une séquence en utilisant une fonction donnée.

Ainsi, afin de calculer la somme d'une liste, nous écrire (Haskell style)

fold (\total element -> total + element) 0 list 

qui regrouperait tous les éléments de la liste avec la fonction d'addition donnée en commençant par 0 (et donc calculer la somme).

En Scala, nous pouvons écrire cette façon:

(0 /: list) { (total, element) => total + element } 

qui peut être simplifié pour

(0 /: list) { _ + _ } 

Answer 2

Chacune de ces fonctionnera, le second est probablement préféré si un peu bizarre au début coup d'oeil. Voir 8.1.9 Séquences de motifs du Scala Reference.

case g: Group => g.shape.map(size(_)).sum 

case Group(ss @ _*) => ss.map(size(_)).sum 

Ceci utilise Scala 2.8. sum peut ne pas fonctionner sur les versions plus anciennes.

Answer 3

La première étape consiste à déterminer ce que vous voulez dire. Les deux choix les plus évidents sont la surface totale couverte par toutes les formes, et le rectangle minimum les contenant toutes. Si pour les cercles vous retournez la zone réelle, ils vous devez probablement aller avec la zone réelle.

Il n'y a pas de façon fermée de répondre à cette question. Je pourrais envisager de lancer un millier de fléchettes aléatoires dans un rectangle entourant au minimum et d'estimer la surface comme le pourcentage de fléchettes qui atteignent un point occupé. Une estimation est-elle une réponse acceptable?

Êtes-vous garanti que toutes les formes seront des cercles et des rectangles? Vous pourriez être en mesure de concocter une solution qui fonctionnerait pour eux. Si les formes peuvent être étendues plus loin, cela ne fonctionnera pas.

Answer 4

cas g:. Groupe => g.shape.map (taille (_)) Somme

Groupe de cas (ss @*) => ss.map (taille ()).somme

ces deux donne la somme de la valeur d'erreur est pas membre de Seq [Int]
Cependant, cette oen fonctionne
groupe de cas (formes @ _ *) => (0 /: formes) {_ + taille (_)

Answer 5

pour la taille emplacement doit forer vers le bas pour obtenir la taille car la forme pourrait être un groupe qui provoque un nombre plus élevé

cas Lieu (x, y, forme) => taille (forme)

Ce est si la taille est le nombre de formes dans la forme