lambda, functional interface আর method reference — আচরণকে মানের মতো পাঠানো

১ · lambda মানে কী — আচরণকে মানের মতো পাঠানো

এ পর্যন্ত method-কে আপনি সবসময় ডেটা দিয়েছেন: একটি সংখ্যা, একটি String, একটি List. কিন্তু অনেক সময় method-কে ডেটার সাথে একটি নিয়ম বা কাজ-ও দিতে হয়। একটি অনলাইন দোকানের পণ্যের তালিকা ভাবুন। কেউ চান ৫০০ টাকার নিচের পণ্য, কেউ চান যা স্টকে আছে, কেউ চান নামে “Bag” আছে এমন পণ্য। প্রতিটির জন্য আলাদা method লিখলে দেখবেন, সব method প্রায় একই — একটি loop, একটি if, একটি নতুন list. পার্থক্য শুধু if-এর ভেতরের শর্তে।

static List<Product> cheap(List<Product> all) {
    List<Product> out = new ArrayList<>();
    for (Product p : all) if (p.price() < 500) out.add(p);    // শুধু এখানে পার্থক্য
    return out;
}
static List<Product> available(List<Product> all) {
    List<Product> out = new ArrayList<>();
    for (Product p : all) if (p.inStock()) out.add(p);       // আর এখানে
    return out;
}

সমাধান: একটিই method লিখুন, আর শর্তটা বাইরে থেকে পাঠান। “এই নিয়মে বাছাই করো” — নিয়মটাই একটি argument. পাঠানোর মতো এই ছোট আচরণের টুকরোকে বলে lambda:

static List<Product> filter(List<Product> all, Predicate<Product> rule) {
    List<Product> out = new ArrayList<>();
    for (Product p : all) if (rule.test(p)) out.add(p);
    return out;
}
// ব্যবহার — নিয়মটা ডাকার জায়গায় লেখা:
filter(items, p -> p.price() < 500);
filter(items, p -> p.inStock());
filter(items, p -> p.name().contains("Bag"));

এখন প্রশ্ন: Java তো একটি টাইপ-কঠোর ভাষা। rule parameter-এর টাইপ কী? Java-তে আলাদা কোনো “function টাইপ” নেই। তার বদলে Java ব্যবহার করে পরিচিত interface — এমন interface যার মধ্যে ঠিক একটিই abstract method. পর্ব ২১-এ এর নাম শুনেছেন: functional interface. ওপরের Predicate<Product> এমনই একটি interface, যার একমাত্র abstract method হলো boolean test(Product p). lambda p -> p.price() < 500 আসলে সেই test method-এর শরীর।

পর্ব ২৭-এ দেখেছেন, Java 8-এর আগে একই কাজ করতে anonymous class লিখতে হতো — পাঁচ লাইনের আনুষ্ঠানিকতা, যার মধ্যে আসল কথা এক লাইন। lambda সেই আনুষ্ঠানিকতা ছেঁটে ফেলেছে। আর পর্ব ৩৩-এ Comparator লিখতে গিয়ে আপনি ইতিমধ্যে lambda দেখেছেন: (a, b) -> Double.compare(b.gpa(), a.gpa()). এই পর্বে সেই ধারণার পুরো ছবি।

২ · lambda-র রূপ আর target type

একটি lambda-র দুই অংশ: বাঁয়ে parameter, ডানে শরীর, মাঝে তীর ->. বাকি সব কিছু প্রসঙ্গ থেকে অনুমান করা হয়। লেখার কয়েকটি রূপ:

শরীর যদি একটি expression হয় (a + b), তার মানটাই ফেরত যায় — return বা { } লাগে না। শরীর যদি { } block হয়, তাহলে সাধারণ method-এর মতো return লিখতে হয়। parameter-এর টাইপ সাধারণত লেখা হয় না, কারণ compiler target type থেকে তা জেনে নেয় (type inference).

এক lambda, অনেক interface

একটি মজার ব্যাপার: lambda-র নিজের কোনো নির্দিষ্ট টাইপ নেই। একই লেখা ভিন্ন জায়গায় ভিন্ন interface-এর object হয়ে যায়:

