Chaining std.algorithm

[Ali Çehreli]

On 12/15/2013 08:42 PM, John Carter wrote:

 > So I have an array of data...
 >   struct romanSystemData {
 >     string digit;
 >     uint   value;
 >     ulong  regionIndex;
 >     ulong  previous;
 > };
 >
 > immutable romanSystemData romanSystem[] = [
 >     {"" ,    0, 0, 0},//0
 >     {"I",    1, 0, 0},//1 8-7
 >     {"V",    5, 1, 1},//2 8-6
 >     {"X",   10, 1, 2},//3 8-5
 >     {"L",   50, 3, 3},//4 8-4
 >     {"C",  100, 3, 4},//5 8-3
 >     {"D",  500, 5, 5},//6 8-2
 >     {"M", 1000, 5, 6} //7 8-1
 > ];
 >
 > I'm happy I can use this look up table ...
 >
 > assert( 10 == find!"(a.digit == b)"( romanSystem, "X").front.value);

The rule is to look for a range (e.g. an array) to be the first argument 
that is passed to a function. Then, take that parameter out and apply 
the function to it as if the function is a member function of that 
range. This is called UFCS (universal function call syntax).

For example, since romanSystem is the first argument to the function 
call find!"(a.digit == b)", write it like this:

     romanSystem.find!"(a.digit == b)"("X")

 > Now I'm sure I can use std.algorithm map to convert say a string of
 > characters "IVXLCDM" into an array [1,5,10,50,100,500,1000]
 >
 > but somehow D template instantiation syntax is flumoxing me.
 >
 > When I try use find in map!"find!""" dmd whinges like crazy at me.
 >
 > How do you nest these things?

The good thing is, find and many other std.algorithm functions return 
ranges themselves. So, when passing those ranges as first arguments to 
other functions, the same rule applies:

     foo!F(bar!B(myRange, 'b'), 'f');

becomes (applying the rule from inside out in two steps):

1)    foo!F(myRange.bar!B('b'), 'f');

2)    myRange.bar!B('b').foo!F('f');

Ali