Funzioni generiche

Fa parte della sezione Programmazione orientata agli oggetti del percorso Kotlin di Coddy. Lezione 37 di 57.

Una funzione generica funziona con qualsiasi tipo. Il suo parametro di tipo, scritto tra parentesi angolari prima del nome della funzione, rappresenta il tipo utilizzato da chi la chiama. T è il nome abituale:

fun <T> firstOr(list: List<T>, default: T): T = if (list.isEmpty()) default else list[0]

All'interno di main:

println(firstOr(listOf(3, 5), 0) + 1)
println(firstOr(listOf<String>(), "none").uppercase())

Output:

4
NONE

Kotlin deduce l'argomento di tipo dagli argomenti. Quando non c'è nulla da cui dedurlo, lo scrivi tu, come in listOf<String>() sopra:

fun <T> repeatItem(item: T, times: Int): List<T> = List(times) { item }

All'interno di main:

println(repeatItem("ab", 3))
println(repeatItem(7, 2))
val empty = repeatItem<Double>(1.5, 0)
println(empty)

Output:

[ab, ab, ab]
[7, 7]
[]

Una funzione può avere diversi parametri di tipo e un parametro di tipo funzione può usarli. È così che funzionano le funzioni di libreria come map per ogni tipo di elemento e di risultato:

fun <A, B> transform(items: List<A>, f: (A) -> B): List<B> {
    val out = mutableListOf<B>()
    for (item in items) out.add(f(item))
    return out
}

fun <K, V> invert(map: Map<K, V>): Map<V, K> = map.entries.associate { (k, v) -> v to k }

Dentro main:

println(transform(listOf("kiwi", "fig")) { it.length })
println(invert(mapOf("a" to 1, "b" to 2)))

Output:

[4, 3]
{1=a, 2=b}

Un parametro di tipo mantiene il tipo del chiamante. firstOr(listOf(3, 5), 0) restituisce un Int, quindi + 1 viene compilato. Anche una versione scritta per List<Any> accetterebbe qualsiasi lista, ma restituirebbe Any e richiederebbe un cast a ogni chiamata:

fun firstAny(list: List<Any>, default: Any): Any = if (list.isEmpty()) default else list[0]
// firstAny(listOf(3, 5), 0) + 1               // errore: Any non ha plus
(firstAny(listOf(3, 5), 0) as Int) + 1         // viene compilato, ma richiede un cast
firstOr(listOf(3, 5), 0) + 1                   // generico: il risultato è un Int

Sfida

Facile

Scrivi due funzioni generiche che funzionino con liste di qualsiasi tipo. countWhere(items, predicate) restituisce quanti elementi soddisfano il predicato, una funzione (T) -> Boolean. mostCommon(items) restituisce l’elemento che compare più spesso (quello che compare per primo nella lista quando le occorrenze sono a pari merito), oppure null per una lista vuota.

Il codice fornito legge una riga di parole e una riga di numeri, e stampa il numero di parole più lunghe di 3 lettere, la parola più comune, il numero di numeri pari, il numero più comune e nothing: null per una lista vuota.

Il tuo codice va in ListTools.kt. Main.kt contiene il codice di input/output fornito e non può essere modificato.

Provalo tu

fun main() {
    // Codice di input/output fornito: lascialo così com'è
    val input = generateSequence(::readLine).toList()
    val words = input[0].split(" ")
    val numbers = input[1].split(" ").map { it.toInt() }
    println("long words: ${countWhere(words) { it.length > 3 }}")
    println("most common word: ${mostCommon(words)}")
    println("even numbers: ${countWhere(numbers) { it % 2 == 0 }}")
    println("most common number: ${mostCommon(numbers)}")
    println("nothing: ${mostCommon(listOf<String>())}")
}