java-repeat

Checked exceptions

Mon, 01 Jan 0001 00:00:00 +0000

Why it matters

IntStream.range(0, n).forEach(...) takes an IntConsumer, which cannot throw checked exceptions. The usual workaround wraps and unwraps.

STREAMS

IntStream.range(0, 3).forEach(i -> {
 try {
 Files.createFile(path(i));
 } catch (IOException e) {
 throw new UncheckedIOException(e);
 }
});

JAVA-REPEAT

repeat(3, i -> Files.createFile(path(i)));
// throws IOException

How the type is inferred

repeat is declared <E extends Throwable> ... throws E. The compiler picks E from what the lambda throws:

Migrating from 0.x

Mon, 01 Jan 0001 00:00:00 +0000

Breaking change. The new repeat returns void; it no longer collects results into a list.

Steps

1
Bump the version
```
<version>0.0.9 1.0.1</version>
```

Switch to the static import

import io.github.repeat.Repeat;
import static io.github.repeat.Repeat.*;

Rewrite each call

Result ignored

Repeat.of().times(3).repeat(i -> { send(i); return null; });
repeat(3, i -> send(i));

Result used: collect it yourself

List<String> ids = Repeat.of().times(3).repeat(i -> "id-" + i);
List<String> ids = new ArrayList<>();
repeat(3, i -> ids.add("id-" + i));

Removed types

0.0.9	1.0.0 and later
`Repeat.of()` → `RepeatContext`	`Repeat.repeat(int, IndexedAction)`
`RepeatCallback<T, E>`	`IndexedAction<E>` (no return value)
`doWithRepeat(int)`	`accept(int)`
`RepeatOperations`, `RepeatTemplate`	Removed; no replacement needed

API reference

Mon, 01 Jan 0001 00:00:00 +0000

Summary

Type	Member	Description
`Repeat`	`repeat(int, IndexedAction<E>)`	Runs the action `times` times with the zero-based index.
`IndexedAction<E>`	`accept(int)`	The action your lambda implements; may throw `E`.

Repeat

final class since 1.0.0

Kotlin-style function for running code multiple times. Designed for static import. Holds only static members; it cannot be instantiated.

public final class Repeat

repeat

public static <E extends Throwable> void repeat(
 final int times,
 final IndexedAction<E> action) throws E

Executes the action the given number of times, passing the zero-based index of each iteration. Like Kotlin’s repeat, a zero or negative times runs nothing.

TYPE PARAMETERS: E — the exception type the action may throw; inferred from the lambda.
PARAMETERS: times — the number of times to execute the actionaction — the action to execute; receives the index
THROWS: E — if the action fails; remaining iterations are not executed

Behavior

When	Result
`times > 0`	Calls `action.accept(i)` for `i = 0 … times - 1`, in order, on the calling thread.
`times <= 0`	Does nothing. The action is never called.
action throws at index `k`	Indexes `0 … k` ran. The exception propagates unchanged, not wrapped.
`action == null`	`NullPointerException` on the first iteration; nothing if `times <= 0`.

Examples

import static io.github.repeat.Repeat.*;

// method reference: collect the indexes 0, 1, 2
List<Integer> indexes = new ArrayList<>();
repeat(3, indexes::add);

// ignore the index
StringBuilder out = new StringBuilder();
repeat(2, i -> out.append("x")); // "xx"

View source Javadoc: Repeat

Credits

Mon, 01 Jan 0001 00:00:00 +0000

Contributors

java-repeat is built by its contributors on GitHub. Issues and pull requests are welcome in java-repeat/java-repeat.

Inspiration

The API follows Kotlin’s repeat function: same name, same zero-based index, same no-op for a zero or negative count.

This site

Hugo: static site generator.
JetBrains Mono: monospaced type for headings and code.
Hosted on GitHub Pages from java-repeat/java-repeat.github.io.

Getting started

Mon, 01 Jan 0001 00:00:00 +0000

Requirements

Java 8 or later.
No runtime dependencies.

Install

Maven

<dependency>
 <groupId>io.github.java-repeat</groupId>
 <artifactId>repeat</artifactId>
 <version>1.0.1</version>
</dependency>

Gradle

implementation("io.github.java-repeat:repeat:1.0.1")

Your first call

import static io.github.repeat.Repeat.*;

repeat(3, i -> System.out.println("attempt " + i));

Output

attempt 0
attempt 1
attempt 2

The lambda receives the zero-based index of each iteration. A zero or negative count does nothing.

Throwing checked exceptions

The action may throw. The exception type is inferred, so the caller declares it as if it had written the loop itself.

Search

Mon, 01 Jan 0001 00:00:00 +0000