ParadoxV5

REpresentational State Transfer

a fancy name for the CRUD support of a (web) server

for the client-server model
- implemented by typically web servers though HTTP(S), with data formatted in HTML, JSON or etc.
treats server resources as OOP-style objects that can be CRUDed
- a resource object can be a single item or a collection (as in OOP)
- use client-side cache and server-side resources, not suspensive states (as with a “State Diagram”)

	# frozen_string_literal: true

	# Assuming `PascalCase` only. Also possible: `English Case`, `Snake_Case`, …
	DIGITS_CASES = %w[
	zero
	one
	two
	three
	four
	five

	`configure' configures this package to adapt to many kinds of systems.

	Usage: ./configure [OPTION]... [VAR=VALUE]...

	To assign environment variables (e.g., CC, CFLAGS...), specify them as
	VAR=VALUE. See below for descriptions of some of the useful variables.

	Defaults for the options are specified in brackets.

	Configuration:

	package xyz.paradoxv5.java;
	import java.util.*;
	import org.jetbrains.annotations.*;

	/**
	For {@code List}s, there is also {@link List#indexOf(Object)} + {@link List#get}.

	For <b>sorted</b> Arrays and {@code List}s, Java has
	{@link Arrays#binarySearch(Object[], Object)} and
	{@link Collections#binarySearch(List, Object) respectively}

	# Proc and lambda share the same class {Proc}.
	# {Proc#lambda?} queries if a Proc is a lambda or not.
	#
	# You can create a proc with {Proc.new} or {Kernel#proc}.
	# You can create a lambda with the `->(){}` syntax or {Kernel#lambda}.
	#
	# `&blk` converts block `blk` to proc (when receiving args)
	# or procs or lambda to block (when passing args).
	#
	# Invoke a proc or lambda with {Proc#call}

	import java.util.*;
	import java.util.stream.Stream;

	public interface OverlappedRepeat<E> extends Collection<E> {
	static <E> Stream<E> overlappedRepeat(Stream<E> stream, int count) {
	return stream.flatMap(e -> Stream.generate(()->e).limit(count));
	}

	static <E> Stream<E> overlappedRepeat(Collection<E> collection, int count) {
	return overlappedRepeat(collection.parallelStream(), count);

	import java.io.PrintWriter;
	/** Wrapper class for {@link #of()} */
	public final class GetStackTraceString {
	/**
	@param e the {@link Throwable}
	@return
	a {@link String} form of this {@code Throwable}’s {@link Throwable#getStackTrace() stack trace}
	using {@link Throwable#printStackTrace(PrintWriter)}
	*/
	public static String of(Throwable e) {