Update Lambda Functions Topic

Author: LeonnardoVerol

docs/programming-languages/lambda-functions/_c.mdx

@@ -1,3 +1,12 @@
 ```C
-// TODO
+// No Native Support.
+// Use named functions and function pointers.
+
+int add(int first, int second)
+{
+	return first + second;
+}
+
+int (*operation)(int, int) = add;
+int result = operation(10, 20);
 ```

docs/programming-languages/lambda-functions/_cpp.mdx

@@ -1,3 +1,30 @@
 ```Cpp
-// TODO
+// Since C++11
+
+// ------------------------------------
+// Definition
+// ------------------------------------
+auto functionName = []([parameters]) {
+	// ...
+};
+
+// ------------------------------------
+// Declaration Example
+// ------------------------------------
+auto add = [](int first, int second) {
+	return first + second;
+};
+
+int result = add(10, 20);
+
+// Capture by value
+int factor {2};
+auto multiply = [factor](int value) {
+	return value * factor;
+};
+
+// Capture by reference
+auto increment = [&factor]() {
+	factor++;
+};
 ```

docs/programming-languages/lambda-functions/_csharp.mdx

@@ -1,3 +1,21 @@
 ```Cs
-// TODO
+// ------------------------------------
+// Definition
+// ------------------------------------
+Func<int, int, int> functionName = ([parameters]) => {
+	// ...
+};
+
+// ------------------------------------
+// Declaration Example
+// ------------------------------------
+Func<int, int, int> add = (first, second) => first + second;
+Func<int, int, int> addBlock = (first, second) =>
+{
+	return first + second;
+};
+
+Action<string> print = message => Console.WriteLine(message);
+
+int result = add(10, 20);
 ```

docs/programming-languages/lambda-functions/_go.mdx

@@ -1,3 +1,25 @@
 ```Go
-// TODO
+// Go has function literals.
+
+// ------------------------------------
+// Definition
+// ------------------------------------
+functionName := func([parameters]) [returnType] {
+	// ...
+}
+
+// ------------------------------------
+// Declaration Example
+// ------------------------------------
+add := func(first int, second int) int {
+	return first + second
+}
+
+result := add(10, 20)
+
+// Function literals can capture values from their environment.
+factor := 2
+multiply := func(value int) int {
+	return value * factor
+}
 ```

docs/programming-languages/lambda-functions/_java.mdx

@@ -1,3 +1,22 @@
 ```Java
-// TODO
+// Since Java 8
+
+// ------------------------------------
+// Definition
+// ------------------------------------
+([parameters]) -> {
+	// ...
+}
+
+// ------------------------------------
+// Declaration Example
+// ------------------------------------
+BinaryOperator<Integer> add = (first, second) -> first + second;
+Consumer<String> print = message -> System.out.println(message);
+Supplier<Integer> getNumber = () -> 10;
+
+int result = add.apply(10, 20);
+
+List<String> names = List.of("Ada", "Grace");
+names.forEach(name -> System.out.println(name));
 ```

docs/programming-languages/lambda-functions/_javascript.mdx

@@ -25,21 +25,35 @@ const functionName = () => { /*...*/ } // no parameter
 // Named Parameters (Keyword Arguments)
 // ------------------------------------
 
-// TODO
+// No Native Support.
+// Use object destructuring.
+const printUser = ({ name, age }) => {
+	console.log(`${name}: ${age}`);
+}
+
+printUser({ name: "Ada", age: 36 });
 
 
 // ------------------------------------
 // Optional Parameters
 // ------------------------------------
 
-// TODO
+// No Native Support as syntax.
+// Check for undefined or use a default value.
+const printUser = (name, age) => {
+	if (age === undefined) {
+		// ...
+	}
+}
 
 
 // ------------------------------------
 // Default Argument for Parameters
 // ------------------------------------
 
-// TODO
+const connect = (host, port = 443) => {
+	// ...
+}
 
 
 // ------------------------------------

docs/programming-languages/lambda-functions/_python.mdx

@@ -1,3 +1,19 @@
 ```Python
-# TODO
+# ------------------------------------
+# Definition
+# ------------------------------------
+function_name = lambda [parameters]: expression
+
+# ------------------------------------
+# Declaration Example
+# ------------------------------------
+add = lambda first, second: first + second
+result = add(10, 20)
+
+numbers = [1, 2, 3]
+doubled = list(map(lambda value: value * 2, numbers))
+
+# Prefer def for complex logic.
+def add(first, second):
+	return first + second
 ```

docs/programming-languages/lambda-functions/_rust.mdx

@@ -1,3 +1,24 @@
 ```Rust
-// TODO
+// Also Known as Closures
+
+// ------------------------------------
+// Definition
+// ------------------------------------
+let function_name = |[parameters]| {
+	// ...
+};
+
+// ------------------------------------
+// Declaration Example
+// ------------------------------------
+let add = |first: i32, second: i32| first + second;
+let add_block = |first: i32, second: i32| {
+	return first + second;
+};
+
+let result = add(10, 20);
+
+// Closures can capture values from their environment.
+let factor = 2;
+let multiply = |value: i32| value * factor;
 ```

docs/programming-languages/lambda-functions/_typescript.mdx

@@ -1,3 +1,24 @@
 ```Typescript
-// TODO
+// Also Known as Arrow Functions
+
+// ------------------------------------
+// Definition
+// ------------------------------------
+const functionName = ([parameters]): returnType => {
+	// ...
+};
+
+// ------------------------------------
+// Declaration Example
+// ------------------------------------
+const add = (first: number, second: number): number => first + second;
+
+const addBlock = (first: number, second: number): number => {
+	return first + second;
+};
+
+const print = (message: string): void => console.log(message);
+const getNumber = (): number => 10;
+
+const result = add(10, 20);
 ```