Buenas, ando confundido sobre como probar si "matchea" o no un argumento con el cual consultar una funcion.. por ejemplo nos dan los parametros que una funcion f ( x, y, 1, ‘c’, (1,x), (x,z), (2,x,z), [ ], (x:xs), [x], [1], (1:xs), (1:2:xs), [1,2,3], ((x,y,2):xs) ) y tengo que indicar si matchea o no o si produce algun otro error de pattern matching con estos argumentos..
‘x’
“c”
1
(1,’c’)
(2,3)
[ ]
[1]
[1,’c’]
1:2:3:[]
[(“s”,2),(“t”,3)]
[(“t”,3,1), (“s”,4,2)]
[(“s”,4,2)]

segun el profe lo resolviamos en 10 min por lo sencillo que era y lo probabamos con haskell asiq no nos podiamos equivocar, lei los apuntes y la verdad que nose como hacerlo.. alguna ayuda? dijo que x e y matcheaban con todos..

no hace falta que crees 4 veces el mismo tema.

¿que es particularmente lo que no entendes?

fue un bug lo de los 4 temas, lo que no entiendo es como probar en haskell el matcho de dichos argumentos a ver si "matchean" o no..

Lo importante para el ejercicio son las reglas de matcheo.

Los nombres de variables representan variables, por lo que matchean con cualquier elemento (al menos en este ejercicio, en que no hay restricción del tipo de cada parámetro). Los literales (como los números, o strings literales, o listas literales) sólo matchean consigo mismos (es decir, si uno de los parámetros del patrón es un 15, sólo va a matchear si la invocación tiene un 15 en ese mismo lugar: un 4 es distinto a un 15, por lo que no matchea. Las listas matchean con listas, y los functores con functores de su misma cantidad de elementos. Pero, además, entra la restricción anterior: si hay variable matchea con cualquier cosa, si no sólo matchea con el mismo elemento.

Seguramente esté haciendo un quilombo con lo que digo, pero espero que se entienda la idea. De todos modos, leete éste apunte que te debería aclarar algunas cosas. Después, tratá de hacer el ejercicio: fijate si cada uno de los parámetros que te dieron matchea o no con el que está en su misma ubicación en el patrón de la función.


Dicho en otras palabras, la pregunta es "si tuvieramos el patrón f ( x, y, 1, ‘c’, (1,x), (x,z), (2,x,z), [ ], (x:xs), [x], [1], (1:xs), (1:2:xs), [1,2,3], ((x,y,2):xs) ), ¿matchearía con la invocación f(‘x’, “c”, 1, (1,’c’), (2,3), [ ], [1], [1,’c’], 1:2:3:[], [(“s”,2),(“t”,3)], [(“t”,3,1), (“s”,4,2)], [(“s”,4,2)]) ? Si no matcheara, ¿cuáles serían los parámetros que no matchean?"


¡Éxitos!

gracias loco, me re sirvio eso!

Un placer

Como consejo, si bien acá en general vamos a tratar de darte bola y blah, no le tengas miedo a escribir al grupo yahoo de PdeP. Ahí está lleno de gente dedicada a explicar esto de maravillas, bastante mejor de lo que yo recuerdo cómo hacer

yo me arme estas funciones para probar bien si matchean o no

 --primeros ejercicios punto 5



data Punto = Pto Int Int

data Tanque = Tque Int Int



f1 y = True

f1 _ = False



f2 1 = True

f2 _ = False



f3 'c' = True

f3 _   = False



f4 (1,x) = True

f4 _     = False



f5 (x,z) = True

f5 _     = False



f6 [] = True

f6 _  = False



f7 (x:xs) = True

f7 _      = False



f8 [x] = True

f8 _   = False



f9 [1] = True

f9 _   = False



f10 (1:xs) = True

f10 _      = False



f11 ((x,y,2):xs) = True

f11 _            = False



f12 (Pto x y) = True

f12 _         = False



f13 (Tque 1 2) = True

f13 _          = False

si tira true matchea, si tira false no matchea, si tira error es otro tipo de problema