Problem Statement

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: 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: 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

Let's start with the solution:

import "/fmt" for Fmt

var multiplier = Fn.new { |n1, n2| Fn.new { |m| n1 * n2 * m } }

var orderedCollection = Fn.new {
    var x  = 2.0
    var xi = 0.5
    var y  = 4.0
    var yi = 0.25
    var z  = x + y
    var zi = 1.0 / ( x + y )
    return [[x, y, z], [xi, yi, zi]]
}

var oc = orderedCollection.call()
for (i in 0..2) {
    var x = oc[0][i]
    var y = oc[1][i]
    var m = 0.5 // rather than 1 to compare with first-class functions task
    Fmt.print("$0.1g * $g * $0.1g = $0.1g", x, y, m, multiplier.call(x, y).call(m))
}