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 toPrettyString();

record ExternalPage(URI url, String content) { }

public record GitHubPrPage(..., Set<Page> links) {

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

}

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

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

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

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

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) {

	ExternalPage {
		Objects.requireNonNull(url);
		Objects.requireNonNull(content);
		if (content.isBlank())
			throw new IllegalArgumentException();
	}

}

public Stats evaluateStatistics();
public String toPrettyString();

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 GitHubPrPage pr -> // use `pr`
	case ExternalPage ext -> // use `ext`
	// ...
};

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 GitHubIssuePage issue -> numberOfIssues++;
		case GitHubPrPage pr -> numberOfPrs++;
		case ExternalPage ext -> numberOfExternals++;
		case ErrorPage err -> numberOfErrors++;
	}
}

public static String toPrettyString(Page rootPage) {
	if (!(rootPage instanceof GitHubPage ghPage))
		return createPrettyString(rootPage);

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

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

record ExternalPage(URI url, String content) { }

// elsewhere
switch (page) {
	case ExternalPage(var url, var content)
		-> // use `url` and `content` here
}

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

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

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

record GitHubCommitPage(/*…*/) implements GitHubPage {

	// ...

}

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

private static String createPrettyString(Page page) {
	return switch (page) {
		case GitHubIssuePage issue -> // ...
		case GitHubPrPage pr -> // ...
		case ExternalPage external -> // ...
		case ErrorPage error -> // ...
	};
}

private static String createPrettyString(Page page) {
	return switch (page) {
		case GitHubIssuePage issue -> // ...
		case GitHubPrPage pr -> // ...
		case ExternalPage external -> // ...
		case ErrorPage error -> // ...
		// missing case: GitHubCommitPage
	};
}

private static String createPrettyString(Page page) {
	return switch (page) {
		case GitHubIssuePage issue -> // ...
		case GitHubPrPage pr -> // ...
		case GitHubCommitPage -> // ...
		case ExternalPage external -> // ...
		case ErrorPage error -> // ...
	};
}

public static String createPageEmoji(Page page) {
	return switch (page) {
		case GitHubIssuePage issue -> "🐈";
		case GitHubPrPage pr -> "🐙";
		default -> "n.a.";
	};
}

public static String createPageEmoji(Page page) {
	return switch (page) {
		case GitHubIssuePage issue -> "🐈";
		case GitHubPrPage pr -> "🐙";
		// duplication 😢
		case ErrorPage err -> "n.a.";
		case ExternalPage ext -> "n.a.";
	};
}

public static String createPageEmoji(Page page) {
	return switch (page) {
		case GitHubIssuePage issue -> "🐈";
		case GitHubPrPage pr -> "🐙";
		case ErrorPage _, ExternalPage _ -> "n.a.";
	};
}

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 Match<T> { }
record Exact<T>(T entity) implements Match<T> { }
record Fuzzies<T>(Collection<Fuzzy<T>> entities)
	implements Match<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 -> // ...
}