Java Records: глубокое погружение и паттерны использования за пределами DTO

// Sealed иерархия с Records для pattern matching
public sealed interface Result<T> {
    record Success<T>(T value, String message) implements Result<T> {}
    record Failure<T>(String error, Throwable cause) implements Result<T> {}
    record Loading<T>() implements Result<T> {}
    record Empty<T>() implements Result<T> {}
}

@Service
public class OrderProcessor {
    
    public String processResult(Result<Order> result) {
        // Полноценное pattern matching с destructuring
        return switch (result) {
            case Result.Success<Order>(var order, var msg) when order.amount().isGreaterThan(Money.ZERO) ->
                "Success: " + msg + " - Order total: " + order.total().formatted();
                
            case Result.Success<Order>(var order, var msg) ->
                "Success with zero amount: " + msg;
                
            case Result.Failure<Order>(var error, var cause) when cause != null ->
                "Error: " + error + " (cause: " + cause.getMessage() + ")";
                
            case Result.Failure<Order>(var error, null) ->
                "Error: " + error;
                
            case Result.Loading<Order>() ->
                "Processing in progress...";
                
            case Result.Empty<Order>() ->
                "No data available";
        };
    }
    
    // Композиция функций с Records
    public Result<Order> fetchOrder(String orderId) {
        try {
            Order order = database.findOrder(orderId);
            if (order == null) {
                return new Result.Empty<>();
            }
            return new Result.Success<>(order, "Order retrieved successfully");
        } catch (SQLException e) {
            return new Result.Failure<>("Database error: " + e.getMessage(), e);
        }
    }
    
    public Result<Order> validateOrder(Result<Order> result) {
        return switch (result) {
            case Result.Success<Order>(var order, var msg) when order.amount().isZero() ->
                new Result.Failure<>("Order amount cannot be zero", null);
            case Result.Success<Order>(var order, var msg) ->
                result; // Valid order
            default -> result; // Propagate other results
        };
    }
}

3.2. Композиция и трансформация с помощью Records

// Функторы и аппликативы с использованием Records
public record Functor<T>(T value) {
    
    public <R> Functor<R> map(Function<T, R> f) {
        return new Functor<>(f.apply(value));
    }
    
    public <R> Functor<R> flatMap(Function<T, Functor<R>> f) {
        return f.apply(value);
    }
    
    public T getOrElse(T defaultValue) {
        return value != null ? value : defaultValue;
    }
}

// Either монада как Record
public sealed interface Either<L, R> {
    record Left<L, R>(L value) implements Either<L, R> {}
    record Right<L, R>(R value) implements Either<L, R> {}
    
    default <T> T fold(Function<L, T> leftFn, Function<R, T> rightFn) {
        return switch (this) {
            case Left<L, R>(var l) -> leftFn.apply(l);
            case Right<L, R>(var r) -> rightFn.apply(r);
        };
    }
    
    default <T> Either<L, T> map(Function<R, T> fn) {
        return match(
            left -> new Either.Left<>(left.value()),
            right -> new Either.Right<>(fn.apply(right.value()))
        );
    }
    
    default Either<L, R> onLeft(Consumer<L> consumer) {
        if (this instanceof Either.Left<L, R>(var l)) {
            consumer.accept(l);
        }
        return this;
    }
    
    default Either<L, R> onRight(Consumer<R> consumer) {
        if (this instanceof Either.Right<L, R>(var r)) {
            consumer.accept(r);
        }
        return this;
    }
    
    private <T> T match(Function<L, T> left, Function<R, T> right) {
        return fold(left, right);
    }
}

// Try монада как Record
public sealed interface Try<T> {
    record Success<T>(T value) implements Try<T> {}
    record Failure<T>(Throwable error) implements Try<T> {}
    
    static <T> Try<T> of(CheckedSupplier<T> supplier) {
        try {
            return new Success<>(supplier.get());
        } catch (Throwable t) {
            return new Failure<>(t);
        }
    }
    
    default Try<T> onSuccess(Consumer<T> consumer) {
        if (this instanceof Success<T>(var v)) {
            consumer.accept(v);
        }
        return this;
    }
    
    default Try<T> onFailure(Consumer<Throwable> consumer) {
        if (this instanceof Failure<T>(var e)) {
            consumer.accept(e);
        }
        return this;
    }
    
    default <R> Try<R> map(Function<T, R> fn) {
        return switch (this) {
            case Success<T>(var v) -> Try.of(() -> fn.apply(v));
            case Failure<T>(var e) -> new Failure<>(e);
        };
    }
    
    default T getOrElse(T defaultValue) {
        return this instanceof Success<T>(var v) ? v : defaultValue;
    }
}

@FunctionalInterface
interface CheckedSupplier<T> {
    T get() throws Throwable;
}

Продвинутые паттерны и кастомизация

4.1. Строитель (Builder) для Records

// Builder паттерн для Records с многими параметрами
public record Product(String id, String name, String description, 
                      Money price, List<String> categories, 
                      List<String> tags, Map<String, String> metadata,
                      LocalDate createdAt, boolean active) {
    
    public static Builder builder() {
        return new Builder();
    }
    
    public static class Builder {
        private String id;
        private String name;
        private String description = "";
        private Money price;
        private List<String> categories = new ArrayList<>();
        private List<String> tags = new ArrayList<>();
        private Map<String, String> metadata = new HashMap<>();
        private LocalDate createdAt = LocalDate.now();
        private boolean active = true;
        
        public Builder id(String id) {
            this.id = id;
            return this;
        }
        
        public Builder name(String name) {
            this.name = name;
            return this;
        }
        
        public Builder description(String description) {
            this.description = description;
            return this;
        }
        
        public Builder price(Money price) {
            this.price = price;
            return this;
        }
        
        public Builder addCategory(String category) {
            this.categories.add(category);
            return this;
        }
        
        public Builder addTag(String tag) {
            this.tags.add(tag);
            return this;
        }
        
        public Builder putMetadata(String key, String value) {
            this.metadata.put(key, value);
            return this;
        }
        
        public Builder createdAt(LocalDate createdAt) {
            this.createdAt = createdAt;
            return this;
        }
        
        public Builder active(boolean active) {
            this.active = active;
            return this;
        }
        
        public Product build() {
            if (id == null || id.isBlank()) {
                throw new IllegalStateException("Product ID is required");
            }
            if (name == null || name.isBlank()) {
                throw new IllegalStateException("Product name is required");
            }
            if (price == null) {
                throw new IllegalStateException("Product price is required");
            }
            return new Product(id, name, description, price, 
                               List.copyOf(categories), 
                               List.copyOf(tags),
                               Map.copyOf(metadata),
                               createdAt, active);
        }
    }
}

// Использование
Product product = Product.builder()
    .id("P-123")
    .name("Ultra Laptop")
    .description("High-performance laptop for developers")
    .price(new Money(new BigDecimal("1299.99"), Currency.getInstance("USD")))
    .addCategory("Electronics")
    .addCategory("Computers")
    .addTag("laptop")
    .addTag("new")
    .putMetadata("color", "silver")
    .putMetadata("processor", "Intel i7")
    .active(true)
    .build();

4.2. Wither методы для «изменения» иммутабельных Records