listFW.visitor

Class FoldLAlgo

java.lang.Object

listFW.visitor.FoldLAlgo

All Implemented Interfaces:

IListAlgo

public class FoldLAlgo
extends java.lang.Object
implements IListAlgo

Performs the fold-left (forward accumulation) algorithm using the given IAccumulator The general forward accumulation algorithm would not take an accumulator as a top-level input parameter, instead the accumulator would be hidden inside the algorithm. But since the fold process, makes the folding process invariant and the accumulator the variant piece, the accumulator is thus necessarily an input parameter here.

Author:

swong

Field Summary

Fields

Modifier and Type	Field and Description
private IListAlgo	helper Helper visitor Arguable, this visitor above is unnecessary, but idea here was to stick to the general architecture of any forward accumulation algorithm, which foldl represents.

Constructor Summary

Constructors

Constructor and Description
FoldLAlgo()

Method Summary

Methods

Modifier and Type	Method and Description
java.lang.Object	emptyCase(MTList host, java.lang.Object... acc) Operates on MTList, the empty list.
java.lang.Object	nonEmptyCase(NEList host, java.lang.Object... acc) Operates on NEList, a non-empty list.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

helper

private IListAlgo helper

Helper visitor Arguable, this visitor above is unnecessary, but idea here was to stick to the general architecture of any forward accumulation algorithm, which foldl represents.

Constructor Detail

FoldLAlgo

public FoldLAlgo()

Method Detail

emptyCase

public java.lang.Object emptyCase(MTList host,
                         java.lang.Object... acc)

Description copied from interface: IListAlgo

Operates on MTList, the empty list. Since IEmptyList has only one method, execute(), there is not much the host list can do here. So the code for the empty case usually involves:

• inp, and perhaps
• host.execute(..., ...).

Specified by:

emptyCase in interface IListAlgo

Parameters:

host - the MTList that is executing this algorithm.

acc - a variable number of input parameters that can be used for any purpose.

Returns:

result from calling this method. The type of the result is problem-specific and may be null.

nonEmptyCase

public java.lang.Object nonEmptyCase(NEList host,
                            java.lang.Object... acc)

Description copied from interface: IListAlgo

Operates on NEList, a non-empty list. The host list now has a first and a rest. So the code here usually involves what host.getFirst() and host.getRest() can do to accomplish the task at hand.

• host.getFirst() is simply a data Object that the host list holds. It is problem-specific, and thus what it can do depends on the problem the current algorithm is trying to solve.
• host.getRest() in contrast is an IList! What can an IList do? execute an alogrithm IListAlgo with some input. What IListAlgo can that be? The current algorithm that is being executed is as good a candidate as any other IListAlgo. In Java, we use the key word this to reference the current receiver of the method call. Having the rest of host (recursively) execute the current algorithm is expressed in Java as: host.getRest().execute(this, ...).

To summarize, the code for the non-empty case usually involves:

• host.getFirst(), and the recursive call
• host.getRest().execute(this, something involving inp).

Specified by:

nonEmptyCase in interface IListAlgo

Parameters:

host - the NEList that is executing this algorithm

acc - a variable number of input parameters that can be used for any purpose.

Returns:

result from calling this method. The type of the result is problem-specific and may be null.