File: Lambda.java

package info (click to toggle)
checker-framework-java 3.2.0%2Bds-1
  • links: PTS, VCS
  • area: main
  • in suites: bookworm
  • size: 22,840 kB
  • sloc: java: 145,910; xml: 839; sh: 518; makefile: 401; perl: 26
file content (96 lines) | stat: -rw-r--r-- 2,610 bytes parent folder | download | duplicates (3)
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
// see also the test for Issue450
// Test file for lambda syntax

interface Supplier<R> {
    R supply();
}

interface Function<T, R> {
    R apply(T t);
}

interface Consumer<T> {
    void consume(T t);
}

interface BiFunction<T, U, R> {
    R apply(T t, U u);
}

interface Noop {
    void noop();
}

class Lambda {

    public static void consumeStr(String str) {}

    Lambda(Consumer<String> consumer) {
        consumer.consume("hello");
    }

    // No parameters; result is void
    Noop f1 = () -> {};
    // No parameters, expression body
    Supplier<Integer> f2 = () -> 42;
    // No parameters, expression body
    //    Supplier<Void> f3 = () -> null;
    // No parameters, block body with return
    Supplier<Integer> f4 =
            () -> {
                return 42;
            };
    Noop f5 =
            () -> {
                System.gc();
            }; // No parameters, void block body

    // Complex block body with returns
    Supplier<Integer> f6 =
            () -> {
                if (true) {
                    return 12;
                } else {
                    int result = 15;
                    for (int i = 1; i < 10; i++) {
                        result *= i;
                    }
                    // conditional expression
                    Consumer<String> consumer =
                            result > 100 ? Lambda::consumeStr : Lambda::consumeStr;
                    return result;
                }
            };

    // Single declared-type parameter
    Function<Integer, Integer> f7 = (Integer x) -> x + 1;
    // Single declared-type parameter
    Function<Integer, Integer> f9 =
            (Integer x) -> {
                return (Integer) x + 1;
            };
    // Single inferred-type parameter
    Function<Integer, Integer> f10 = (x) -> x + 1;
    // Parentheses optional for single inferred-type parameter
    Function<Integer, Integer> f11 = x -> x + 1;

    // Single declared-type parameter
    Function<String, Integer> f12 = (String s) -> s.length();
    // Single declared-type parameter
    Consumer<Thread> f13 =
            (Thread t) -> {
                t.start();
            };
    // Single inferred-type parameter
    Consumer<String> f14 = s -> s.length();
    // Single inferred-type parameter
    Consumer<Thread> f15 =
            t -> {
                t.start();
            };

    // Multiple declared-type parameters
    BiFunction<Integer, Integer, Integer> f16 = (Integer x, final Integer y) -> x + y;
    // Multiple inferred-type parameters
    BiFunction<String, String, String> f18 = (x, y) -> x + y;
}