Supplier<String> s = () -> "hi";             // String get()
Callable<String> c = () -> "hi";             // String call() throws Exception
Function<Integer, Integer> f = x -> x * 2;   // Integer apply(Integer)
UnaryOperator<Integer> u     = x -> x * 2;   // একই লেখা, অন্য interface
IntUnaryOperator i           = x -> x * 2;   // int applyAsInt(int) — boxing নেই

প্রতিটি লাইনে compiler বাঁ পাশের টাইপ দেখে, সেই interface-এর একমাত্র abstract method খোঁজে, আর মিলিয়ে দেখে: parameter-এর সংখ্যা মেলে কি না, শরীরের টাইপ method-এর return টাইপের সাথে মেলে কি না। মিললে বৈধ। তাই target type না থাকলে lambda লেখাই যায় না:

class Main {
    public static void main(String[] args) {
        var twice = x -> x * 2;
    }
}

Main.java:3: error: cannot infer type for local variable twice
        var twice = x -> x * 2;
            ^
  (lambda expression needs an explicit target-type)
1 error

var বলে “ডান পাশ দেখে টাইপ বের করো”, আর lambda বলে “বাঁ পাশ দেখে আমার টাইপ ঠিক করো” — দুজনই অন্যজনের দিকে তাকিয়ে আছে, তাই compiler হাল ছেড়ে দেয়। এবার পুরো প্রক্রিয়াটা ধাপে ধাপে দেখুন — compiler একটি lambda পেলে কী কী করে:

1interface Predicate<T> { boolean test(T t); }2Predicate<Product> isCheap = p -> p.price() < 500;34Product pen = new Product("Pen", 20, true);5boolean ok = isCheap.test(pen);

@FunctionalInterface — compiler-কে পাহারাদার বানানো

নিজের functional interface বানালে তার মাথায় @FunctionalInterface annotation লিখুন। এটা না লিখলেও lambda কাজ করবে — একটি abstract method থাকলেই যথেষ্ট। annotation-টি একটি প্রতিশ্রুতি: “এই interface-এ ঠিক একটি abstract method থাকবে।” পরে কেউ ভুলে আরেকটি abstract method যোগ করলে compiler সেখানেই থামাবে, আর যত জায়গায় এই interface-এর জন্য lambda লেখা আছে সেগুলো ভাঙার আগেই সমস্যা ধরা পড়বে:

@FunctionalInterface
interface Rule {
    boolean check(int price);
    String explain();
}

class Main {
    public static void main(String[] args) { }
}

Main.java:1: error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  Rule is not a functional interface
    multiple non-overriding abstract methods found in interface Rule
1 error

বার্তার শেষ লাইনটি পড়ুন: “multiple non-overriding abstract methods”. “non-overriding” কথাটি গুরুত্বপূর্ণ। Comparator-এ compare ছাড়াও boolean equals(Object) abstract হিসেবে ঘোষিত আছে, তবু সে functional interface — কারণ equals সব object-এর Object class থেকে আসে, তাই সেটা গোনায় ধরা হয় না। explain-কে default method বানালে (শরীর দিলে) error চলে যাবে।

৩ · java.util.function — তৈরি interface-এর পরিবার

প্রতিটি lambda-র জন্য নিজে interface বানাতে হলে বিরক্তিকর হতো। তাই Java 8 java.util.function package-এ চল্লিশটির বেশি সাধারণ-উদ্দেশ্যের functional interface দিয়েছে। মুখস্থ করার দরকার নেই — মূল পরিবারটা বুঝলে বাকিগুলোর নাম দেখেই অর্থ বোঝা যায়। প্রশ্ন দুটি: কী নেয়? আর কী ফেরত দেয়?

