1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// VIM_TEST_SETUP let g:java_highlight_functions = 'style'
// VIM_TEST_SETUP let g:java_highlight_signature = 1
// VIM_TEST_SETUP let g:java_highlight_generics = 1
// VIM_TEST_SETUP let g:java_highlight_java_lang = 1
// VIM_TEST_SETUP hi link javaGenericsC1 Todo
// VIM_TEST_SETUP hi link javaGenericsC2 Error
// VIM_TEST_SETUP hi link javaWildcardBound Error
import java.math.BigInteger;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.LongFunction;
import java.util.function.Predicate;
class Generics$Tests<T extends Number & Comparable<? super T>, U>
{ // JDK 21+.
static final Function<Function<Object, Object>, Object> PARTIAL =
Generics$Tests.y0();
static final Function<BigInteger, BigInteger> FACTORIAL_2000 =
Generics$Tests.<BigInteger, BigInteger>y1()
.apply(f -> x -> (x.compareTo(BigInteger.ONE) < 1)
? BigInteger.ONE
: x.multiply(f.apply(x.subtract(BigInteger.ONE))));
static <T1> Y0<T1> y0()
{
return (Function<T1, T1> f) -> f.apply(
Generics$Tests.<T1>y0()
.apply(f));
}
static <T1, T2> Y1<T1, T2> y1()
{
return (Function<Function<T1, T2>, Function<T1, T2>> f) ->
(T1 x) -> f.apply(Generics$Tests.<T1, T2>y1()
.apply(f))
.apply(x);
}
static<T> void noOp(T dummy) { }
interface alpha<T> { }
interface Y0<T1> extends Function<Function<T1, T1>, T1> { }
interface Y1<T1, T2> extends Function<Function<Function<T1, T2>,
Function<T1, T2>>,
Function<T1, T2>> { }
interface Stackable<E> extends Iterable<E>
{
boolean isEmpty();
E peek();
E pop();
Stackable<E> popAll(Stackable<? super E> elements);
Stackable<E> popSome(Stackable<? super E> elements,
Predicate<? super E> filter);
Stackable<E> push(E element);
Stackable<E> pushAll(Iterable<? extends E> elements);
Stackable<E> pushSome(Iterable<? extends E> elements,
Predicate<? super E> filter);
Stackable<E> wind(Consumer<? super Stackable<E>> action);
}
sealed interface Num<N extends Number>
{
int radix();
N value();
}
record Bin<N extends Number>(N value) implements Num<N>
{
public int radix() { return 2; }
}
record Dec<N extends Number>(N value) implements Num<N>
{
public int radix() { return 10; }
}
record Hex<N extends Number>(N value) implements Num<N>
{
public int radix() { return 16; }
}
record Oct<N extends Number>(N value) implements Num<N>
{
public int radix() { return 8; }
}
static Num<Long> fromDecimal(long x, int radix)
{
record Pair(LongFunction<Num<Long>> a,
LongFunction<String> b) { }
final Pair p = switch (radix) {
case 2 -> new Pair(Bin::new, Long::toBinaryString);
case 8 -> new Pair(Oct::new, Long::toOctalString);
case 16 -> new Pair(Hex::new, Long::toHexString);
default -> new Pair(Dec::new,
y -> Long.toString(y));
};
return p.a().apply(Long.parseLong(p.b().apply(x), radix));
}
static long toDecimal(Num<Long> x)
{
return Long.parseLong(switch (x) {
case Bin<?>(Long b) -> Long.toBinaryString(b);
case Oct<?>(Long o) -> Long.toOctalString(o);
case Hex<?>(Long h) -> Long.toHexString(h);
default -> Long.toString(x.value());
}, x.radix());
}
static Class<?> eitherComparableOrIterable(Object o)
{
final boolean comparable;
return ((comparable = o instanceof Comparable) ^
o instanceof Iterable)
? (comparable)
? Comparable.class
: Iterable.class
: java.lang.Class.class;
}
<A, T extends java.util.function.Supplier<A>,
B, U extends java.util.function.Supplier<B>> U convert(T o)
{
throw new UnsupportedOperationException("TODO");
}
@java.lang.annotation.Target(
java.lang.annotation.ElementType.TYPE_USE)
@interface Taggable
{
String value() default "";
}
{
int N = 0, X = 1, Y = 2;
Predicate<T> f = y->N<y.intValue();
Predicate<T> g = y->X<N&&(Integer)y>N;
boolean[] bb = {
X<N||N>Y, X < Y, X <Y, X <(Y), X<(Y), (X)<Y,
Double.isFinite(X<<Y),
X<=Y, X<(int)(byte)Y, X<~Y, X<-Y, X<+Y,
};
Class<?> klass = Generics$Tests.class;
Class< java.lang.Class<@Taggable("<>")int[][]> [] [] >
[ ] [ ] $ [ ] [ ];
if (false) { new Generics$Tests<>(); }
alpha<?> ao;
alpha<U> au;
alpha<alpha<U>> aau;
alpha<Y0<?>> ay0o;
alpha<Y0<U>> ay0u;
Y0<alpha<?>> y0ao;
Y0<alpha<U>> y0au;
}
}
|
