scala durch den Satz Typ mit Bedingung Iterieren

Question

ich eine Art von Satz und Gewerkschaftsfunktion als

type Set = Int => Boolean 
def union(s: Set, t: Set): Set = (e: Int) => s(e) || t(e) 
val xs = Set(12001,12002, 12003, 12004) 
val ys = Set(13001,13002, 13003, 13004) 

folgen Wenn ich die Vereinigungsoperation verwenden,

union(xs,ys) 

Es sollte mir noch einen Satz zurück, die all enthält die Elemente beider Sätze xs und ys

Edited Section:

Es tut mir leid ich auf meine Frage nicht klar war, ich habe meine eigene Implementierung des Iterators für beide Set xs und ys

var i = xs.iterator; 
while(i.hasNext) 
    println(i.next()) 

Aber ich war bei dieser Implementierung nicht zufrieden und stellte fest, dass Sie kann die Bedingung mit der Funktion implementieren (nach einigem googlen), aber ich konnte es nicht in meinem Eclipse-Arbeitsblatt zum Laufen bringen.

val rs = union(xs,ys)   //> rs : Learn2.Set = <function1> 

Ich vermute, es gibt eine Funktion zurück.

so meine Fragen, 1. ist es möglich, wie oben im bearbeiteten Abschnitt beschrieben zu implementieren? Wenn ja, was fehlt mir, damit es funktioniert? 2. Ich verstehe nicht, wie das Element e in (e: Int) => s(e) || t(e) wird in beiden Sätzen über die Elemente iteriert

Answer 1

Sehen Sie sich Ihre Set Typ: Int => Boolean. Es dauert also Int und gibt zurück. Was das bedeutet ist, dass es nicht eine Sammlung ist, die Sie durchlaufen können, um alle seine Werte abzurufen, da es tatsächlich keine Werte enthält.

Wenn Sie wissen möchten, was Int Werte zurückgeben true dann müssen Sie über den gesamten Bereich der möglichen Eingaben (oder eine Teilmenge davon) iterieren und filtern für die Bedingung, die Sie suchen.

scala> val res = union(xs,ys) 
res: Set = $$Lambda$1091/332405156@2c30c81d 

scala> (0 to 20000).filter(res).foreach(println) 
12001 
12002 
12003 
12004 
13001 
13002 
13003 
13004 

scala> 

Update

Ihre Verwirrung ergibt sich aus der Tatsache, dass Sie Ihre Funktion nach einer bestehenden Sammlung in der Standard-Bibliothek benannt haben. xs.itorator funktioniert, weil xs ist nicht ein Beispiel für Ihre Set, es ist ein Set aus der Standard-Bibliothek mit allen zugehörigen Methoden. Benennen Sie Ihren Typ-Alias ​​in etwas wie Xet um und Sie werden sehen, was ich meine.

type Xet = Int => Boolean 
def union(s: Xet, t: Xet): Xet = (e: Int) => s(e) || t(e) 

val xx: Xet = _ == 12001 
val yx: Xet = _ == 13002 
val zx: Xet = union(xx, yx) 

xx.itrerator // Error, won't compile 
(1 to 20000).filter(zx).foreach(println) // output: 12001 & 13002