সম্পর্কগুলো খেয়াল করুন। UnaryOperator<T> আসলে Function<T,T>-এর বিশেষ রূপ (সে Function-কে extend করে) — যখন ইনপুট আর আউটপুট একই টাইপ। BinaryOperator<T> তেমনি BiFunction<T,T,T>. “Bi” মানে দুটি ইনপুট: BiConsumer, BiPredicate-ও আছে — যেমন Map.forEach নেয় একটি BiConsumer, কারণ প্রতিটি entry-তে key আর value দুটি জিনিস। আর পুরোনো Runnable (কিছু নেয় না, কিছু দেয় না) আর Comparator-ও functional interface, যদিও তারা এই package-এর নয়।

primitive সংস্করণ — boxing-এর খরচ এড়াতে

generics শুধু reference টাইপ নেয় (পর্ব ২৮), তাই Function<int, int> লেখা যায় না — লিখতে হয় Function<Integer, Integer>. এর মানে প্রতিটি ডাকে int-কে Integer object-এ মোড়ানো (autoboxing) আর আবার খোলা। দশটা সংখ্যায় কিছু যায় আসে না, কিন্তু কোটি সংখ্যার loop-এ বাড়তি object তৈরি আর garbage collection সময় খায়। তাই আছে primitive specialization:

নামের ধাঁচ: Int… মানে ইনপুট int, ToInt… মানে আউটপুট int. একই পরিবার Long আর Double-এর জন্যও আছে। সব primitive-এর জন্য নেই (যেমন CharPredicate নেই) — interface-এর সংখ্যা বিস্ফোরিত না করতে Java শুধু সবচেয়ে বেশি ব্যবহৃত তিনটি বেছে নিয়েছে। পর্ব ৩৫-এর IntStream এই interface-গুলোই ব্যবহার করে।

৪ · ছোট নিয়ম জুড়ে বড় নিয়ম — composition

functional interface-গুলোর আসল শক্তি তাদের default method-এ। ছোট ছোট নিয়ম আলাদাভাবে লিখে, পরে সেগুলো জুড়ে নতুন নিয়ম বানানো যায় — কোনো নতুন lambda না লিখেই। একে বলে function composition.

andThen আর compose নিয়ে নতুনরা প্রায়ই গুলিয়ে ফেলেন। ধরুন doubleIt = x -> x * 2 আর plus3 = x -> x + 3. doubleIt.andThen(plus3).apply(5) হলো (৫ × ২) + ৩ = ১৩ — লেখার ক্রমেই চলে। doubleIt.compose(plus3).apply(5) হলো (৫ + ৩) × ২ = ১৬ — গণিতের f(g(x))-এর মতো, ভেতরেরটা আগে। মনে রাখার সহজ উপায়: andThen পড়ুন “এটা, তারপর ওটা”।

পর্ব ৩৩-এর Comparator-ও একই ধারণায় তৈরি: Comparator.comparing(Product::price).thenComparing(Product::name).reversed() — ছোট তুলনা জুড়ে বড় তুলনা। এবার একটি সত্যিকারের প্রশ্ন: একটি ল্যাম্প আছে, দাম ৪৫০ টাকা, স্টকে নেই। নিয়ম “সস্তা এবং স্টকে আছে — এর উল্টো”, অর্থাৎ “এখন কেনার মতো নয়”। isCheap.and(inStock).negate() ল্যাম্পের জন্য কী দেবে? ধাপে ধাপে দেখুন:

1Predicate<Product> isCheap = p -> p.price() < 500;2Predicate<Product> inStock = Product::inStock;3Predicate<Product> skip = isCheap.and(inStock).negate();4Product lamp = new Product("Lamp", 450, false);5skip.test(lamp);6skip.test(new Product("Bag", 950, true));

এবার পুরো একটি ছোট “ছাড়ের নিয়ম ইঞ্জিন” চালিয়ে দেখুন। applyDiscount একটি নিয়ম (Predicate) আর একটি পরিবর্তন (UnaryOperator) নেয় — কোন পণ্যে আর কী ছাড়, দুটিই বাইরে থেকে আসে:

import java.util.*;
import java.util.function.*;

record Product(String name, int price, boolean inStock) { }

