Esta es mi solución a ejercer de yaht:¿Puede esta muestra de Haskell ser más corta?
Ejercicio 4.6 Escribir una tupla tipo de datos que puede contener uno, dos, tres o cuatro elementos, dependiendo del constructor (es decir, no debe haber cuatro constructores , uno para cada número de argumentos). También proporcione funciones tuple1 a tuple4 que toman una tupla y devuelven el valor Just en esa posición, o Nothing si el número es válido (es decir, pregunta por la tupla4 en una tupla que contiene solo dos elementos).
cuando escribí una primera línea Yo estaba emocionado por la simplicidad en comparación 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; -- }
En C# Puedo tener acceso a cualquier campo sin ningún problema, pero aquí yo debería escribir un 'funciones de acceso', ¿verdad? Y la cantidad de código aquí me pone triste.
¿Puedo tener un código más corto aquí?
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'
Por cierto una de las ventajas # C aquí es lo mejor en comparación con anulable. En C# tenemos sintaxis especial (?postfix) y la conversión completamente transparente (pero aún opcionalmente controlable) entre T? y T (int? y int). Incluso durante el desempaquetado, puedo tener el objeto x = 5; var y = (int?) x. Sin mencionar la conversión innecesaria de int b = 5; a int? c = b; –
Oh, tantas respuestas y formas ... ¿Y sabes qué? Nada es lo suficientemente legible si tenemos en cuenta una cantidad de conocimiento que el autor da en YAHT en ese punto de ejercicio, excepto la respuesta del 1º Daniel ... Claro, leer más puede arrojar algo de luz sobre 'dónde' o '>> =' o '> =>' operadores ... Pero incluso esta respuesta es bastante compleja, creo, no lo adivinaría por mi cuenta, parece complicado :) Muchas gracias por las respuestas. –