Iterable

1. Iterable

An **iterable** is a fundamental concept in programming, and understanding it is crucial for effectively working with collections of data. This article provides a comprehensive introduction to iterables, specifically within the context of scripting languages often used in MediaWiki extensions, focusing on PHP as it is the language MediaWiki is built upon. We will cover what iterables are, how they differ from other data structures, how to create and use them, and their practical applications, including how they relate to Loops and data manipulation within MediaWiki's environment. This article is geared towards beginners, assuming limited prior programming experience.

1. 1. What is an Iterable?

At its core, an iterable is any object capable of returning its members one at a time. This "returning members one at a time" process is called *iteration*. Think of it like a conveyor belt delivering items sequentially. Each item on the belt is a member of the iterable. Crucially, an iterable doesn't necessarily need to contain all its elements in memory simultaneously. This is a key difference between iterables and, for example, a standard array.

In PHP, many data types are inherently iterable. These include:

• **Arrays:** The most common iterable in PHP.
• **Objects implementing the `Iterator` interface:** This allows custom classes to define their own iteration behavior.
• **Traversable objects:** A broader interface than `Iterator`, encompassing objects that can be iterated over, often representing data sources like databases or files.
• **Strings:** A string can be iterated over character by character.

An iterable *doesn't* have to be a collection of the same data type. PHP arrays, for instance, can contain a mix of integers, strings, and even other arrays.

1. 1. Iterables vs. Arrays

While arrays are iterables, not all iterables are arrays. This distinction is important for understanding performance and flexibility.

• **Arrays:** Store all elements in contiguous memory locations. Accessing an element by its index is very fast. However, large arrays can consume significant memory.
• **Iterators/Traversables:** Generate elements on demand. They don't need to store everything in memory at once. This is beneficial when dealing with very large datasets, as it avoids memory exhaustion. Accessing an element requires iterating through the sequence until that element is reached, which can be slower than direct array access.

Consider a scenario where you need to process a large log file. Loading the entire file into an array would likely exceed available memory. An iterator, on the other hand, can read and process the file line by line, minimizing memory usage.

1. 1. The `Iterator` Interface

To create a custom iterable object in PHP, you need to implement the `Iterator` interface. This interface requires you to define two methods:

• `current()`: Returns the current element of the iteration.
• `next()`: Advances the iteration to the next element.
• `key()`: Returns the key of the current element.
• `valid()`: Checks if the current iteration is valid (i.e., if there are more elements to iterate over).
• `rewind()`: Resets the iteration to its initial state.

Here's a simplified example:

```php class MyIterable implements Iterator {

   private $data = ['apple', 'banana', 'cherry'];
   private $position = 0;

   public function current(): mixed {
       return $this->data[$this->position];
   }

   public function next(): void {
       $this->position++;
   }

   public function key(): mixed {
       return $this->position;
   }

   public function valid(): bool {
       return isset($this->data[$this->position]);
   }

   public function rewind(): void {
       $this->position = 0;
   }

}

$iterable = new MyIterable();

foreach ($iterable as $key => $value) {

   echo "Key: " . $key . ", Value: " . $value . "\n";

} ```

This example demonstrates the basic structure of an `Iterator`. The `$data` array holds the elements, and the `$position` variable keeps track of the current element during iteration. The methods implement the required functionality of the `Iterator` interface.

1. 1. Using Iterables with Loops

Iterables are most commonly used with `foreach` loops. The `foreach` loop automatically handles the iteration process, making your code cleaner and more readable.

```php $array = [1, 2, 3, 4, 5];

foreach ($array as $value) {

   echo $value . "\n";

}

// With keys: foreach ($array as $key => $value) {

   echo "Key: " . $key . ", Value: " . $value . "\n";

} ```

The `foreach` loop iterates over the iterable, assigning each element to the `$value` variable (and its corresponding key to the `$key` variable, if specified).

1. 1. Traversable Interface

The `Traversable` interface is a broader interface than `Iterator`. Any class that implements `Iterator` also implements `Traversable`. `Traversable` is often used when working with data sources that may not directly implement `Iterator` but can still be iterated over. This is particularly relevant when dealing with external resources like databases or files.

1. 1. Generators: A Simplified Approach to Iterables

PHP provides a more convenient way to create iterables using **generators**. Generators are functions that can pause their execution and yield a value. The next time the generator is called, it resumes from where it left off. This is achieved using the `yield` keyword.

```php function generateNumbers(int $start, int $end): Generator {

   for ($i = $start; $i <= $end; $i++) {
       yield $i;
   }

}

foreach (generateNumbers(1, 5) as $number) {

   echo $number . "\n";

} ```