class Main {
    static List<Product> applyDiscount(List<Product> list, Predicate<Product> rule, UnaryOperator<Product> change) {
        List<Product> out = new ArrayList<>();
        for (Product p : list) out.add(rule.test(p) ? change.apply(p) : p);
        return out;
    }
    public static void main(String[] args) {
        List<Product> items = List.of(new Product("Pen", 20, true), new Product("Bag", 950, true),
                new Product("Lamp", 450, false), new Product("Mug", 180, true));
        Predicate<Product> isCheap = p -> p.price() < 500;
        Predicate<Product> inStock = Product::inStock;
        Predicate<Product> buyNow = isCheap.and(inStock);
        for (Product p : items) if (buyNow.test(p)) System.out.println("Buy: " + p.name());
        System.out.println("Lamp skip? " + buyNow.negate().test(items.get(2)));
        UnaryOperator<Product> tenOff = p -> new Product(p.name(), p.price() * 90 / 100, p.inStock());
        applyDiscount(items, isCheap.negate(), tenOff).forEach(System.out::println);
    }
}

একই ধাঁচে ইনপুট যাচাই: ছোট ছোট যাচাই আলাদা নামে রাখুন, তারপর জুড়ুন। প্রতিটি নিয়ম আলাদাভাবে পরীক্ষা করা যায়, আর নতুন শর্ত যোগ করা মানে একটি .and(...):

Predicate<String> notBlank = s -> !s.isBlank();
Predicate<String> digitsOnly = s -> s.chars().allMatch(Character::isDigit);
Predicate<String> elevenLong = s -> s.length() == 11;
Predicate<String> validPhone = notBlank.and(digitsOnly).and(elevenLong);

validPhone.test("01712345678");   // true
validPhone.test("0171-234");      // false

৫ · method reference — চার ধরন

অনেক lambda শুধু একটি বিদ্যমান method ডাকে, আর কিছু করে না: s -> Integer.parseInt(s), m -> System.out.println(m). এখানে parameter-এর নাম (s, m) শুধু হাত বদলের জন্য। method reference সেটুকুও বাদ দেয়: Integer::parseInt, System.out::println. :: পড়ুন “এর এই method” হিসেবে। method reference চলে না — এটাও lambda-র মতো একটি functional interface-এর object বানায়, তাই এরও target type লাগে।

চার ধরনের method reference আছে, আর পার্থক্যটা একটাই প্রশ্নে: method-টি কোন object-এর ওপর চলবে, আর সেই object কোথা থেকে আসবে? চারটি ধরন lambda-র পাশে রেখে দেখুন:

Function<String, Integer> parse = Integer::parseInt;
// সমান lambda:
Function<String, Integer> parse = s -> Integer.parseInt(s);
parse.apply("200")   // 200

Consumer<String> print = System.out::println;
// সমান: m -> System.out.println(m)
String phone = "01712345678";
Predicate<String> hasPrefix = phone::startsWith;
// সমান: pre -> phone.startsWith(pre)
hasPrefix.test("017")   // true

Function<String, String> up = String::toUpperCase;
// সমান: s -> s.toUpperCase()
BiFunction<String, String, Boolean> sw = String::startsWith;
// সমান: (s, pre) -> s.startsWith(pre)
up.apply("dhaka")   // DHAKA

Supplier<List<String>> make = ArrayList::new;
// সমান: () -> new ArrayList<>()
Function<Integer, List<String>> sized = ArrayList::new;
// সমান: n -> new ArrayList<>(n)
Function<String, Product> f = Product::new;  // যদি এমন constructor থাকে

method reference কখন lambda-র চেয়ে ভালো? যখন সে আরও পরিষ্কার পড়ায়। names.forEach(System.out::println) বা map(String::trim) নিজেই একটি বাক্যের মতো পড়া যায়। কিন্তু (a, b) -> a.compareToIgnoreCase(b)-এর জায়গায় String::compareToIgnoreCase লিখলে অনেক পাঠককে এক মুহূর্ত থেমে ভাবতে হয় — কে object, কে argument? আর lambda যদি method ডাকার আগে-পরে কিছু করে (s -> Integer.parseInt(s.trim())), method reference চলবে না। নিয়ম একটাই: যেটা পড়তে সহজ, সেটা লিখুন।

