java – How to transform this simple OOP program to a functional-programming language? – Education Career Blog

During the last months I have tried to code using the functional programming paradigm. Now I have a solution in OOP and I am trying to find a functional solution.

The problem is simple. I have an algorithm, which produces two different arrays as result (a and b). Now, I want to check how good the results are. Therefore I write several evaluation criteria for them. I hope pseudo-java source code is okay for you!

// first the Algorithm class
class Algorithm {
    private a;
    private b;

    Algorithm(input) {

    getA(){return a;}
    getB(){return b;}

    void computeResult() { 
        ... // time-consuming operations 
        ... // set values for a and b

// this class tests the Algorithm using a list of evaluation criteria
class AlgorithmTest {

    AlgorithmTest() {
        ... // Definition of input
        ... // Definition of list of evaluation criteria evals
        Algorithm algorithm = new Algorithm(input); // Compute the result

        for (EvaluationCriterion eval : evals) {
            System.out.println(eval.getClassSimpleName()); // Print name of class
            System.out.println(eval.evaluate(algorithm));  // Print evaluation result

    main () {
        new AlgorithmTest();

interface EvaluationCriterion {
    double evaluate(Algorithm a);

// an example implementation of a criterion
class EvaluationA implements EvalutationCriterion{
    double evaluation(Algorithm algorithm) {
        a = algorithm.getA();
        b = algorithm.getB();
        double c = anotherComputation(a, b);
        return c;

    double anotherComputation(a, result){
        ... // compute and return result

Is it possible to “transform” this source code using functional programming paradigm?
I am sure it it, but can you still add new evaluation criteria easily like in the OOP approach?

I could write a module called algorithm that includes pure functions that compute either a or b. In this case I have to compute it twice, which requires to much time.

But how to do the evaluation step using multiple evaluation functions?


But how to do the evaluation step using multiple evaluation functions?

You’d pass in the functions you want to use, as first-class values.

Your type EvaluationCriterion is basically just the function type Algorithm -> Double (in Haskell syntax). EvaluationA, EvaluationB, etc. don’t need to be new types. They’re just values of type EvaluationCriterion. You can pass them as values, build a list of type EvaluationCriterion, etc.

The irony here is that you’ve already used first-class functions in your solution. This abstraction-weak OOP language lacks first-class functions, so you had to apply a standardized workaround (“design pattern”). Converting it to a functional language (or just a reasonable OOP language) is a matter of removing complexity.

Now, as to how to eliminate the statefulness of Algorithm, I haven’t thought about that. But do remember that FP does not mean “no state ever”. Caching pure function results is quite a common thing to do.


Something like this:

type Algorithm = Input -> (A,B)

type Accuracy  = Double
type EvaluationCriterion = Algorithm -> Accuracy

example :: EvaluationCriterion
example f = size a / (size a + size b)
    (a,b) = f 42

This particular example criterion is random nonsense, of course; you have to supply suitable functionality and types Input, A, B.


I think your Algorithm-class could be simply reduced to (Scala pseudocode – I think this is easier to understand than Haskell or Clojure as it is closer to Java)

def computeResult(input: Input): (ListResult1, ListResult2) = ...

where (a,b) is a Tuple, a simple wrapper around two values a and b.

EvaluationCriterion could be

trait EvaluationCriterion {
   def evaluate(algo : Input => (ListResult1, ListResult2)): Double

If you have a Sequence (e.g. a List) of these criterias, you can write => (crit.getClass.toString, crit.evaluate(computeResult _)))

which would result in something like Seq((CritClass1, 1.2), (CritClass2, 0.99), (CritClass3, 0.54))


Since you mentioned Clojure, here’s an easy way to do it:

(def algorithm-1 
  {:a some-calculate-a-for-algorithm-1
   :b some-calculate-b-for-algorithm-2})

(defn evaluation-1 algorithm input
  (some-computation-1 ((:a algorithm) input) ((:b algorithm) input)))

Basically you define your algorithms as being a map containing two functions (labelled :a and :b), you could easily add other data or functions into the algorithms if desired.

Then the evaluation functions just execute a computation on the results of calling the two functions for a given algorithm on the input.

If you want to get really clever, then you can create a macro as follows:

(defmacro build-evaluation-function computation
  `(fn algorithm# input# (~computation ((:a algorithm#) input#) ((:b algorithm#) input#))))

And then you can build as many evaluation functions as you like, using any function that takes two parameters as the computation:

(def evaluation-2 (build-evaluation-function add))

(def evaluation-3 (build-evaluation-function str))

; etc....

Leave a Comment