In this example, `generateNumbers` is a generator function. The `yield $i;` statement pauses the function and returns the value of `$i`. The next time the loop requests a value, the function resumes from the `yield` statement and continues to the next iteration. Generators are memory-efficient and can significantly simplify the creation of iterables, especially for complex iteration logic.

1. 1. Practical Applications in MediaWiki

Iterables are used extensively within MediaWiki for various tasks:

• **Iterating over revisions of a page:** The Revision API returns data that can be treated as an iterable.
• **Processing category members:** Retrieving and processing the members of a category involves iterating over a list of pages.
• **Handling search results:** The Search API returns search results that are often presented as an iterable.
• **Parsing wikitext:** Wikitext parsing involves iterating over tokens and elements within the wikitext markup.
• **Database Queries:** Result sets from database queries can be treated as iterables, allowing you to process each row individually. This is crucial for large datasets.
• **Working with Templates:** Iterating over template parameters.
• **Modules and their dependencies:** Managing and iterating over module dependencies.

1. 1. Advanced Concepts

• **Infinite Iterators:** You can create iterators that theoretically never end, useful for streaming data or generating sequences. Be careful when using these, as they can lead to infinite loops if not handled correctly.
• **Lazy Evaluation:** Iterators and generators enable lazy evaluation, meaning that values are computed only when they are needed. This can improve performance, especially when dealing with expensive computations.
• **Chaining Iterators:** You can combine multiple iterators to create more complex iteration pipelines. For example, you could filter an iterator to remove unwanted elements, then map it to transform the remaining elements.

1. 1. Technical Analysis and Trading Strategies Relevance

Understanding iterables is crucial when implementing or analyzing trading strategies and technical indicators within a MediaWiki environment (e.g., through a custom extension). Consider these scenarios:

• **Backtesting:** When backtesting a Moving Average strategy, you need to iterate through historical price data to calculate the moving average at each point in time. Iterables provide an efficient way to process this data.
• **Bollinger Bands:** Calculating Bollinger Bands involves iterating through price data to compute the moving average and standard deviation.
• **Fibonacci Retracements:** Identifying Fibonacci retracement levels requires iterating through price data to find swing highs and lows.
• **MACD (Moving Average Convergence Divergence):** Calculating the MACD requires iterating through price data and applying multiple moving averages.
• **Volume Weighted Average Price (VWAP):** Calculating VWAP involves iterating through price and volume data.
• **Risk Management:** Iterating through a portfolio of assets to calculate overall risk exposure.
• **Candlestick Patterns:** Identifying candlestick patterns involves iterating through price data to analyze the shape and position of candlesticks.
• **Elliott Wave Theory:** Analyzing Elliott Wave patterns requires iterative identification of wave structures.
• **Ichimoku Cloud:** Calculating the Ichimoku Cloud involves iterating through price data to compute various components.
• **Relative Strength Index (RSI):** Calculating RSI requires iterating through price data to determine average gains and losses.
• **Stochastic Oscillator:** Calculating the Stochastic Oscillator involves iterating through price data to determine overbought and oversold conditions.
• **Average True Range (ATR):** Calculating ATR requires iterating through price data to determine the true range.
• **Donchian Channels:** Calculating Donchian Channels involves iterating through price data to find the highest high and lowest low over a specific period.
• **Parabolic SAR:** Calculating Parabolic SAR involves iterative calculations based on price and acceleration factors.
• **Pivot Points:** Calculating pivot points involves iterating through price data to find the high, low, and close prices.
• **Market Sentiment Analysis:** Iterating through news articles or social media posts to gauge market sentiment.
• **Correlation Analysis:** Iterating through the price data of multiple assets to calculate their correlation.
• **Trend Following:** Iterating through historical data to identify and capitalize on established trends.
• **Mean Reversion:** Iterating through data to identify deviations from the mean and capitalize on the reversion.
• **Arbitrage Opportunities:** Iterating through price data across different exchanges to identify arbitrage opportunities.
• **Algorithmic Trading:** Iterables form the bedrock of many algorithmic trading systems, allowing for automated execution of trading strategies.
• **Portfolio Optimization:** Iterating through different asset allocations to find the optimal portfolio based on risk and return objectives.
• **Backtesting Frameworks:** Building robust backtesting frameworks relies heavily on efficient iteration over historical data.
• **Real-time Data Feeds:** Processing real-time data feeds requires continuous iteration to update indicators and trading signals.

1. 1. Conclusion

Iterables are a powerful and versatile tool for working with data in PHP and, by extension, within the MediaWiki ecosystem. Understanding the concepts of iterators, traversables, and generators will enable you to write more efficient, readable, and maintainable code, especially when dealing with large datasets or complex data processing tasks. Mastering iterables is essential for developing custom extensions, analyzing data, and implementing sophisticated trading strategies within MediaWiki.

Data Types Functions Classes PHP MediaWiki API Loops Arrays Objects Extension Development Templates