৬ · capture, this আর collection-এ lambda

বাইরের ভ্যারিয়েবল ধরা — effectively final

lambda তার চারপাশের local variable পড়তে পারে — যেমন বাজেট একটি ভ্যারিয়েবলে রেখে p -> p.price() <= budget. পর্ব ২৭-এ anonymous class-এর জন্য যে নিয়ম দেখেছেন, lambda-তেও তাই: lambda ভ্যারিয়েবলের মানের কপি রাখে (variable capture), তাই ভ্যারিয়েবলটি effectively final হতে হবে — ঘোষণার পর কখনো নতুন মান বসানো যাবে না। ধাপে ধাপে দেখুন:

1static Predicate<Product> under(int budget) {2    return p -> p.price() <= budget;3}4Predicate<Product> small = under(200);5small.test(new Product("Mug", 180, true));6// যদি লাইন ২-এর আগে লিখতেন: budget += 50;

সবচেয়ে সাধারণ ভুলটি হলো lambda দিয়ে যোগফল জমানোর চেষ্টা:

import java.util.*;

class Main {
    public static void main(String[] args) {
        int total = 0;
        List<Integer> prices = List.of(20, 950, 180);
        prices.forEach(p -> total += p);
        System.out.println(total);
    }
}

Main.java:7: error: local variables referenced from a lambda expression must be final or effectively final
        prices.forEach(p -> total += p);
                            ^
1 error

পর্ব ২৭-এ বার্তাটি ছিল “from an inner class”, এখানে “from a lambda expression” — নিয়ম একই। সমাধান “নিয়ম এড়ানোর কৌশল” নয় (int[] total = {0} লিখে array-র ভেতরের ঘর বদলানো — AI প্রায়ই এটা দেয়)। সমাধান হলো নকশা বদলানো: একটি সাধারণ for-each loop লিখুন, অথবা পর্ব ৩৫-এ দেখবেন prices.stream().mapToInt(Integer::intValue).sum() — যেখানে কিছুই বদলাতে হয় না, ফলটাই ফেরত আসে। নিয়মটির কারণ শুধু কপি নয়: lambda প্রায়ই অন্য thread-এ চলে, আর বদলানো যায় এমন local variable ভাগাভাগি হলে data race তৈরি হতো (প্রশ্ন ৫-এ আরও)।

lambda-তে this

পর্ব ২৭-এর পার্থক্যটি আবার মনে করুন: anonymous class একটি নতুন class, তাই তার ভেতরে this মানে নামহীন object নিজে। lambda নতুন class নয়, নতুন scope-ও নয় — তার ভেতরে this মানে যে object-এর method-এ lambda লেখা হয়েছে। ফলে একটি instance method-এর ভেতরে items.forEach(p -> this.total += p.price()) বৈধ: total একটি field, local variable নয়, আর lambda আসলে this-কে ধরে, যা নিজে বদলায় না। তবে এটাও বাইরের অবস্থা বদলানো — একাধিক thread-এ নিরাপদ নয়। একই কারণে lambda-র parameter বা ভেতরের ভ্যারিয়েবলের নাম বাইরের কোনো local variable-এর নামে রাখা যায় না; একই scope, তাই compiler আপত্তি করে।

collection-এ lambda — Java 8-এর নতুন method

lambda আসার সাথে Java 8 collection interface-গুলোতে default method যোগ করেছে, যেগুলো সরাসরি lambda নেয়। পর্ব ৩০-৩১-এর List আর Map এখন আরও সংক্ষেপে কাজ করে:

দুটি সতর্কতা। প্রথমত, removeIf আর replaceAll collection-টিকে বদলায়, তাই List.of(...)-এর মতো অপরিবর্তনীয় list-এ UnsupportedOperationException দেবে — আগে new ArrayList<>(...)-এ কপি করুন। দ্বিতীয়ত, পর্ব ১১-এ দেখেছেন for-each loop চলার সময় list থেকে মুছলে ConcurrentModificationException হয়; removeIf সেই কাজটাই নিরাপদে করে। আর computeIfAbsent হলো পর্ব ৩১-এর “key না থাকলে খালি list বসাও, তারপর যোগ করো” ধাঁচের এক লাইনের রূপ — পরের অংশের প্রোগ্রামে দেখবেন।

