EN
PréludeChargé par défaut — aucun import nécessaire.

Parse — analyse une valeur à partir de son texte show (le dual de Show)

Synopsis 
dropWs : List Char -> List Char

Supprime les espaces de tête.

allBlank : List Char -> Bool

Le reste n'est-il que des espaces ? (parse l'exige après la valeur.)

orElse : Maybe (a, List Char) -> Maybe (a, List Char) -> Maybe (a, List Char)

Le premier analyseur qui réussit (utilisé pour les alternatives de constructeurs).

isIdentChar : Char -> Bool
pName : String -> List Char -> Maybe (List Char)

Attend le nom exact du constructeur à l'avant (après les espaces), comme un token ENTIER — le caractère suivant, s'il y en a un, ne doit pas prolonger un identifiant, donc Red ne correspond pas au préfixe de RedX. Renvoie le reste non consommé.

optParen : (List Char -> Maybe (a, List Char)) -> List Char -> Maybe (a, List Char)

Exécute p, en acceptant une couche optionnelle de parenthèses englobantes (show en ajoute autour d'un argument composé ou négatif).

pChar : Char -> List Char -> Maybe (List Char)

Attend un seul caractère littéral (après les espaces) ; renvoie le reste.

intP : List Char -> Maybe (Int, List Char)

Lit un entier signé à l'avant.

fixedP : (Int -> w) -> (w -> Int) -> List Char -> Maybe (w, List Char)

Lit un préfixe d'entier signé, puis le RÉTRÉCIT vers un scalaire de largeur fixe via les wrap : Int -> w / val : w -> Int fournis. Ne réussit que si la valeur fait l'ALLER-RETOUR (val (wrap n) == n) — c.-à-d. qu'elle tient dans l'intervalle du type ; un littéral hors intervalle (256/-1 pour Word8, 128 pour Int8) échoue avec Nothing, exactement comme tryCast : Int -> Maybe wN. Accepte une couche de parenthèses optionnelle (le showParen de Show enveloppe un IntN négatif à une précédence > 6), en miroir de Parse Int. Paramétrique en w (sans dictionnaire) : l'appelant fournit la paire wrap/val propre à la largeur cible.

doubleP : List Char -> Maybe (Double, List Char)

Consomme un LEXÈME Double — [+-]?(digits(.digits?)?|.digits)([eE][+-]?digits)? — depuis l'AVANT, puis convertit exactement ce lexème avec parseDouble (fini, bit-exact d'un backend à l'autre). Renvoie la valeur avec le reste non consommé, si bien qu'un Double se COMPOSE dans un parse de tuple/liste — contrairement à parseDouble, qui exige la chaîne ENTIÈRE. Un . seul (sans chiffres), ou un e non suivi de chiffres d'exposant, ne fait pas partie du nombre (ce e est laissé à l'appelant). Le lexème est construit selon la même grammaire que celle qu'accepte la regex parseDouble du backend JS, si bien que les trois implémentations de parseDouble (OCaml/JS/C) ne divergent jamais dessus.

charP : List Char -> Maybe (Char, List Char)

Lit un littéral de caractère à la 'c' (avec les échappements de show).

unescape : Char -> Maybe Char
strP : List Char -> Maybe (String, List Char)

Lit un littéral de chaîne à la "…", en dé-échappant \" \\ \n \t \r (l'inverse de l'échappement de Show String, donc parse (show s) == Just s).

unescStr : Char -> Maybe Char
parse : Parse a => String -> Maybe a

Analyse une chaîne entière (pas de résidu hormis des espaces), ou Nothing.

parseListElems : (List Char -> Maybe (a, List Char)) -> List Char -> Maybe (List a, List Char)

Analyse les éléments d'une liste après le [ ouvrant — ] vide, ou une séquence séparée par des virgules se terminant par ]. L'analyseur d'élément rd est fourni par l'appelant.