Reduce<TIn,TOut> class method

Project: Array Utilities Unit

Unit: DelphiDabbler.Lib.ArrayUtils

Record: TArrayUtils

Applies to: ~>0.1

type
  TReducer<TIn,TOut> = reference to function (const AAccumulator: TOut;
    const ACurrent: TIn): TOut;
  TReducerEx<TIn,TOut> = reference to function (const AAccumulator: TOut;
    const ACurrent: TIn; const AIndex: Integer;
    const AArray: array of TIn): TOut;

class function Reduce<TIn,TOut>(const A: array of TIn;
  const AReducer: TReducer<TIn,TOut>; const AInitialValue: TOut): TOut;
  overload; static;

class function Reduce<TIn,TOut>(const A: array of TIn;
  const AReducer: TReducerEx<TIn,TOut>; const AInitialValue: TOut): TOut;
  overload; static;

Description

Reduces the elements of an array to a single value of an optionally different type to that of the array elements.

Parameters:

• A - The array whose elements are to be reduced.

• AReducer - Callback function executed for each element in the array that is used to calculate the reduced value. AReducer must be a function of type TReducer<TIn,TOut> or TReducerEx<TIn,TOut>.

  Parameter(s):

  • AAccumulator - The value, of type TOut, resulting from the previous call to AReducer. On the first call, its value is set to AInitialValue.
  • ACurrent - The value of the current element of the array, of type TIn. On the first call, its value is A[0].
  • AIndex - The index of ACurrent in array A. On the first call, its value is 0. (TReducerEx<TIn,TOut> only.)
  • AArray - Reference to the array on which Reduce<TIn,TOut> was called (i.e. A). (TReducerEx<TIn,TOut> only.)

  Returns:

  • A value of type TOut that becomes the value of the AAccumulator on the next invocation of this callback. On the final call the return value becomes the return value of Reduce<TIn,TOut>.

• AInitialValue - A value, of type TOut, to which AAccumulator is initialized the first time that AReducer is called.

Returns:

• The single value of type TOut that results from running AReducer over the elements of A.

Examples

Example #1

This first example uses the first overload of Reduce<Tin,TOut> that uses a callback of type TReducer<TIn,TOut>. The procedure counts the number of strings in an array that begin with given text.

procedure Reduce_TwoTypes_Eg1;
const
  RequiredStr = 'needle';
var
  A: TArray<string>;
  CountStrsReducer: TArrayUtils.TReducer<string,Integer>;
begin
  CountStrsReducer := function (const AAccumulator: Integer;
    const ACurrent: string): Integer
    begin
      Result := AAccumulator;
      if Pos(RequiredStr, ACurrent) = 1 then
        Inc(Result);
    end;
  A := TArray<string>.Create('find', 'the', 'needle', 'and', 'more', 'needles');
  Assert(TArrayUtils.Reduce<string,Integer>(A, CountStrsReducer, 0) = 2);
end;

Exampe #2

This second example uses the second overload of Reduce<Tin,TOut> that uses a callback of type TReducerEx<TIn,TOut>. The calculates the arithmetic mean of a list of integers stored in an array.

procedure Reduce_TwoTypes_Eg2;
var
  AverageReducer: TArrayUtils.TReducerEx<Integer,Extended>;
  A: TArray<Integer>;
begin
  AverageReducer := function (const AAccumulator: Extended;
    const ACurrent: Integer; const AIndex: Integer;
    const AArray: array of Integer): Extended
    begin
      // Don't call with empty array
      Result := AAccumulator + ACurrent / Length(A);
    end;
  A := TArray<Integer>.Create(3, 6, 3, 8, 3, 2);
  Assert(
    SameValue(
      4.16666666666667,
      TArrayUtils.Reduce<Integer,Extended>(A, AverageReducer, 0),
      0.000001
    )
  );
end;

See Also

• Reduce<T>
• Transform<TIn,TOut>