Docs & rules

higher-kinded-j/higher-kinded-jGitHub

This is a public, read-only report. Striff reads this repository's docs, turns each sentence that makes a claim about the code into a rule, and checks the rule against the code on the default branch. How this works

main5ee7ab3Last read Oct 3

Is this yours? Install to manage it

Once installed, Striff checks every pull request.

109

108

26 docs

higher-kinded-j/higher-kinded-jOpen repository

higher-kinded-j/higher-kinded-j — documented rules

109 of 109 rules, printed October 14, 2026.

	The sentence in your docs
Read Oct 2	it implements `Combinable` but not `Chainable`. 2 rules from this sentence	FreeApPath may not implement Chainable	Holds
Read Oct 2		FreeApPath implements Combinable	Holds
Read Oct 2	`VStreamPath` does not honour `HttpHeaderCarrier`, because the response status and headers are committed before the first SSE event.	VStreamPath may not depend on HttpHeaderCarrier	Holds
Read Oct 2	`TrampolinePath.done(value)` signals completion.	TrampolinePath has a `done` method	Holds
Read Oct 2	`TrampolinePath.defer(supplier)` describes the next step without immediately executing it.	TrampolinePath has a `defer` method	Holds
Read Oct 2	When you call `run()`, the trampoline bounces through the deferred steps in a loop, never growing the call stack.	TrampolinePath has a `run` method	Holds
Read Oct 2	Feature Combining ( zipWith ), FreePath Yes, FreeApPath Yes	FreeApPath has `zipWith`	Holds
Read Oct 2	`bracket` is the fundamental resource pattern:	IOPath has `bracket`	Holds
Read Oct 2	When your resource implements `AutoCloseable`, `withResource` provides a cleaner syntax:	IOPath has `withResource`	Holds
Read Oct 2	The guarantee runs whether `fetchData()` succeeds or fails.	IOPath has `guarantee`	Holds
Read Oct 2	`parZipWith` runs two `IOPath` computations concurrently and combines their results:	IOPath has `parZipWith`	Holds
Read Oct 2	The same typed overload exists for `firstSuccess`, `raceVTask`, `firstVTaskSuccess`, and `firstCompletedSuccess`. 4 rules from this sentence	PathOps has `firstSuccess`	Holds
		PathOps has `raceVTask`	Holds
		PathOps has `firstVTaskSuccess`	Holds
		PathOps has `firstCompletedSuccess`	Holds
Read Oct 2	For a runtime-sized list, bridge the empty case to a value with `NonEmptyList.fromList(list).map(PathOps::raceIO)`. 2 rules from this sentence	PathOps has `raceIO`	Holds
Read Oct 2		NonEmptyList has a `fromList` method	Holds
Read Oct 2	Cons works from the front (head/tail), Snoc works from the back (init/last).	TimeSource has `now`	Holds
Read Oct 2	`getLeft()`/`getRight()` return `Maybe` and never throw. 2 rules from this sentence	EitherOrBoth has a `getLeft` method	Holds
Read Oct 2		EitherOrBoth has a `getRight` method	Holds
Read Oct 2	full `Validated`-style accumulation lives on `EitherOrBothPath` (`zipWithAccum`).	EitherOrBothPath has `zipWithAccum`	Holds
Read Oct 2	Definition: An immutable list guaranteed by its type to contain at least one element: a `head` plus a (possibly empty) `tail`.	NonEmptyList has `head`	Holds
Read Oct 2	Because non-emptiness is encoded in the type, `head`, `last`, `reduce`, `min`, and `max` are total (they never throw and return no `Optional`). 4 rules from this sentence	NonEmptyList has `last`	Holds
		NonEmptyList has `reduce`	Holds
		NonEmptyList has `min`	Holds
		NonEmptyList has `max`	Holds
