Hello,

skaller wrote:
> On Wed, 2007-10-10 at 08:39 +0100, Hugo Ferreira wrote:
> 
>> # let exp = gen_events |> gen_states |> analyze_data |> check_stop ;;
>> val exp : '_a -> unit = <fun>
>>
>> And execute it so:
>>
>> # let start_state = () ;;
>> val start_state : unit = ()
>>
>> # let _ = exp start_state ;;
>> - : unit = ()
> 
>> My question is: how can one design and implement such a "pull pipe" and
>> solve the problem I have of propagating state back to a previous
>> function. 
> 

Apologies for being so obtuse but I cannot to see how this solves my
problem. Please note that I am not well versed in functional programming
so that what I am asking may not be possible. Lets say I have a small
pipe of 3 actions:

let exp = a |> b |> c

a: requires the input of a state and outputs an event
b: requires input of a state and the event generated at that state and
outputs processed data
c: consumes n number elements of processed data and stops when it
requires no more such data

Note that "c" will "pull in" for example 10 states and check for
termination, "b" will therefore need "pull in" 10 events. Each time it
pulls in an event it generates a state. This last state must be made
available to "a" so that it may generate its next event.

The issue here is how can I implement this so that I can flexibly
configure experiments by "constructing" a chain of actions but still be
able to pass back the state to one of those actions. Something like:

let exp = a |> b (output 1 back to a) |> c

Regards,
Hugo F.









> Assume 
> 
> 	f : state_t -> state_t option
> 
> is your state transformer, then
> 
> 	let rec go state = 
> 		match f state with 
> 		| Some state -> go state
> 		| None -> ()
> 		
> will do it.
>