Version française
Home     About     Download     Resources     Contact us    
Browse thread
Restarting a piece of code
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Alex Baretta <alex@b...>
Subject: Re: [Caml-list] Restarting a piece of code
Andrej Bauer wrote:
> I have a problem which I do not know how to program in The Right Way.
> I would be grateful to hear ideas on how to do it.
> 
> Suppose I have a bunch of functions (the actual example is exact real
> number arithmetic) which optimistically compute results (e.g. we compute
> numbers up to some precision and hope it will be good enough) that may
> turn out not to be good enough later during the computation. When this
> happens, the entire computation needs to be restarted (e.g. we need to
> recompute the numbers again with higher precision).

This is a very interesting idea. Something similar comes up in my
AS/Xcaml application server when an HTTP resource which has already
computed a portion of the HTTP response realizes that it cannot continue
and must delegate the response to a different HTTP resource. An
exception is raised which is caught by the AS/Xcaml runtime system,
which aborts the current computation and restarts the computation of the
request by activating the HTTP resource whose URL is provided in the
exception body.

***

Back to your question, I suggest not to represent computations as thunks
but to use continuation passing style. This programming paradigm
provides enough flexibility to allow for different overflow thresholds
in different parts of the computation, without need for globals and side
effects (yes, you should worry about them, they are the bad guys).

exception Overflow

let grow_threshold old_value = ...

let compute threshold threshold_transformation computation =
  try
    computation (threshold_transformation threshold)
  with Overflow ->
    let new_threshold = grow_threshold threshold in
      computation (threshold_transformation new_threshold)

Recursive computations occur through the compute driver, which also
receives a threshold_transformation function determining the value of
the threshold for the next computation. If you want your code to be
parametric with respect to the threshold growing policy, you might want
to modify the code as follows (-rectypes required!)

let rec compute grow_threshold = fun
  threshold
  threshold_transformation
  computation
->
  try
    computation
      (compute grow_threshold)
      (threshold_transformation threshold)
  with Overflow ->
    let new_threshold = grow_threshold threshold in
      computation
        (compute grow_threshold)
        (threshold_transformation new_threshold)


In this case the driver for recursive computations is no longer the
global compute function but the first parameter of the computation function.

Alex

-- 
*********************************************************************
http://www.barettadeit.com/
Baretta DE&IT
A division of Baretta SRL

tel. +39 02 370 111 55
fax. +39 02 370 111 54

Our technology:

The Application System/Xcaml (AS/Xcaml)
<http://www.asxcaml.org/>

The FreerP Project
<http://www.freerp.org/>