OCAMLRUNPARAM="b" returns a disappointingly
unhelpful backtrace, because the program you're trying to debug
has a non-trivial usage of exceptions that destroys the
backtrace information you were expecting. Here is a new library
that should solve this problem, by allowing you to reliably
register backtraces. Read more for the source, and the juicy
internal details: weak tables, semi-manual garbage collection
logic, and an optional change to the OCaml runtime to
improve the library performances.
Batteries contributors recently started a new discussion on the Enum module, whose purpose is to provide an good intermediate representation for conversion between data-structures, but whose implementation is perceived as too complicated and not well-understood enough. Going back to fundamentals (forgetting about half the features of Enum), what is the ultimate intermediate traversal interface?
There are two obvious choices in an effectful setting: a
generator, that is a “next-element” function of type
(unit -> 'a) that generates the next element each time
it is called, or an exception to signal end of input; or an
iterator, a fold-function of type
('a -> unit) -> unit, that iterates a consumer
function through all elements of the list.
Both are suitable as an abstract representation of any sequence (the
second is precisely the basis for Simon Cruanes’ Sequence library), and
their are at opposite ends of the control spectrum: generators
give control to the consumer of the sequence (she decides when
to call the generator function), while iterators give control to the
producer of the sequence (she decides when to call the iterated
function). It’s easy to transform a structure into a iter
to_iter), or to build a structure from a next
of_next), because you have the control. But as a library
writer, you should also write the without-control conversions
to_next), despite them being
slower and harder to implement, so that your users can live the easy
Finally, continuation capture is a well-known technique to invert control, letting you write code in “direct style”, as if you were in control, when you’re not. In this post, I will demonstrate how you can start from a conversion function that has control and, by systematic source-to-source transformations of conversion to continuation-passing-style (CPS) and defunctionalization, obtain a conversion function that works without the control.