# Haskell dans Maguyva : des graphes de code pour classes de types et modules

Canonical source: https://maguyva.ai/fr/languages/haskell

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

Maguyva prend en charge Haskell avec AST, symboles et graphe, pour que les agents IA suivent fonctions, instances de classes de types et constructeurs de données entre modules.

## Aperçu du support

- Palier: Prise en charge de l’AST et des symboles
- Programmation
- Extensions: .hs, .lhs
- Analyse AST réelle pour une recherche consciente de la syntaxe et un contexte structurel.
- Les symboles nommés alimentent la recherche sémantique et le référencement croisé. La navigation par graphe est disponible lorsque l’extraction de relations est activée.
- Ce langage fournit des symboles et des relations à la recherche tenant compte du graphe ; les types d’arêtes pris en charge varient selon ses constructions natives.
- L’analyse AST et l’extraction de symboles sont toutes deux disponibles.

## Idéal pour

- Les services et bibliothèques Haskell comptant de nombreux modules, classes de types et instances.
- Les compilateurs, parseurs et autres bases de code où modifier un type de données a des effets lointains.
- Les équipes qui utilisent des agents IA pour lire du Haskell inconnu avant un refactoring.

## Workflows d'agent

- Trouver tous les appelants d'une fonction avant de modifier sa signature de type.
- Lister les types qui ont une instance d'une classe de types.
- Retracer où un constructeur de données est construit et quelles fonctions le consomment.

## Là où Haskell fait trébucher les outils d'IA superficiels

Haskell appelle les fonctions sans parenthèses, les compose avec des opérateurs et répartit les appels via les classes de types. `render user` est un appel, `f . g <$> xs` en contient plusieurs, et `show` signifie ce que dit l'instance de ce type. Une recherche textuelle trouve les noms, pas les instances qui se cachent derrière.

Maguyva enregistre instances et constructeurs comme des relations : l'agent voit quels types implémentent une classe et où une valeur est construite.

## Ce que Maguyva extrait en Haskell

Maguyva associe les fichiers `.hs` et `.lhs` à Haskell. Les fonctions et liaisons sont extraites comme appelables, et les classes de types, les types `data` et les `newtype` comme types. Les appels sont reconnus dans l'application séparée par des espaces et à travers les opérateurs infixes, et les imports normalisent les clauses `qualified`, `hiding` et `as`.

Les classes de types et les constructeurs deviennent des relations du graphe :

- `instance Eq Point` enregistre que `Point` implémente `Eq`.
- Quand une méthode de classe a un corps par défaut dans le même fichier, une instance qui définit cette méthode enregistre une redéfinition de l'implémentation par défaut.
- L'application d'un constructeur de données, comme `Point 1 2`, compte comme une instanciation.
- `error`, `undefined` et `throw` enregistrent des throws, et les handlers comme `catch` enregistrent des catches.

Comme les déclarations d'instance peuvent définir des noms comme `show` ou `return`, une définition du même fichier n'est pas considérée d'office comme la cible d'un appel sans receveur portant ce nom.

## Exemples de prompts pour agents

- « Qui appelle `parseConfig`, et depuis quels modules ? » (`find_symbol`, puis `dependency_search` en incoming)
- « Quels types ont une instance `ToJSON` ? » (`dependency_search`)
- « Retrace comment une requête est décodée et validée. » (`get_task_context`)

## Limites connues

- Environ 130 noms du Prelude et de base, comme `map`, `foldr`, `fmap`, `pure` et `>>=`, ainsi que des modules comme `Data.List` et `Control.Monad`, sont filtrés des relations. Utilisez `text_pattern_search` pour les retrouver.
- Dans la grammaire, un nœud de fonction brut désigne aussi les types de fonction : le preset `functions` de `structural_search` ne renvoie donc que des lambdas, et les presets `methods` et `variables` ne sélectionnent rien. Utilisez `find_symbol` pour les fonctions nommées.
- Les fichiers Haskell lettrés `.lhs` sont lus en entier avec la grammaire Haskell : attendez-vous à des résultats partiels.
- Haskell n'a pas de syntaxe de décorateur : les relations de décorateur sont donc marquées comme non applicables.

## Étapes suivantes

Connectez un dépôt avec le [démarrage rapide](/fr/docs/quickstart), puis consultez la matrice de prise en charge sur la [page de compatibilité](/fr/docs/compatibility). Pour d'autres bases de code fonctionnelles, lisez le [guide Elixir](/fr/languages/elixir).

## Détails du moteur

- La prise en charge de Haskell associe `.hs` et `.lhs` à Haskell. Classes de types, types `data` et `newtype` sont des types, et les appels sont reconnus dans l'application par espaces et à travers les opérateurs infixes.
- `instance Eq Point` enregistre que `Point` implémente `Eq`, et une méthode d'instance qui remplace un défaut de classe du même fichier enregistre un override.
- L'application d'un constructeur de données compte comme instanciation, et environ 130 noms du Prelude et de base sont filtrés des relations.

## Points d'entrée MCP utiles

- `find_symbol`: Utilisez-le pour une fonction ou un type quand vous avez besoin de la définition et des références ; les presets structurels ne renvoient que des lambdas.
- `dependency_search`: Utilisez la traversée incoming sur une classe de types pour voir quels types en ont une instance.
- `get_task_context`: Utilisez-le pour des prompts comme « retrace comment une requête est décodée et validée ».