Action (documentation 1.7.1 API)

Type Parameters:

S - Type of the object to transform through an action

All Known Subinterfaces:

Action.Dependent<S>, Action.Independent<S>

All Known Implementing Classes:

Action.JustMutate, Action.JustTransform
```
@API(status=EXPERIMENTAL,
     since="1.7.0")
public interface Action<S>
```
An action class represents a state transformation that can be performed on an object of type S. Those objects can be mutable, which means that the state changing method will return the same object, or immutable, which requires the method to return another object that represents the transformed state.
Do not implement this interface directly, but either Action.Dependent or Action.Independent. Only those can be used to create an arbitrary for a ActionChain.

Mind that there is a another interface Action which looks similar but refers to jqwik's old and deprecated style of state-based property testing. The two interfaces CANNOT be used interchangeably.

See Also:

ActionChain, ActionChainArbitrary

Nested Class Summary

Nested Classes
Modifier and Type	Interface	Description
`static interface`	`Action.Dependent<S>`	Implement this interface if you want to have the action's transforming behaviour depend on the previous state.
`static interface`	`Action.Independent<S>`	Implement this interface if you want to have the action's transforming behaviour not to depend on previous state.
`static class`	`Action.JustMutate<S>`	Subclass if you want to implement an independent action that simply mutates the given state.
`static class`	`Action.JustTransform<S>`	Subclass if you want to implement an independent action that simply transforms the given state.

Method Summary

All Methods Static Methods Instance Methods Default Methods
Modifier and Type	Method	Description
`static <T> ActionBuilder<T>`	`builder()`	Create an unconditioned ActionBuilder.
`static <T> Action.Independent<T>`	`just(java.lang.String description, Transformer<T> transformer)`	Convenience method to create an independent Action with a description and a constant transformer
`static <T> Action.Independent<T>`	`just(Transformer<T> transformer)`	Convenience method to create an independent Action with a constant transformer
`default boolean`	`precondition(S state)`	If this method returns false, the action will not be performed.
`static <T> ActionBuilder<T>`	`when(java.util.function.Predicate<T> precondition)`	Create an ActionBuilder with a precondition.

- Method Detail
  - builder
```
static <T> ActionBuilder<T> builder()
```
    Create an unconditioned ActionBuilder.
  - when
```
static <T> ActionBuilder<T> when(java.util.function.Predicate<T> precondition)
```
    Create an ActionBuilder with a precondition.
  - just
```
static <T> Action.Independent<T> just(Transformer<T> transformer)
```
    Convenience method to create an independent Action with a constant transformer
  - just
```
static <T> Action.Independent<T> just(java.lang.String description,
                                      Transformer<T> transformer)
```
    Convenience method to create an independent Action with a description and a constant transformer
  - precondition
```
default boolean precondition(S state)
```
    If this method returns false, the action will not be performed.
    Implementing this method will make the chain of actions harder to shrink.
    
    Parameters:
    
    state - the current state
    
    Returns:
    
    true if the precondition holds