Itérer sur une liste enveloppée Scala

Question

J'ai besoin d'encapsuler une liste dans un objet séparé dans Scala agissant comme une classe wrapper pour ma collection. J'ai besoin de ceci pour implémenter quelques méthodes pour agir avec la liste (en détail j'ai besoin de trouver des objets dans la liste qui sont associés à un autre objet dans la liste).

Alors tout d'abord mon code:

object Axons { 
    var axonList=List[Axon](); 
    var pos=0; 
    def init(al: List[Axon]) { 
     axonList= al; 
    } 
    def reverse(): List[Axon] = axonList.reverse 
    def get(count: Int) = axonList(count) 
    def getList(): List[Axon] = axonList 
    def length(): Int = axonList.length 

} 

Maintenant itérer se produit comme:

for (axon <- axons.getList) 

Cela ressemble un peu laid pour moi, mais je ne pouvais pas comprendre comment mettre en œuvre un itérateur qui est utilisable plusieurs fois pour parcourir la collection.

Une autre approche, utilisant simplement la liste simple, consiste à définir une fonction qui utilise la fonction fold pour réduire la liste contenant simplement les objets que je veux avoir.

Ce que vous pensez est un moyen plus commun? Filtrez dans une liste séparée en tenant simplement les objets nécessaires ou en utilisant un itérateur. À mon avis, il serait plus propre d'encapsuler ma collection Axons dans un objet séparé, d'un point de vue logiciel de desing.

Selon vous, qu'est-ce qui convient le mieux au problème?

(Si vous vous demandez ce que je fais et ce que l'axone est, sa partie d'un réseau de neurones http://en.wikipedia.org/wiki/Neural_network et la collection axones enveloppe les connexions entre une source et un neurone de destination)

remerciements et genre ce qui a trait

============================================= ====

Solution de Felix

object Axons extends Traversable[Axon] { 
    var axonList=List[Axon](); 
    def init(al: List[Axon]) { 
     axonList= al; 
    } 
    def reverse(): List[Axon] = axonList.reverse 
    def get(count: Int) = axonList(count) 

     //look here! 
    def foreach[U](f: Axon=> U): Unit = axonList.foreach(f) 
    //end ... 
    def length(): Int = axonList.length 
    def findAxonsBySource(sourceNeuron: Neuron): List[Axon] = { 
     axonList collect { 
      case axon: Axon if axon.getSourceNeuron == sourceNeuron => axon 
      } 
    } 
} 

Answer 1

Je ne suis pas sûr que cela:

for (axon <- axons.getList) 

compile. Tu voulais mettre Axons en majuscule?

Quoi qu'il en soit, vous pouvez faire quelque chose comme ceci:

object Test extends Traversable[Int]{ 
val list = List(1,2,1337,4) 
def foreach[U](f: Int=> U): Unit = list.foreach(f) 
} 

et le tester comme ceci:

Test foreach println 
1 
2 
1337 
4 

Je ne suis pas tout à fait sûr que je comprends bien le problème, mais j'espère que cela aide:)

modifier

Juste quelques réflexions sur votre message. La bonne chose à propos de Scala est que vous pouvez parfois ignorer les étapes que vous seriez obligé de prendre en Java par exemple. Ne créez pas de classes et de grands schémas pour tout sauf si vous pensez que c'est vraiment justifiable. Mon approche est toujours de plier/mapper/filtrer et ce n'est pas jusqu'à ce que j'obtienne ce dont j'ai besoin pour tester mon logiciel. Si j'ai besoin d'augmenter la performance/la modularité, je peux commencer à refaire des parties de mon logiciel. La plupart du temps, je reçois des programmes courts et j'ai rarement à refaire. Je vois l'aspect fonctionnel de Scala comme un cadeau pour réduire énormément le code de plaque de chaudière.

Answer 2

Si votre objectif est d'être en mesure d'utiliser Axons dans la liste compréhensions, alors il vous suffit de mettre en œuvre map, flatMap, withFilter méthodes et (dans votre cas) déléguer ces appels à la axonList. Lorsque vous avez fait cela, vous pouvez utiliser axons comme ceci:

for (axon <- axons) 

Plus d'informations vous pouvez trouver dans ce SO répondre:

Mock for comprehension in scala