৭ · নিজের higher-order method আর checked exception-এর ঝামেলা

যে method আরেকটি আচরণ (function) parameter হিসেবে নেয় বা ফেরত দেয়, তাকে বলে higher-order function. filter, applyDiscount, under — সবই আপনি এর মধ্যে লিখেছেন। এই কৌশলের সবচেয়ে বড় লাভ: “কখন আর কীভাবে চালাতে হবে” — এই কাঠামো একবার লেখা, আর “কী চালাতে হবে” প্রতিবার আলাদা। নিচের প্রোগ্রামে দুটি বাস্তব উদাহরণ: নেটওয়ার্ক ব্যর্থ হলে আবার চেষ্টা করার retry, আর একটি ছোট নোটিফিকেশন dispatcher, যেখানে প্রতিটি ঘটনার জন্য কয়েকজন শ্রোতা (Consumer) নিবন্ধিত:

import java.util.*;
import java.util.function.*;
class Main {
    static <T> T retry(Supplier<T> task, int times) {
        RuntimeException last = new IllegalArgumentException("times must be > 0");
        for (int i = 1; i <= times; i++)
            try { return task.get(); }
            catch (RuntimeException e) { last = e; System.out.println("try " + i + ": " + e.getMessage()); }
        throw last;
    }
    public static void main(String[] args) {
        Iterator<String> net = List.of("timeout", "timeout", "200 OK").iterator();
        String reply = retry(() -> {
            String r = net.next();
            if (r.equals("timeout")) throw new IllegalStateException(r);
            return r;
        }, 3);
        System.out.println("got " + reply);
        Map<String, List<Consumer<String>>> subs = new TreeMap<>();
        subs.computeIfAbsent("order", k -> new ArrayList<>()).add(m -> System.out.println("SMS: " + m));
        subs.computeIfAbsent("order", k -> new ArrayList<>()).add(m -> System.out.println("Email: " + m));
        subs.computeIfAbsent("payment", k -> new ArrayList<>()).add(System.out::println);
        subs.forEach((topic, list) -> list.forEach(c -> c.accept(topic + " event")));
    }
}

checked exception — lambda-র সবচেয়ে বড় কাঁটা

ধরুন কয়েকটি ফাইলের লেখা ছাপতে চান। Files.readString (পর্ব ৩৭) একটি checked exception — IOException — ছুঁড়তে পারে। main-এ throws IOException লিখে দিলেও:

import java.io.IOException;
import java.nio.file.*;
import java.util.*;

class Main {
    public static void main(String[] args) throws IOException {
        List<Path> files = List.of(Path.of("a.txt"), Path.of("b.txt"));
        files.forEach(p -> System.out.println(Files.readString(p)));
    }
}

Main.java:8: error: unreported exception IOException; must be caught or declared to be thrown
        files.forEach(p -> System.out.println(Files.readString(p)));
                                                              ^
1 error

কেন? lambda-র শরীর আসলে Consumer.accept-এর শরীর, main-এর নয়। আর accept-এর ঘোষণায় কোনো throws নেই। main-এর throws এখানে কাজে আসে না, কারণ lambda কখন চলবে তা main জানে না — forEach চালাবে, হয়তো পরে, হয়তো অন্য thread-এ। তিনটি সমাধান, পছন্দের ক্রমে:

• সাধারণ loop লিখুন। for (Path p : files) System.out.println(Files.readString(p)); — এখানে main-এর throws কাজ করে। checked exception থাকলে প্রায়ই এটাই সবচেয়ে পরিষ্কার।
• lambda-র ভেতরে ধরে unchecked-এ মুড়ে দিন। JDK এই কাজের জন্যই UncheckedIOException দিয়েছে; মূল exception-টি cause হিসেবে থেকে যায়, তাই কারণ হারায় না:

files.forEach(p -> {
    try { System.out.println(Files.readString(p)); }
    catch (IOException e) { throw new UncheckedIOException(e); }   // কারণ সাথে থাকে
});

