Programmation Fonctionnelle, TP8

Version & licenses
Creative Commons License

Interface du module Parse

Guyslain Naves
  1. (** type des scanners de liste d'['input] calculant une valeur de type ['result] *)
  2. type ('input, 'result) t = 'input list -> ('result * 'input list) list

  4. (** [read scanner input] applique un scanner sur une liste de donnée,
  5. * et construit une valeur de type ['result]. Plusieurs constructions
  6. * peuvent être possible : le résultat est donc une liste de construction
  7. * possibles. Chacun de ces éléments contient la valeur construite, et
  8. * la liste des entrées non-utilisées.
  9. * Si aucune construction n'est possible, retourne la liste vide.
  10. *)
  11. val read : ('input, 'result) t -> 'input list -> ('result * 'input list) list

  13. (** Le scanner qui échoue systématiquement *)
  14. val failure : ('input, 'fail) t

  16. (** [don't_read result] est un scanner qui retourne toujours [result] sans rien lire. *)
  17. val don't_read : 'result -> ('input,'result) t

  19. (** Lit le premier élément de l'entrée, et le retourne s'il vérifie le prédicat *)
  20. val read_this : ('input -> bool) -> ('input,'input) t

  22. (** [choose scanner1 scanner2] applique les deux scanners, et retourne
  23. * tous les résultats possibles
  24. *)
  25. val choose : ('input, 'res) t -> ('input, 'res) t -> ('input, 'res) t

  27. (** [apply f scanner input] lit [input] avec [scanner] et
  28. * applique [f] à chaque résultat obtenu
  29. *)
  30. val apply : ('read -> 'result) -> ('input, 'read) t -> ('input, 'result) t

  32. (** [combine scanner1 scanner2] lit l'entrée avec [scanner1], obtenant une fonction [f],
  33. * puis lit la suite de l'entrée avec [scanner2], et applique [f] au résultat.
  34. *)
  35. val combine : ('input,'tmp -> 'res) t -> ('input, 'tmp) t -> ('input, 'res) t

  37. (** [reject scanner1 scanner2] échoue si [scanner1] arrive à lire l'entrée.
  38. * Si [scanner1] échoue, alors le résultat de [scanner2] est retourné.
  39. *)
  40. val reject : ('input,'fail) t -> ('input,'success) t -> ('input,'success) t

  42. (** [filter predicat scanner] applique [scanner] à l'entrée,
  43. * et garde les résultats qui satisfont le prédicat
  44. *)
  45. val filter : ('result -> bool) -> ('input,'result) t -> ('input,'result) t

  47. val keep_highest_score : ('result -> 'input list -> int) -> ('input,'result) t -> ('input,'result) t

  49. (** [read_sequence scanner] lit l'entrée avec [scanner] itérativement,
  50. * jusqu'à ce que la lecture échoue. Retourne la liste des
  51. * valeurs construites, possiblement aucune, et l'entrée non-lue.
  52. *)
  53. val read_sequence : ('input,'result) t -> ('input, 'result list) t

  55. (** [read_strict_sequence scanner] agit comme [read_sequence]
  56. * mais lit au moins une valeur.
  57. *)
  58. val read_strict_sequence : ('input,'result) t -> ('input, 'result list) t





  64. (** le module [Infix] propose des opérateurs infixes pour certaines
  65. * des valeurs qui précèdent.
  66. *)
  67. module Infix : sig
  68. (** [combine] *)
  69. val (-->) : ('input,'tmp -> 'res) t -> ('input, 'tmp) t -> ('input, 'res) t

  71. (** [choose] *)
  72. val (<|>) : ('input, 'res) t -> ('input, 'res) t -> ('input, 'res) t

  74. (** [apply] *)
  75. val ( *>> ) : ('read -> 'result) -> ('input, 'read) t -> ('input, 'result) t

  77. (** [reject] *)
  78. val (-!-) : ('input,'fail) t -> ('input,'success) t -> ('input,'success) t
  79. end