vim

Fork of vim, an acceptable text editor
git clone git://git.laack.co/vim.git
Log | Files | Refs | README | LICENSE

java_lambda_expressions_signature.java (4893B)


      1 // VIM_TEST_SETUP let g:java_highlight_functions = 'style'
      2 // VIM_TEST_SETUP let g:java_highlight_signature = 1
      3 
      4 import java.lang.annotation.ElementType;
      5 import java.util.function.BinaryOperator;
      6 import java.util.function.Function;
      7 import java.util.function.Predicate;
      8 
      9 class LambdaExpressions$Tests	// JDK 21+.
     10 {
     11 	<I1, C1, C2, T1, T2, T3, Z1, Z2, Z3, S1, S2, S3> void test()
     12 	{	// Schönfinkel's functions.
     13 		I<I1> i = x -> x;
     14 		C<C1, C2> c = x -> y -> x;
     15 		T<T1, T2, T3> t = f -> y -> x -> f.apply(x).apply(y);
     16 		Z<Z1, Z2, Z3> z = f -> g -> x -> f.apply(g.apply(x));
     17 		S<S1, S2, S3> s = f -> g -> x -> f.apply(x)
     18 						.apply(g.apply(x));
     19 
     20 		I<I1> i01 = (var x) -> x;
     21 		I<I1> i02 = (@Taggable var x) -> x;
     22 		I<I1> i03 = (@Taggable @Taggable var x) -> x;
     23 		I<I1> i04 = (final var x) -> x;
     24 		I<I1> i05 = (@Taggable final var x) -> x;
     25 		I<I1> i06 = (@Taggable @Taggable final var x) -> x;
     26 		I<I1> i07 = (I1 x) -> x;
     27 		I<I1> i08 = (@Taggable I1 x) -> x;
     28 		I<I1> i09 = (@Taggable @Taggable I1 x) -> x;
     29 		I<I1> i10 = (final I1 x) -> x;
     30 		I<I1> i11 = (@Taggable final I1 x) -> x;
     31 		I<I1> i12 = (@Taggable @Taggable final I1 x) -> x;
     32 
     33 		I<I1[]> ii01 = (I1... x) -> x;
     34 		I<I1[]> ii02 = (@Taggable I1... x) -> x;
     35 		I<I1[]> ii03 = (@Taggable @Taggable I1... x) -> x;
     36 		I<I1[]> ii04 = (final I1... x) -> x;
     37 		I<I1[]> ii05 = (@Taggable final I1... x) -> x;
     38 		I<I1[]> ii06 = (@Taggable @Taggable final I1... x) -> x;
     39 
     40 		BinaryOperator<I1> leftConst01 = (var x, var y) -> x;
     41 		BinaryOperator<I1> leftConst02 = (@Taggable var x,
     42 					@Taggable var y) -> x;
     43 		BinaryOperator<I1> leftConst03 = (@Taggable @Taggable var
     44 					x, @Taggable @Taggable var y) -> x;
     45 		BinaryOperator<I1> leftConst04 = (final var x,
     46 					final var y) -> x;
     47 		BinaryOperator<I1> leftConst05 = (@Taggable final
     48 					var x, @Taggable final var y) -> x;
     49 		BinaryOperator<I1> leftConst06 = (@Taggable
     50 					@Taggable final var x,
     51 					@Taggable
     52 					@Taggable final var y) -> x;
     53 		BinaryOperator<I1> leftConst07 = (I1 x, I1 y) -> x;
     54 		BinaryOperator<I1> leftConst08 = (@Taggable I1 x,
     55 					@Taggable I1 y) -> x;
     56 		BinaryOperator<I1> leftConst09 = (@Taggable @Taggable I1
     57 					x, @Taggable @Taggable I1 y) -> x;
     58 		BinaryOperator<I1> leftConst10 = (final I1 x,
     59 					final I1 y) -> x;
     60 		BinaryOperator<I1> leftConst11 = (@Taggable final
     61 					I1 x, @Taggable final I1 y) -> x;
     62 		BinaryOperator<I1> leftConst12 = (@Taggable
     63 					@Taggable final I1 x,
     64 					@Taggable
     65 					@Taggable final I1 y) -> x;
     66 
     67 		Runnable noOp = () -> {};
     68 		BinaryOperator<I1> leftConst = (x, y) -> x;
     69 		I<I1> id1 = (x) -> (x);
     70 		@SuppressWarnings("unchecked") I<I1> id2 =
     71 				((I<I<I1>>) (I<?>) (Function<I1,
     72 					I1> x) -> x).apply(switch (0) {
     73 				case ((int) (byte) 1) -> (I1 x) -> x;
     74 				default -> (@Taggable I1 x) -> x; });
     75 		C<C1, C2> const1 = (x) -> (y) -> (x);
     76 		C<C1, C2> const2 = switch(switch ("") {
     77 						case "->"->"(s)->(s)";
     78 						default->"default"; }) {
     79 			case ("->")->(var x)->(var y)->(x);
     80 			default->(@Taggable var x)->(@Taggable var y)
     81 				->(x);
     82 		};
     83 	}
     84 
     85 	@java.lang.annotation.Target(ElementType.PARAMETER)
     86 	@java.lang.annotation.Repeatable(Taggables.class)
     87 	@interface Taggable { String[] value() default ""; }
     88 
     89 	@java.lang.annotation.Target(ElementType.PARAMETER)
     90 	@interface Taggables { Taggable[] value(); }
     91 
     92 	interface I<A1> extends Function<A1, A1> { }
     93 	interface C<A1, A2> extends Function<A1, Function<A2, A1>> { }
     94 	interface T<A1, A2, A3> extends
     95 				Function<Function<A1, Function<A2, A3>>,
     96 					Function<A2,
     97 					Function<A1, A3>>> { }
     98 	interface Z<A1, A2, A3> extends Function<Function<A2, A3>,
     99 					Function<Function<A1, A2>,
    100 					Function<A1, A3>>> { }
    101 	interface S<A1, A2, A3> extends
    102 				Function<Function<A1, Function<A2, A3>>,
    103 					Function<Function<A1, A2>,
    104 					Function<A1, A3>>> { }
    105 
    106 	static void echo(Object o) { System.out.println(o); }
    107 
    108 	static {
    109 		enum Letters { OTHER, ALPHA, BETA }
    110 
    111 		Letters other = Letters.OTHER;
    112 
    113 		switch (other) {
    114 		case Letters alpha when Letters.ALPHA == alpha:
    115 						{ echo(alpha); break; }
    116 		case Letters beta when Letters.BETA == beta:
    117 						{ echo(beta); break; }
    118 		default:			{ echo(other); }
    119 		}
    120 
    121 		echo(switch (other) {
    122 			case Letters alpha when Letters.ALPHA == alpha
    123 						-> alpha;
    124 			case Letters beta when Letters.BETA == beta
    125 						-> beta;
    126 			default			-> other;
    127 		});
    128 
    129 		switch (null) {
    130 		case String str when !"<empty>".equals(switch (str) {
    131 			case String str_ when
    132 					Predicate.<String>not(text ->
    133 							!text.isEmpty())
    134 						.test(str_)
    135 							-> "<empty>";
    136 			case String str_		-> str_;
    137 			}):			{ echo(str); break; }
    138 		case null: default:		{ echo("Other"); }
    139 		}
    140 
    141 		echo(switch (null) {
    142 			case String str when !"<empty>".equals(
    143 							switch (str) {
    144 				case String str_ when
    145 					Predicate.<String>not(text ->
    146 							!text.isEmpty())
    147 						.test(str_)
    148 							-> "<empty>";
    149 				case String str_	-> str_;
    150 				})		-> str;
    151 			case null, default	-> "Other";
    152 		});
    153 	}
    154 }