• বারবার লাগলে একটি সহকারী বানান। নিজের functional interface, যার method throws IOException, আর একটি method যা তাকে সাধারণ Function-এ মুড়ে দেয়:

@FunctionalInterface
interface IOFunction<T, R> { R apply(T t) throws IOException; }

static <T, R> Function<T, R> unchecked(IOFunction<T, R> f) {
    return t -> {
        try { return f.apply(t); }
        catch (IOException e) { throw new UncheckedIOException(e); }
    };
}
// ব্যবহার: files.stream().map(unchecked(Files::readString)).forEach(System.out::println);

৮ · পর্দার আড়ালে, আর কখন lambda না লিখবেন

পর্ব ২৭-এ দেখেছেন, প্রতিটি anonymous class compile হয়ে আলাদা Main$1.class ফাইল হয়। lambda হয় না। javac lambda-র শরীরকে বাইরের class-এর ভেতরেই একটি private synthetic method বানায় (নাম অনেকটা lambda$main$0), আর lambda যেখানে লেখা সেখানে বসায় একটি invokedynamic নির্দেশ। সেই নির্দেশ প্রথমবার চলার সময় JVM একটি bootstrap method ডাকে — LambdaMetafactory — যে চলার সময়েই functional interface-এর একটি implementation তৈরি করে, যার method ওই private method-কে ডাকে। ফলটি সেই জায়গার সাথে বাঁধা থাকে, তাই পরের বার এই খরচ আর লাগে না।

শেষ সারিটি বাস্তবে গুরুত্বপূর্ণ: lambda-র ভেতরে exception হলে stack trace-এ lambda$main$0 আর JDK-র ভেতরের কয়েকটি লাইন দেখবেন — কোন lambda, সেটা বুঝতে লাইন নম্বরের ওপর ভরসা করতে হয়। পাঁচটি lambda এক লাইনে জুড়লে debug করা কঠিন হয়ে পড়ে। আর lambda-র object-এর identity-র ওপর নির্ভর করবেন না (== দিয়ে দুটি lambda তুলনা, বা তাকে map-এর key বানানো) — JVM সেটা পুনর্ব্যবহার করবে কি না, তা নির্দিষ্টভাবে প্রতিশ্রুত নয়।

কখন lambda নয়

lambda একটি সরঞ্জাম, লক্ষ্য নয়। নিচের পরিস্থিতিতে সাধারণ loop বা নাম দেওয়া method সাধারণত পরিষ্কার:

৯ · AI-এর যুগে — লম্বা lambda আর লুকানো exception ধরুন

AI lambda লিখতে খুব ভালোবাসে। “একটি ফাইল পড়ে লাইনগুলো যাচাই করো” বললে প্রায়ই পাবেন একটি forEach-এর ভেতরে পনেরো লাইনের lambda, তার ভেতরে আরেকটি forEach, আর মাঝে একটি catch (Exception e) { }. কোড compile হয়, ছোট টেস্টে চলেও। কিন্তু ভুল ফাইলে প্রোগ্রাম নীরবে খালি ফল দেয়, আর তিন মাস পরে কেউ বুঝতে পারে না কোন lambda কী করছে। এমন ধাঁচগুলো চিনে রাখুন:

AI-এর কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি lambda এক নজরে পড়া যায় (মোটামুটি তিন লাইনের মধ্যে)
• নেস্ট করা lambda নেই, বা প্রতিটি স্তরের নাম আছে
• কোনো lambda-তে ফাঁকা catch বা শুধু printStackTrace() নেই
• সংখ্যার loop-এ boxed Function<Integer,…>-এর বদলে primitive interface
• নিজের বানানো functional interface-এর সত্যিকারের কারণ আছে, আর তাতে @FunctionalInterface
• removeIf/replaceAll অপরিবর্তনীয় List.of-এর ওপর ডাকা হয়নি
• অন্তত একটি অংশ আমি নিজে সাধারণ loop-এ লিখে মিলিয়ে দেখেছি — ফল একই