Re: Musings on RxAda

[Jacob Sparre Andersen <sparre@nbi.dk>]

Alejandro R. Mosteo wrote:

> Anyway, the gist of it is that you chain function calls (operators in
> their jargon) to process data asynchronously.

This sounds like how you chain filters in a Unix shell using pipes.

Continuing that thought, an obvious mapping to Ada is tasks (acting as
filters) and protected objects (acting as pipes/buffers).

Even though Ada doesn't explicitly have lambda functions, localised
scopes allow similar (if somewhat more verbose) formulations.

> Observable.just("Hello, world!")
>     .map(s -> s + " -Dan")
>     .map(s -> s.hashCode())
>     .map(i -> Integer.toString(i))
>     .subscribe(s -> System.out.println(s));

   Q1 : String_Queues.Queue;

   task Hello_World;
   task body Hello_World is
   begin
      Q1.Enqueue (+"Hello, world!");
   end Hello_World;

   Q2 : String_Queues.Queue;

   task Add_Source;
   task body Add_Source is
      Buffer : Unbounded_String;
   begin
      Q1.Dequeue (Buffer);
      Q2.Enqueue (Buffer & " -Dan");
   end Add_Source;

   Q3 : Hash_Queues.Queue;

   task Hash_String;
   task body Hash_String is
      Buffer : Unbounded_String;
   begin
      Q2.Dequeue (Buffer);
      Q3.Enqueue (Hash (Buffer));
   end Hash_String;

   Q4 : String_Queues.Queue;

   task Hash_As_String;
   task body Hash_As_String is
      Buffer : Hash_Type;
   begin
      Q3.Dequeue (Buffer);
      Q4.Enqueue (+Hash_Type'Image (Buffer));
   end Hash_As_String;

   task Output;
   task body Output is
      Buffer : Unbounded_String;
   begin
      Q4.Dequeue (Buffer);
      Put_Line (+Buffer);
   end Output;

See <https://bitbucket.org/sparre/ada-2012-examples>
("src/chained_calls.adb") for the full, compilable version.

I'm tempted to make the tasks task types with references to the input
and output queues as discriminants, but I'm not sure it really would be
an improvement.

Greetings,

Jacob
-- 
"If it's a mess, hide it..." -- J-P. Rosen