Read Oct 2	a `head` plus a (possibly empty) `tail`.	NonEmptyList has `tail`	Holds
Read Oct 2	Testing: inject `TimeSource.fixed(...)`, or `TimeSource.of(steppableClock)` with `hkj-test`'s `SteppableClock`, and time-dependent code becomes deterministic by moving the clock rather than sleeping. 2 rules from this sentence	TimeSource has a `fixed` method	Holds
Read Oct 2		TimeSource has an `of` method	Holds
Read Oct 2	Modern accumulating idiom: the canonical error channel is now NonEmptyList, so `Validated.invalidNel("...")` and `Validated.validNel(value)` bake in the `Semigroup` and drop the manual `Semigroups.list()` argument. 2 rules from this sentence	Validated has an `invalidNel` method	Holds
Read Oct 2		Validated has a `validNel` method	Holds
Read Oct 2	To build a record from several validated fields with every error located, use Validated Assembly (`Validated.fields()`), which reports each failure as a FieldError.	Validated has a `fields` method	Holds
Read Oct 2	Each Path type offers consistent operations (`map`, `via`, `recover`, `run`) regardless of the underlying effect. 26 rules from this sentence	EitherPath has a `map` method	Holds
		EitherPath has a `via` method	Holds
		EitherPath has a `recover` method	Holds
		EitherPath has a `run` method	Holds
		MaybePath has a `map` method	Holds
		MaybePath has a `via` method	Holds
		MaybePath has a `recover` method	Holds
		MaybePath has a `run` method	Holds
		TryPath has a `map` method	Holds
		TryPath has a `via` method	Holds
		TryPath has a `recover` method	Holds
		TryPath has a `run` method	Holds
		IOPath has a `map` method	Holds
		IOPath has a `via` method	Holds
		IOPath has a `run` method	Holds
		ValidationPath has a `map` method	Holds
		ValidationPath has a `via` method	Holds
		ValidationPath has a `recover` method	Holds
		ValidationPath has a `run` method	Holds
		TrampolinePath has a `map` method	Holds
		TrampolinePath has a `via` method	Holds
		TrampolinePath has a `run` method	Holds
		CompletableFuturePath has a `map` method	Holds
		CompletableFuturePath has a `via` method	Holds
		CompletableFuturePath has a `recover` method	Holds
		CompletableFuturePath has a `run` method	Holds
Read Oct 2	Path Type MaybePath<A>, Underlying Effect Maybe<A>, Purpose Optional values	MaybePath depends on Maybe	Holds
Read Oct 2	Path Type TryPath<A>, Underlying Effect Try<A>, Purpose Exception handling	TryPath depends on Try	Holds
Read Oct 2	Path Type ValidationPath<E, A>, Underlying Effect Validated<E, A>, Purpose Error accumulation	ValidationPath depends on Validated	Holds
Read Oct 2	Path Type TrampolinePath<A>, Underlying Effect Trampoline<A>, Purpose Stack-safe recursion	TrampolinePath depends on Trampoline	Holds
Read Oct 2	Multiple interpreters are combined using `Interpreters.combine()`.	Interpreters has a `combine` method	Holds
Read Oct 2	It speaks the full family vocabulary (`map`/`via`/`then`, `mapError`/`recover`/`recoverWith`/`bimap`). 7 rules from this sentence	VResultPath has `map`	Holds
		VResultPath has `via`	Holds
		VResultPath has `then`	Holds
		VResultPath has `mapError`	Holds
		VResultPath has `recover`	Holds
		VResultPath has `recoverWith`	Holds
		VResultPath has `bimap`	Holds
Read Oct 2	`Edits.combine(...)` folds several pure edits (`set`, `modify`) into one reusable Update at compile time;	Edits has a `combine` method	Holds
Read Oct 2	`Edits.accumulate(...)` adds the validated REST-`PATCH` shape: it mixes pure and fallible edits, reports every bad field at once (each located as a FieldError), and applies the writes only if all validated.	Edits has an `accumulate` method	Holds
Read Oct 2	`ErrorEnvelope<C>(String code, String message, Instant timestamp, C context)`, where `C` is a typed context record rather than a `Map<String, Object>`. 4 rules from this sentence	ErrorEnvelope has `code`	Holds
		ErrorEnvelope has `message`	Holds
		ErrorEnvelope has `timestamp`	Holds
		ErrorEnvelope has `context`	Holds
Read Oct 2	`withContext(D)` is the record wither that replaces the context (and may change its type), while the generated `editContext` transforms the existing one.	ErrorEnvelope has a `withContext` method	Holds
Read Oct 2	Located automatically: `Validated.fields()` and the `parseIfPresent` edits prepend the field label onto each error's path, so a leaf validator creates unlocated `FieldError.of(...)`s and the assembly attaches the location.	Validated has a `fields` method	Holds
Read Oct 2	`foldMap(Monoid<M> monoid, Function<A, M> f, S source)` - Map and combine all values	Fold has a `foldMap` method	Holds
Read Oct 2	`exists(Predicate<A> p, S source)` - Check if any value satisfies predicate	Fold has an `exists` method	Holds
Read Oct 2	`all(Predicate<A> p, S source)` - Check if all values satisfy predicate	Fold has an `all` method	Holds
Read Oct 2	Definition: The stock ValidatedPrism vocabulary for the common wire-to-domain conversion families: one static factory per family (`uuid()`, `uri()`, `localDate()`, `instant()`, `offsetDateTime()`, `enumByName(Class)`, `bigDecimal()`, `intFromString()`, `booleanStrict()`, `currency()`, `locale()`, and friends). 11 rules from this sentence	StandardCodecs has an `uuid` method	Holds
		StandardCodecs has an `uri` method	Holds
		StandardCodecs has a `localDate` method	Holds
		StandardCodecs has an `instant` method	Holds
		StandardCodecs has an `offsetDateTime` method	Holds
		StandardCodecs has an `enumByName` method	Holds
		StandardCodecs has a `bigDecimal` method	Holds
		StandardCodecs has an `intFromString` method	Holds
		StandardCodecs has a `booleanStrict` method	Holds
		StandardCodecs has a `currency` method	Holds
		StandardCodecs has a `locale` method	Holds
