Data-Oriented Programming

public class PageTreeFactory {

	public static Page loadPageTree(/*...*/) {
		// [...]
	}

}

public URL url();
public Exception error();
public String content();
public int issueNumber();
public int prNumber();
public Set<Page> links();
public Stream<Page> subtree();

public Stats evaluateStatistics();
public String printPageList();

record ExternalPage(URI url, String content) { }

public record ErrorPage(
	URI url, Exception ex) { }

public record ExternalPage(
	URI url, String content) { }

public record GitHubIssuePage(
	URI url, int issueNumber,
	String content, Set<Page> links) { }

public record GitHubPrPage(
	URI url, int prNumber,
	String content, Set<Page> links) { }

public sealed interface Page
		permits ErrorPage, SuccessfulPage {
	// ...
}

public sealed interface Page
		permits ErrorPage, SuccessfulPage {
	// ...
}

public sealed interface Page
		permits ErrorPage, SuccessfulPage {
	URI url();
}

public sealed interface SuccessfulPage
		extends Page permits ExternalPage, GitHubPage {
	String content();
}

public sealed interface GitHubPage
		extends SuccessfulPage
		permits GitHubIssuePage, GitHubPrPage {
	Set<Page> links();
	default Stream<Page> subtree() { ... }
}

record ExternalPage(URI url, String content) {
	// compact constructor
	ExternalPage {
		Objects.requireNonNull(url);
		Objects.requireNonNull(content);
		if (content.isBlank())
			throw new IllegalArgumentException();
	}
}

// compact constructor
GitHubPrPage {
	// [...]
	links = Set.copyOf(links);
}

public Stats evaluateStatistics();
public String printPageList();

if (rootPage instanceof GitHubPage ghPage)
	// do something with `ghPage`

if (!(rootPage instanceof GitHubPage ghPage))
	// can't use `ghPage` here
	return;

// do something with `ghPage` here 😈

switch (page) {
	case ExternalPage ext -> // use `ext`
	case GitHubPrPage pr -> // use `pr`
	// ...
};

public static Stats evaluate(Page rootPage) {
	Statistician statistician = new Statistician();
	statistician.evaluateTree(rootPage);
	return statistician.result();
}

private void evaluateTree(Page page) {
	if (page instanceof GitHubPage ghPage)
		ghPage.subtree().forEach(this::evaluatePage);
	else
		evaluatePage(page);
}

private void evaluatePage(Page page) {
	// `numberOf...` are fields
	switch (page) {
		case ErrorPage __ -> numberOfErrors++;
		case ExternalPage __ -> numberOfExternals++;
		case GitHubIssuePage __ -> numberOfIssues++;
		case GitHubPrPage __ -> numberOfPrs++;
	}
}

public static String printPageList(Page rootPage) {
	if (!(rootPage instanceof GitHubPage ghPage))
		return createPageName(rootPage);

	return ghPage
			.subtree()
			.map(Pretty::createPageName)
			.collect(joining("\n"));
}

private static String createPageName(Page page) {
	return switch (page) {
		case ErrorPage err
			-> "💥 ERROR: " + err.url().getHost();
		case ExternalPage ext
			-> "💤 EXTERNAL: " + ext.url().getHost();
		case GitHubIssuePage issue
			-> "🐈 ISSUE #" + issue.issueNumber();
		case GitHubPrPage pr
			-> "🐙 PR #" + pr.prNumber();
	};
}

record ExternalPage(URI url, String content) { }

// elsewhere
Object obj = // ...
if (obj instanceof ExternalPage(var url, var content))
	// use `url` and `content` here
switch (obj) {
	case ExternalPage(var url, var content) ->
		// use `url` and `content` here
}

public static String createPageName(Page page) {
	return switch (page) {
		case ErrorPage(var url, var ex)
			-> "💥 ERROR: " + url.getHost();
		case GitHubIssuePage(
				var url, var content, var links,
				int issueNumber)
			-> "🐈 ISSUE #" + issueNumber;
		// ...
	};
}

case ErrorPage(var url, _)
	-> "💥 ERROR: " + url.getHost();
case GitHubIssuePage(_, _, _, int issueNumber)
	-> "🐈 ISSUE #" + issueNumber;

private static String createPageName(Page page) {
	return switch (page) {
		case ErrorPage(var url, _)
			-> "💥 ERROR: " + url.getHost();
		case ExternalPage(var url, _)
			-> "💤 EXTERNAL: " + url.getHost();
		case GitHubIssuePage(_, _, _, issueNumber)
			-> "🐈 ISSUE #" + issueNumber;
		case GitHubPrPage(_, _, _, prNumber)
			-> "🐙 PR #" + prNumber;
	};
}

public record GitHubCommitPage(
		URI url, String hash,
		String content, Set<Page> links)
	implements GitHubPage {

	// [...]

}

public sealed interface GitHubPage
		extends SuccessfulPage
		permits GitHubIssuePage, GitHubPrPage,
			GitHubCommitPage {
	// [...]
}

// non-exhaustive ⇝ compile error
switch (page) {
	case ErrorPage _ -> numberOfErrors++;
	case ExternalPage _ -> numberOfExternalLinks++;
	case GitHubIssuePage _ -> numberOfIssues++;
	case GitHubPrPage _ -> numberOfPrs++;
}

switch (page) {
	case ErrorPage _ -> numberOfErrors++;
	case ExternalPage _ -> numberOfExternalLinks++;
	case GitHubIssuePage _ -> numberOfIssues++;
	case GitHubPrPage _ -> numberOfPrs++;
	case GitHubCommitPage _ -> numberOfCommits++;
}

record PageWithLinks(Page page, Set<URI> links) {

	PageWithLinks {
		requireNonNull(page);
		requireNonNull(links);
		links = new HashSet<>(links);
	}

	public PageWithLinks(Page page) {
		this(page, Set.of());
	}

}

// type declaration
sealed interface Match<T> { }

record None<T>() implements MatchResult<T> { }
record Exact<T>(T entity) implements Match<T> { }
record Fuzzies<T>(Collection<Fuzzy<T>> entities)
	implements MatchResult<T> { }

record Fuzzy<T>(T entity, int distance) { }

// method declaration
Match<User> findUser(String userName) { ... }

// calling the method
switch (findUser("John Doe")) {
	case None<> none -> // ...
	case Exact<> exact -> // ...
	case Fuzzies<> fuzzies -> // ...
}