J'essaie de mettre en œuvre un morphisme foreach afin de tester ma compréhension de la définition de morphisme et de la correspondance de modèle ... Il me manque évidemment les deux points complètement.
Pourriez-vous me corriger? Je veux que le morphisme Lorsque j'ai compilé, j'ai foreach code> prend une liste de
a code> et un morphisme
f code> comme arguments et pour renvoyer la liste de tous les résultats
r code> de
f code> appliqué à tous les éléments
a code> éléments. p>
src \ main.hs: 23: 0: Erreur d'analyse dans le motif code> p> p>
4 Réponses :
Vous avez oublié de mettre et exécuter: p> () code> dans
foreach []: xf = [] :( fx) code> spécifié de manière incorrecte le type de fonction, les suivants doivent maintenant compiler :
(a -> r) code> ici signifie ici que le deuxième argument à
foreach code> est la fonction qui convertit le type
A code> sur type
r code>. Si vous voulez par exemple un type de fonction spécifié comme
foreach :: [a] -> (a -> a) -> [a] code>, vous n'êtes pas en mesure d'évaluer
foreach [1. .20] Afficher code>, parce que
Afficher code> produit une chaîne code>, et votre fonction prend la valeur d'un type et renvoie la valeur du même type.
: -O Vous êtes bienvenu @Stephane Questions Tagged "Haskell" sont beaucoup plus actives que "Schéma", "Raquette" ou "Erlang". Je pense que j'ai besoin de sortir ici un peu.
La troisième ligne n'est pas nécessaire à la manière ( (x: xs) code> correspondant
(x: []) code>, liets
xs code> à
[] code> puis se termine lors de la prochaine récursion) à la place.
@Delnan: En effet, je viens de concentrer mon attention sur la syntaxe et la définition de type de fonction qui empêchait la source de compiler.
@Yasir, je déplace le statut de réponse aux réponses de Camcann parce qu'il traite également des incohérences d'écriture foreach [] f = [] code> et
foreach (x: []) f = (FX) : [] code> mais si je pouvais vérifier deux réponses comme des réponses correctes, je laisserais le vôtre, c'était en premier et reste sur tout plutôt correct.
Le problème est syntaxique, dans cette ligne:
map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = f x : map f xs
THX pour toutes les précisions, nommément application de fonction avec une priorité plus élevée.
et bon exemple avec la mise en œuvre de la carte
La signature de type que vous donnez est (au moins dans l'opinion de Haskell Compiler) Bogus. C'est une fonction qui prend une liste d'éléments de tout Il semble que votre objectif soit de mettre en œuvre la fonction code> Fonction: p> a code> et une valeur de tout em> type
f code> et produit une liste de valeurs de Tout type em> type
r code>. C'est comme dire "J'ai un groupe d'éléphants et un tournevis. Transformez chaque éléphant en mangue".
foreach :: [a] -> (a -> b) -> [b]
C'est bien de savoir qu'il existe déjà en tant que carte. Je l'ai utilisé dans un tutoriel mais je l'ai oublié ;-), je l'utiliserai maintenant. J'ai également remarqué l'existence du mot-clé Forall en tant que proposition d'achèvement automatique de Leksah, mais je n'ai pas pu trouver sa syntaxe.
@Stephane Rolland: Forall A b. (A -> B) -> [A] -> [B] code>. Vous aurez besoin d'une extension de langue Haskell pour utiliser cette syntaxe. Voir Types Quantifiés existentiellement quantifiés .
Juste un petit addenda. En plus d'une correspondance de motif récursif, on peut également mettre en œuvre c'est tout. P> P> foreach code> à l'aide de la compréhension de la liste:
Au fait: cela existe déjà, s'appelle
mapper code> et défini dans la moitié des lignes.
@delnan: Avec des arguments de cette façon, cela s'appelle
pour code> (et défini en termes de
carte code> probablement).
@Alexandre: Ah oui, ordre d'argument négligé ... La définition serait
Flip carte code>.
Les troisième et quatrième lignes sont inutiles. Le troisième est pris en charge par les deuxième et cinquième lignes, tandis que le quatrième n'aimait tout simplement pas de sens.
@Dan thx pour le remarquant ces incohérences.