Questa è la mia soluzione di esercitare da yaht:Questo esempio di haskell può essere più breve?
Esercizio 4.6 Scrivi una tupla tipo di dati che può contenere uno, due, tre o quattro elementi, a seconda del costruttore (vale a dire, non ci dovrebbe essere quattro costruttori , uno per ogni numero di argomenti). Fornisci anche le funzioni tuple1 a tuple4 che prendono una tupla e restituiscono solo il valore in quella posizione, oppure Nothing se il numero è valido (ad esempio, chiedi la tuple4 su una tupla che contiene solo due elementi).
quando ho scritto una prima linea ero entusiasta di semplicità confronto con C#
data Tuplex a b c d = Tuple1 a | Tuple2 a b | Tuple3 a b c | Tuple4 a b c d -- class Tuplex<a,b,c,d> { -- Tuplex(a p1){ _p1 = p1; } -- Tuplex(a p1, b p2){ _p1 = p1; _p2 = p2; } -- Tuplex(a p1, b p2, c p3){ _p1 = p1; _p2 = p2; _p3 = p3; } -- Tuplex(a p1, b p2, c p3, d p4){ _p1 = p1; _p2 = p2; _p3 = p3; _p4 = p4; } -- public Nullable<a> _p1; -- public Nullable<b> _p2; -- public Nullable<c> _p3; -- public Nullable<d> _p4; -- }
In C# posso accedere a qualsiasi campo senza problemi, ma qui avrei dovuto scrivere un 'funzioni di accesso', giusto? E la quantità di codice qui mi rende triste.
Posso avere un codice più breve qui?
tuple1 ∷ Tuplex a b c d → Maybe a tuple2 ∷ Tuplex a b c d → Maybe b tuple3 ∷ Tuplex a b c d → Maybe c tuple4 ∷ Tuplex a b c d → Maybe d tuple1 (Tuple1 a) = Just a tuple1 (Tuple2 a b) = Just a tuple1 (Tuple3 a b c) = Just a tuple1 (Tuple4 a b c d) = Just a tuple2 (Tuple1 a) = Nothing tuple2 (Tuple2 a b) = Just b tuple2 (Tuple3 a b c) = Just b tuple2 (Tuple4 a b c d) = Just b tuple3 (Tuple1 a) = Nothing tuple3 (Tuple2 a b) = Nothing tuple3 (Tuple3 a b c) = Just c tuple3 (Tuple4 a b c d) = Just c tuple4 (Tuple1 a) = Nothing tuple4 (Tuple2 a b) = Nothing tuple4 (Tuple3 a b c) = Nothing tuple4 (Tuple4 a b c d) = Just d -- unit tests prop_tx1 = tuple1 (Tuple1 4) ≡ Just 4 prop_tx2 = tuple1 (Tuple2 4 'q') ≡ Just 4 prop_tx3 = tuple2 (Tuple1 4) ≡ (Nothing ∷ Maybe Char) prop_tx4 = tuple2 (Tuple2 4 'q') ≡ Just 'q'
BTW uno dei C# vantaggi Ecco Forse rispetto a Nullable. In C# abbiamo una sintassi speciale (?postfix) e conversione completamente trasparente (ma ancora opzionalmente controllabile) tra T? e T (int? e int). Anche durante l'unboxing, posso avere oggetto x = 5; var y = (int?) x. Non menzionare la conversione inutile da int b = 5; a int? c = b; –
Oh, tante risposte e modi ... E sai cosa? Nulla è leggibile abbastanza se prendiamo in considerazione una quantità di conoscenza che l'autore dà in YAHT in quel punto di esercizio, ad eccezione della prima risposta di Daniel ... Certo, un'ulteriore lettura può far luce su "dove" o ">> =" o '> =>' operatori ... Ma anche questa risposta è piuttosto complessa, penso, non indovinerei che, da parte mia, sembra difficile :) Grazie mille per le risposte. –