Module MyStream

module MyStream: sig .. end

Implémentation des flots.

type 'a t = 'a head Lazy.t

type 'a head =

`\|`	`Nil`
`\|`	`Cons of 'a * 'a t`

Implémentation (polymorphe) du type des flots. Une liste est entièrement stockée en mémoire dès sa création et donc avant même que l'on y accède. À l'inverse, un flot peut être vu comme une liste « potentielle », c'est-à-dire que ses éléments sont générés « à la demande » sans être stockés en mémoire « à l'avance ». Le type 'a t est défini comme dans le manuel de cours.

Égalité

val equal : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool

equal eq xs ys détermine si les flots xs et ys contiennent les mêmes éléments au regard de la fonction eq qui teste l'égalité entre éléments. Les flots sont donc forcés jusqu'à la première différence. Peut ne pas terminer si les deux arguments sont infinis.

Constructeurs

val from_list : 'a list -> 'a t

from_list l renvoie le flot dont les éléments sont ceux de l

val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t

unfold f seed produit un flot (potentiellement infini) obtenu en itérant la fonction f à partir de la valeur initiale seed. À chaque requête, f peut ne rien renvoyer (valeur None) auquel cas le flot est épuisé, ou bien une paire de valeurs constituée du premier élément du flot et d'une valeur à partir de laquelle f pourra déterminer l'élément suivant du flot. Cette fonction est typiquement utilisée pour définir le flot associé à un fichier. Ce flot renvoie les octets contenus dans le fichier au fur et à mesure qu'il est sollicité.

Concaténation

val concat : 'a t -> 'a t -> 'a t

concat xs ys renvoie la concaténation des flots xs et ys, donc un flot qui, lorsqu'il est sollicité, renvoie les éléments de xs puis, lorsque ce dernier est épuisé, ceux de ys.

Si xs est infini, les flots xs et concat xs ys sont « égaux » au sens où les calculs effectués lorsque l'on force concat xs ys sont les mêmes que ceux qui seraient effectués si l'on forçait xs.

Préfixe fini

val take : int -> 'a t -> 'a t

take n xs renvoie le flot des n premiers éléments of xs. Si xs a moins de n éléments, alors les calculs effectués lorsque l'on force

take n 
xs

sont les mêmes que ceux qui seraient effectués si l'on forçait xs.

val last : 'a t -> 'a option

last xs retourne Some x où x est le dernier élément d'un flot fini qui n'est pas vide, None si le flot est vide. Le calcul « épuise » son argument et donc ne termine pas si ce dernier est infini.

Réducteurs

val iter : ('a -> unit) -> 'a t -> unit

iter f xs force xs pour obtenir son premier élément x et le reste xs' du flot, puis effectue f x et réitère en appelant iter f xs'. En particulier iter f xs ne s'arrête que lorsque le flot xs est « épuisé » et peut donc ne pas terminer.

val map : ('a -> 'b) -> 'a t -> 'b t

map f xs applique la fonction f à chacun des éléments du flot xs pour créer un nouveau flot.

Retour à la page du TD8