user
In First-class functions, a language is showing how its manipulation of functions is similar to its manipulation of other types.

This tasks aim is to compare and contrast a language's implementation of first class functions, with its normal handling of numbers.

Write a program to create an ordered collection of a mixture of literally typed and expressions producing a real number, together with another ordered collection of their multiplicative inverses. Try and use the following pseudo-code to generate the numbers for the ordered collections:

```
  x  = 2.0
  xi = 0.5
  y  = 4.0
  yi = 0.25
  z  = x + y
  zi = 1.0 / ( x + y )

```

Create a function *multiplier*, that given two numbers as arguments returns a function that when called with one argument, returns the result of multiplying the two arguments to the call to multiplier that created it and the argument in the call:

```
 new_function = multiplier(n1,n2)
 # where new_function(m) returns the result of n1 * n2 * m

```

Applying the multiplier of a number and its inverse from the two ordered collections of numbers in pairs, show that the result in each case is one.  
**Compare and contrast the resultant program with the corresponding entry in First-class functions.** They should be close.

To paraphrase the task description: Do what was done before, but with numbers rather than functions
assistant
(formerly Perl 6)

**Works with**: Rakudo version 2015-09-10

```
sub multiplied ($g, $f) { return { $g * $f * $^x } }
 
my $x  = 2.0;
my $xi = 0.5;
my $y  = 4.0;
my $yi = 0.25;
my $z  = $x + $y;
my $zi = 1.0 / ( $x + $y );

my @numbers = $x, $y, $z;
my @inverses = $xi, $yi, $zi;
 
for flat @numbers Z @inverses { say multiplied($^g, $^f)(.5) }

```

Output:

```
0.5
0.5
0.5
```

The structure of this is identical to first-class function task.