Scala flatMap, czym są ms i e? - lista, scala

Mam „uczę się Scali iw poniższym kodzie używając flatMap (zaczerpniętego z 99 problemów Scali)

def myflatten(somelist : List[Any]): List[Any] = somelist flatMap {
case ms: List[_] => flatten(ms)
case e => List(e)
}

Teraz jestem całkowicie zdezorientowany, czym są „ms” i „e”? muszą być czymś kluczowym, jakbym zmienił ms, aby powiedzieć dd, otrzymuję błąd „nie znaleziono wartości ms”. Jeśli najeżdżę na nie, otrzymam podpowiedź, że „ms” to „Lista [] []”, a „e” to „Dowolny”.

Próbowałem googliować dla „elementów Scala List msoraz e "lub" Scala flatMap ms i e "lub" Scala co oznaczają przypadki ms i case e? ", ale nie wydaje mi się znaleźć niczego, co wyjaśniałoby czym są te" ms "i" e ".

Czy są to słowa kluczowe? Gdzie mogę znaleźć informacje na ich temat w dokumentacji Scali?

P.S. Rozumiem kod, ale nie po to, czym są ms i e

Odpowiedzi:

5 dla odpowiedzi № 1

Jeśli jesteś nowy, pozwól mi wyjaśnić krok po kroku, co się tutaj dzieje.

def myflatten(somelist : List[Any]): List[Any] = somelist flatMap {
case ms: List[_] => flatten(ms)
case e => List(e)
}

Pisane słownie:

def myflatten(somelist : List[Any]): List[Any] = somelist flatMap { something =>
something match {
case ms: List[_] => flatten(ms)
case e => List(e)
}
}

Co jest ms i e?

Najpierw pozwól mi to złamać.

Jesteś flatMapping nad a List[Any].

val x = List("Str1", "Str2", "Str3")
val y = x flatMap { elementInList => List(elementInList) }

Oznacza to, że dla każdego elementu na liście tworzysz nową listę z tym elementem. Ponieważ jest to flatMap zasadniczo otrzymujesz tę samą listę (te same elementy).

Sprawdź, co by się stało, gdybyś użył map zamiast flatMap:

val x = List("Str1", "Str2", "Str3")
val y = x map { elementInList => List(elementInList) }

temu val y byłoby:

List(List("Str1"), List("Str2"), List("Str3"))

sprawdzić http://www.brunton-spall.co.uk/post/2011/12/02/map-map-and-flatmap-in-scala/

teraz, patrząc na pełny przykład:

def myflatten(somelist : List[Any]): List[Any] = somelist flatMap { something =>
something match {
case ms: List[_] => flatten(ms)
case e => List(e)
}
}

dopasowujesz element na liście lub w tym przypadku zwany something. pasujesz również do elementów type.

na przykład

def myMatch(e: Any): String = {
e match {
case x: String  => "Its a String: " + x
case y: Int     => "Its a Int: " + y
//notice how im using x twice.. its because they"re in separate scope!
case x: Boolean => "Its a Boolean: " + x
case _          => "Its something else!"
}
}

odwołać się myMatch z param "hello" i powróci "Its a String: hello".

odwołać się myMatch z param 1 i powróci "Its a Int: 1".

sprawdzić http://docs.scala-lang.org/tutorials/tour/pattern-matching.html

Co jest e i ms?

spójrzmy na twój kod:

def myflatten(somelist : List[Any]): List[Any] = somelist flatMap {
case ms: List[_] => flatten(ms)
case e => List(e)
}

Jeśli element na liście, na który aktualnie patrzymy, jest tego typu List[_] (taki sam jak List[Any]), następnie wykonujemy ten blok, flatten(ms). ms jest val przypisany do dopasowanego elementu.

Jeśli element na liście, na który aktualnie patrzymy, jest tego typu _ lub zasadniczo domyślne (case _ =>) a następnie zwróć a List(e) zawierający jeden element, który jest elementem, na który patrzyliśmy.

To zawsze zwróci a List[List[Any]]. Który jest następnie spłaszczony do List[Any].

Mam nadzieję, że to pomoże,

Rhys

---

2 dla odpowiedzi nr 2

Tutaj case ms: List[_] to dopasowanie maszynowe dla List elementy typu. ms nie jest słowem kluczowym, to tylko zmienna reprezentująca element typu List.

I case e jest dopasowywaniem zmiennej, jest rodzajem scenariusza catch. Pasuje do wszystkich elementów, które nie są List (tak jak Lists zostaną dopasowane do pierwszego przypadku). Jeszcze raz e również nie jest słowem kluczowym.

Więcej informacji można przeczytać Rodzaje wzorów

---

1 dla odpowiedzi nr 3

ms, e - to tylko nazwy zmiennych. Możesz do nich dzwonić, jak chcesz.

W pierwszym przypadku:

case ms: List[_] => flatten(ms)

przypuszczasz, że treść twojej listy

def myflatten(somelist : List[Any])

można dopasować jako Lista [_] dowolnego typu

W drugim przypadku:

case e => List(e)

przypuszczasz, że zawartość twojej listy może być czymkolwiek innym.

Przeczytaj oficjalny dokument: http://docs.scala-lang.org/tutorials/tour/pattern-matching.html

A tu trochę samouczka: https://kerflyn.wordpress.com/2011/02/14/playing-with-scalas-pattern-matching/ zdobyć trochę informacji o dopasowywaniu wzorca scala.

---

-1 dla odpowiedzi № 4

Ogólnie porównujesz z dwoma różnymiprzypadki (tj.) przypadki mające listę dowolnych, a druga jest domyślnie określona przez e. więc jeśli masz listę [_], to zaimplementujesz płaską mapę lub drugą podaną opcję

---