package coq

You can search for identifiers within the package.

in-package search v0.2.0

Formal proof management system

Install

Dune Dependency

coq.inria.fr Edit opam file Versions (38)

Authors

T

The Coq development team, INRIA, CNRS, and contributors.

Maintainers

C

coqdev@inria.fr

Sources

coq-8.15.2.tar.gz

sha256=13a67c0a4559ae22e9765c8fdb88957b16c2b335a2d5f47e4d6d9b4b8b299926

doc/coq-core.clib/IStream/index.html

Module `IStream`Source

Purely functional streams

Contrarily to OCaml module Stream, these are meant to be used purely functionally. This implies in particular that accessing an element does not discard it.

Sourcetype +'a t

Type of pure streams.

Sourcetype 'a node =

| Nil
| Cons of 'a * 'a t
(*
View type to decompose and build streams.
*)

Constructors

Sourceval empty : 'a t

The empty stream.

Sourceval cons : 'a -> 'a t -> 'a t

Append an element in front of a stream.

Sourceval thunk : (unit -> 'a node) -> 'a t

Internalize the laziness of a stream.

Destructors

Sourceval is_empty : 'a t -> bool

Whethere a stream is empty.

Sourceval peek : 'a t -> 'a node

Return the head and the tail of a stream, if any.

Standard operations

All stream-returning functions are lazy. The other ones are eager.

Sourceval app : 'a t -> 'a t -> 'a t

Append two streams. Not tail-rec.

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

Mapping of streams. Not tail-rec.

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

Iteration over streams.

Sourceval fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a

Fold over streams.

Sourceval concat : 'a t t -> 'a t

Appends recursively a stream of streams.

Sourceval map_filter : ('a -> 'b option) -> 'a t -> 'b t

Mixing map and filter. Not tail-rec.

Sourceval concat_map : ('a -> 'b t) -> 'a t -> 'b t

concat_map f l is the same as concat (map f l).

Conversions

Sourceval of_list : 'a list -> 'a t

Convert a list into a stream.

Sourceval to_list : 'a t -> 'a list

Convert a stream into a list.

Other

Sourceval force : 'a t -> 'a t

Forces the whole stream.

On This Page

Purely functional streams
Constructors
Destructors
Standard operations
Conversions
Other