jupyter/chapter08-lambda.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["if you have not read the previous chapter on interfaces, starts by it first\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# Lambda and Method reference \n", "Java unlike JavaScript or Python, don't let you pass a method as argument of a method\n", "without ceremony\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Let say i want to write a method that do either the sum of an array of values or the sum of their square,\n", "it can write if that way\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["int sumOf(boolean squareSum, int... array) {\n", "  var sum = 0;\n", "  for(var value: array) {\n", "    if (squareSum) {\n", "      sum = sum + value * value;\n", "    } else {\n", "      sum = sum + value;\n", "    }\n", "  }\n", "  return sum;\n", "}\n", "System.out.println(sumOf(true, 1, 2, 3));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["but you every values of the array, squareSum will have the same value so it's equivalent to write\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["int sumOf(boolean squareSum, int... array) {\n", "  var sum = 0;\n", "  if (squareSum) {\n", "    for(var value: array) {\n", "      sum = sum + value * value;\n", "    }\n", "  } else {\n", "    for(var value: array) {\n", "      sum = sum + value;\n", "    }\n", "  }\n", "  return sum;\n", "}\n", "System.out.println(sumOf(true, 1, 2, 3));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["and at that point, you have code duplication.\n", "Usually testing a condition in the middle of a computation is a code smell.\n", "There is a way to solve that, it's to take the part of the computation that change as parameter\n", "so sumOf instead of a boolean that take a function as parameter more or less like this\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["/*\n", "int sumOf(??? function, int... array) {\n", "  var sum = 0;\n", "  for(var value: array) {\n", "    sum = sum + function(value);\n", "  }\n", "  return sum;\n", "}\n", "*/\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Functional interface\n", "the question is what ??? is. The answer in simple in Java, if it can be either a value or another one,\n", "then it's an interface. Exactly like in the previous chapter, we have introduce an interface in\n", "between two records.\n", "Here my interface is a function that takes an int and return an int so\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["interface Fun {\n", "  int apply(int value);\n", "}\n", "int sumOf(Fun function, int[] array) {\n", "  var sum = 0;\n", "  for(var value: array) {\n", "    sum = sum + function.apply(value);\n", "  }\n", "  return sum;\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["then using the lambda syntax we have seeing in the previous chapter sumOf can be called\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var array = new int[] { 1, 2, 3 };\n", "System.out.println(sumOf(x -> x, array));\n", "System.out.println(sumOf(x -> x * x, array));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Package java.util.function\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Because it's not convenient to have to declare an interface every times you want to send\n", "a function as parameter, Java already provides a bunch of interfaces in the package\n", "java.lang.function, so you often don't have to write your own\n", "Moreover most interface also have variant for primitive types \n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["import java.util.function.*;\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["java.lang.Runnable is equivalent to () -> void\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Runnable runnable = () -> { System.out.println(\"hello\"); };\n", "runnable.run();\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Supplier<T> is equivalent to () -> T\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Supplier<String> supplier = () -> \"hello supplier\";\n", "System.out.println(supplier.get());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["IntSupplier, LongSupplier and DoubleSupplier\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["IntSupplier supplier = () -> 42;\n", "System.out.println(supplier.getAsInt());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Consumer<T> is equivalent to (T) -> void\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Consumer<String> consumer = message -> System.out.println(message);\n", "consumer.accept(\"hello consumer\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["IntConsumer, LongConsumer and DoubleConsumer\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["DoubleConsumer consumer = message -> System.out.println(message);\n", "consumer.accept(42);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Predicate<T> is equivalent to (T) -> boolean\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Predicate<String> predicate = text -> text.length() < 5;\n", "System.out.println(predicate.test(\"hello predicate\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["IntPredicate, LongPredicate and DoublePredicate\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["DoublePredicate isPositive = v -> v >= 0;\n", "System.out.println(isPositive.test(17.3));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Function<T,U> is equivalent to (T) -> U\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Function<String, String> fun = s -> \"hello \" + s;\n", "System.out.println(fun.apply(\"function\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["IntFunction<T>, LongFunction<T> and DoubleFunction<T>\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["IntFunction<String[]> arrayCreator = size -> new String[size];\n", "System.out.println(arrayCreator.apply(5).length);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["ToIntFunction<T>, ToLongFunction<T> and ToDoubleFunction<T>\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["ToIntFunction<String> stringLength = s -> s.length();\n", "System.out.println(stringLength.applyAsInt(\"hello\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["UnaryOperator<T> is equivalent to (T) -> T\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["UnaryOperator<String> unaryOp =  s -> \"hello \" + s;\n", "System.out.println(unaryOp.apply(\"unary operator\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["IntUnaryOperator, LongUnaryOperator and DoubleUnaryOperator\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["IntUnaryOperator unaryOp =  x -> - x;\n", "System.out.println(unaryOp.applyAsInt(7));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["BiPredicate is equivalent to (T, U) -> boolean\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["BiPredicate<String, String> predicate = (s, prefix) -> s.startsWith(prefix);\n", "System.out.println(predicate.test(\"hello\", \"hell\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["BiFunction<T,U,V> is equivalent to (T, U) -> V\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["BiFunction<String, String, String> fun = (s1, s2) -> s1 + \" \" + s2;\n", "System.out.println(fun.apply(\"hello\", \"bi-function\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["BinaryOperator<T> is equivalent to (T, T) -> T\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["BinaryOperator<String> binaryOp =  (s1, s2) -> s1 + \" \" + s2;\n", "System.out.println(binaryOp.apply(\"hello\", \"binary operator\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["IntBinaryOperator, LongBinaryOperator and DoubleBinaryOperator\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["IntBinaryOperator binaryOp =  (a, b) -> a + b;\n", "System.out.println(binaryOp.applyAsInt(40, 2));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Lambda\n", "Lambda syntax is similar to arrow part the switch syntax\n", "- with 0 parameter: () -> expression\n", "- with 1 parameter: x -> expression\n", "- with 2 or more parameters: (a, b) -> expression\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["DoubleUnaryOperator op = x -> 2.0 * x;\n", "System.out.println(op.applyAsDouble(2));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["instead of an expression, you can have statements between curly braces\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["DoubleUnaryOperator op = x -> {\n", "    return 2.0 * x;\n", "  };\n", "System.out.println(op.applyAsDouble(2));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The types of the parameters are optional so you can declare them or not\n", "if you don't declare them the parameter types of the abstract method\n", "of the interface are used\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["DoubleUnaryOperator op = (double x) -> 2.0 * x;\n", "System.out.println(op.applyAsDouble(2));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Method references\n", "There are 5 kinds of method references\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["1. a reference to an instance method\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["   Seeing an instance method as a function means you have to\n", "   take the type of `this` into account, here `startsWith` as\n", "   one parameter but the function as two \n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["BiPredicate<String,String> predicate = String::startsWith;\n", "System.out.println(predicate.test(\"hello\", \"hell\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["2. a bound reference to an instance method\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["   The value of this is fixed so the parameter of the function\n", "   are the same as the parameter of the instance method\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var text = \"hello\";\n", "IntSupplier supplier = text::length;\n", "System.out.println(supplier.getAsInt());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["3. a reference to a static method\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["   No instance here, so the parameter of the function are the\n", "   same as the parameter of the static method\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["ToIntFunction<String> function = Integer::parseInt;\n", "System.out.println(function.applyAsInt(\"42\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["4. a reference to a new instance\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["   The parameter of the function are the same as the parameter of\n", "   the constructor. The return type is the class of the constructor\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Person(String name) {}\n", "Function<String, Person> factory = Person::new;\n", "System.out.println(factory.apply(\"John\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["5. a reference to a new array\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["   Same as above, the return type is the array.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["IntFunction<String[]> arrayCreator = String[]::new;\n", "System.out.println(arrayCreator.apply(2).length);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["A frequent error is to think that String::length is a reference\n", "to a static method because the syntax is close to String.length()\n", "which is a call to a static method. But for a method reference,\n", "the same syntax is used to reference an instance method and\n", "a static method. So String::length is a reference to an instance\n", "method because the method length() in the class String is declared\n", "as an instance method.\n"]
}
],
  "metadata": {
    "kernelspec": {
      "display_name": "Java",
      "language": "java",
      "name": "java"
    },
    "language_info": {
      "codemirror_mode": "java",
      "file_extension": ".java",
      "mimetype": "text/x-java-source",
      "name": "Java",
      "pygments_lexer": "java",
      "version": "15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}