Read Oct 2	`ValidatedPrism.canonical(message, parse, render)` wraps a throwing parser with the section law guarded per value: the render defines the canonical form and every spelling it cannot reproduce is a located rejection (an injective render stays your obligation);	ValidatedPrism has a `canonical` method	Holds
Read Oct 2	`ValidatedPrism.fromIso(iso)` is a parse that never fails;	ValidatedPrism has a `fromIso` method	Holds
Read Oct 2	`ValidatedPrism.fromPrism(prism, reason)` lifts a plain prism by supplying the reason its empty case cannot express.	ValidatedPrism has a `fromPrism` method	Holds
Read Oct 3	@EffectAlgebra public sealed interface PaymentGatewayOp<A> permits PaymentGatewayOp.Authorise, PaymentGatewayOp.Charge, PaymentGatewayOp.Refund {	PaymentGatewayOp is a contract, and PaymentGatewayOp is declared sealed, and PaymentGatewayOp is annotated with EffectAlgebra	Holds
Read Oct 3	@HttpExchange("/users") @HkjHttpClient public interface UserClientApi {	UserClientApi is a contract, and UserClientApi is annotated with HttpExchange, and UserClientApi is annotated with HkjHttpClient	Holds
Read Oct 2	The key insight is that *EffectBoundary does not create new infrastructure; it bridges Free monads into the existing Path type ecosystem** that hkj-spring already handles.	EffectBoundary depends on Free	Holds
Read Oct 2	`EffectBoundary.runIO()` returns `IOPath<A>`, which the existing `IOPathReturnValueHandler` already handles:	EffectBoundary depends on IOPath	Holds
Read Oct 2	`ObservableEffectBoundary` wraps an `EffectBoundary` with Micrometer metrics.	ObservableEffectBoundary depends on EffectBoundary	Holds
Read Oct 2	Controllers can return either the raw `EitherOrBoth` or its Path wrapper `EitherOrBothPath`; both are handled by `EitherOrBothPathReturnValueHandler`. 2 rules from this sentence	EitherOrBothPathReturnValueHandler depends on EitherOrBoth	Holds
Read Oct 2		EitherOrBothPathReturnValueHandler depends on EitherOrBothPath	Holds
Read Oct 2	When an `Either`, `Validated`, `EitherOrBoth`, or `NonEmptyList` appears inside a DTO (for example a batch result containing `List<Either<DomainError, User>>`), the `HkjJacksonModule` serialises it with a tagged shape: 3 rules from this sentence	HkjJacksonModule depends on Validated	Holds
		HkjJacksonModule depends on EitherOrBoth	Holds
		HkjJacksonModule depends on NonEmptyList	Holds
Read Oct 2	`ValidatedUserDetailsService` validates the username with `Validated`, accumulating all format errors (too short and illegal characters, not just the first) before looking the user up.	ValidatedUserDetailsService depends on Validated	Holds
Read Oct 2	The default `DefaultErrorStatusCodeStrategy` consults `hkj.web.error-status-mappings` first, then falls back to `ErrorStatusCodeMapper`'s tokenised heuristics, then to `hkj.web.either.default-error-status`.	DefaultErrorStatusCodeStrategy depends on ErrorStatusCodeMapper	Holds
Read Oct 3	The `EitherTMonad<F, L>` class implements `MonadError<EitherTKind.Witness<F, L>, L>`, providing the standard monadic operations for the combined structure.	EitherTMonad implements MonadError	Holds
Read Oct 2	Retry-After. `ClientErrorResponse.retryAfter()` exposes a server `Retry-After` hint (delta-seconds or HTTP-date) as an `Optional<Duration>` — read it in a custom decoder to seed `VTaskPath.withRetry`.	ClientErrorResponse has a `retryAfter` method	Holds

109 rules from 9 docs

See these where the change is. The browser extension puts a pull request's doc findings, and a diagram of what it changed, on the GitHub page itself, so the code and what your docs say about it are side by side.