IEnumerable<t> 在 OCaml 中</t>

Question

I use F# a lot. All the basic collections in F# implement IEumberable interface, thus it is quite natural to access them using the single Seq module in F#. Is this possible in OCaml?

The other question is that 'a seq in F# is lazy, eg I can create a sequence from 1 to 100 using {1..100} or more verbosely:

seq { for i=1 to 100 do yield i }

In OCaml, I find myself using the following two methods to work around with this feature:

1. generate a list:

    let rec range ab = if a > b then [] else a:: range (a+1) b;;

2. or resort to explicit recursive functions.

The first generates extra lists. The second breaks the abstraction as I need to operate on the sequence level using higher order functions such as map and fold .

I know that the OCaml library has Stream module. But the functionality of it seems to be quite limited, not as general as 'a seq in F#.

BTW, I am playing Project Euler problems using OCaml recently. So there are quite a few sequences operations, that in an imperative language would be loops with a complex body.

Answer 1

This Ocaml library seems to offer what you are asking. I've not used it though.

http://batteries.forge.ocamlcore.org/

Checkout this module, Enum http://batteries.forge.ocamlcore.org/doc.preview:batteries-beta1/html/api/Enum.html

I somehow feel Enum is a much better name than Seq. It eliminates the lowercase/uppercase confusion on Seqs.

Answer 2

An enumerator, seen from a functional programming angle, is exactly a fold function. Where a class would implement an Enumerable interface in an object-oriented data structures library, a type comes with a fold function in a functional data structure library.

Stream is a slightly quirky imperative lazy list (imperative in that reading an element is destructive). CamlP5 comes with a functional lazy list library, Fstream . This already cited thread offers some alternatives .

Answer 3

It seems you are looking for something like Lazy lists. Check out this SO question

Answer 4

The Batteries library mentioned also provides the (--) operator:

# 1 -- 100;;
- : int BatEnum.t = <abstr>

The enum is not evaluated until you traverse the items, so it provides a feature similar to your second request. Just beware that Batteries' enum s are mutable. Ideally, there would also be a lazy list implementation that all data structures could be converted to/from, but that work has not been done yet.