Concurrency: use present tense

Author: moritz

lib/Language/concurrency.pod

@@ -188,12 +188,12 @@ consumed by one or more consumers simultaneously in a manner similar to
 "events" in other programming languages and can be seem as enabling
 "Event Driven" or reactive designs.
 
-L<Supply> is a role that can be composed into your own types, but will 
+L<Supply> is a role that can be composed into your own types, but will
 frequently be used as a "type punned" class to create standalone objects.
 
 At its simplest a L<Supply> is a message stream that can have multiple
 subscribers created with the method C<tap> on to which data items can be
-placed with C<emit> :
+placed with C<emit>:
 
     my $supply = Supply.new();
 
@@ -214,25 +214,25 @@ interested in the events:
     $supply.emit("Won't trigger the tap");
 
 Calling C<close> on the L<Tap> object (or calling C<close> on the supply
-object with the tap object as an argument,) will trigger the callback
+object with the tap object as an argument,) triggers the callback
 specified by C<closing> if present and stop further events being sent to
 the tap callback but otherwise leave the supply intact to receive further
-events. Calling C<done> on the supply object will similarly call the
-C<done> callback that may be specified for any taps but will not prevent any
+events. Calling C<done> on the supply object similarly calls the
+C<done> callback that may be specified for any taps, but does not prevent any
 further events being emitted to the stream, or taps receiving them.
 
-The method C<interval> will return a new supply which will automatically
-emit a new event at the specified interval, the data that is emitted will
-be an integer starting at 0 that will be incremented for each event. The
-following code will output 0 .. 5 :
+The method C<interval> returns a new supply which peridically
+emits a new event at the specified interval. The data that is emitted
+is an integer starting at 0 that is incremented for each event. The
+following code outputs 0 .. 5 :
 
 	my $supply = Supply.interval(2);
 	$supply.tap(-> $v { say $v });
 	sleep 10;
 
-A second argument can be supplied which will specify a delay in seconds
+A second argument can be supplied which specifies a delay in seconds
 before the first event is fired. Each tap of a supply created by
-C<interval> will have its own sequence starting from 0, as illustrated
+C<interval> has its own sequence starting from 0, as illustrated
 by the following:
 
     my $supply = Supply.interval(2);
@@ -244,8 +244,8 @@ by the following:
 An existing supply object can be filtered or transformed, using the methods
 C<grep> and C<map> respectively, to create a new supply in a manner like
 the similarly named list methods: C<grep> returns a supply such that only
-those events emitted on the source stream for which the expression provided
-to the C<grep> will be enitted:
+those events emitted on the source stream for which the C<grep> condition
+is true is emitted on the second supply:
 
     my $supply = Supply.new;
     $supply.tap(-> $v { say "Original : $v" });
@@ -257,9 +257,9 @@ to the C<grep> will be enitted:
         $supply.emit($_);
     }
 
-C<map> will return a new supply such that for each item emitted to the
+C<map> returns a new supply such that for each item emitted to the
 original supply a new item which is the result of the expression passed
-to the C<map> will be emitted:
+to the C<map> is emitted:
 
      my $supply = Supply.new;
      $supply.tap(-> $v { say "Original : $v" });