DEV Community: Roshan kumar

Learn a little bit about of ʎ function in C++ 💎

Roshan kumar — Sun, 20 Sep 2020 15:28:51 +0000

in c++ lambda function is quite popular. And it makes code more readable with tons of functionality. So let's start learning about it 👀.

When we talking about the syntax of lambda function in c++ it quite different.

We don't follow complex code on the learning path, we always try to make things simpler.

[ captures ] ( params ) -> return_type { body_statements }

First, we try to understand about captures. When we need variables that defined in outside of function then we use captures to making a clone of a variable.

[ ] { }      // no captures
[=] { }      // everything by copy(not recommended)
[&] { }      // everything by reference(not recommended)
[x] { }      // x by copy
[&x] { }     // x by reference
[&, x] { }   // x by copy, everything else by reference
[=, &x] { }  // x by reference, everything else by copy

If we capture by copy that's make the clone of the variable only, they don't affect actual variables. But when we capture by reference we able to change the value of the variable inside that function.

Try to understand lambda function with Hello World program.

auto say_hello = [] {
    cout << "Hello World!";
};

use a variable that defines outside the function.

// init varible with value
int a = 10;
// lambda function
auto print_a = [a] ( ) {
    cout << a;
};
print_a(); \\ output is 10

change the value of a variable that defines outside the function.

// init varible with value
int a = 10;
// lambda function
auto print_a = [a] ( ) {
     a = 12;
     cout << a;
};
print_a(); \\ output is 12

Now I think the concept of captures is pretty clear.

Now we move forward to params, params are nothing but the only short name of parameters. I think you all familiar with this concept 🥱. but still, I want to give a short example of parameters in lambda function.

auto sum = [](int a, int b) {
        return a + b;
}
cout << sum(10,4); // Output is 14

Now last is return_type, After c++ 20 return type is optional. We don't need to specify the return type of lambda function.

But still we may specify return type with using -> sign.

auto sum = [](int a, int b) -> int {
        return a + b;
};

🎉✨✨🎉🎊🎊🎉🎉✨✨🎉🎊🎊🎉
Congratulation you learn c++ lambda function in few minutes with dvlpr_roshan ( Roshan Kumar ).

Still, who wants to learn lambda function a little bit more with advance features.

actually real syntax of the lambda function in c++ is: [ captures ] <tparams> ( params ) specifiers exception attr -> return_type {body_statements}

Following links can helpful for learning more about the concept of the lambda function in c++.

A program of calc sum ➕ with new and smart code in JavaScript 🔥.

Roshan kumar — Sun, 20 Sep 2020 07:20:18 +0000

Create function in JavaScript that's takes single arguments and return sum of all previous arguments without using global variable.

Here we always try to find short and smart 🏆 code for doing same task.

First we try to do this task with simple approach then move forward.

When we create diagram in mind first we think to take an global variable that store data for you, But that's always a bad idea for smart 😎 developer.


function calc() {
    // creating private valriable
    let value = 0;
    // private function
    function changeBy(val) {
        value += val;
    }
    // returning an object
    return {
        // add method 
        add: function (i) {
            changeBy(i);
        },
        // return value
        value: function () {
            return value;
        }
    }
}

// making mycalc function with calc
let mycalc = calc()

// adding number.
mycalc.add(12)
mycalc.add(15)

// print to console
console.log(mycalc.value())

// output is 27

Here we seem like we have long code, and also we don't have es-6 smart features, so let's begin 🎉.



let calc = () => {
    // creating private valriable
    let value = 0;
    // private function
    let changeBy = val => value += val;
    // returning an object
    return {
        // add method 
        add: (i) => changeBy(i),
        // return value
        value: () => value
    }
}

// making mycalc function with calc
let mycalc = calc()

// adding number.
mycalc.add(12)
mycalc.add(15)

// print to console
console.log(mycalc.value())

// still output is 27 but with smart code.

Now if see code, that's pretty short.

let calc = () => {
    let value = 0;
    let changeVal = val => (value += val);
    return {
        add: (i) => changeVal(i)
    }
}

But a thing is noticeable why we use private function 😋 let's remove it.

let calc = () => {
    let value = 0;
    return {
        add: i => value += i
    }
}

We removed many lined of code to making simpler, but still we have an issue with that code. We need a function that's take arguments every time and return sum of all previous and current arguments. But when use our function we feel like we using any class methods and it's properties, let's solve this issue.

To solving this issue we need to wrap calc function in () parenthesis, and change the name of function calc to sum and call that's function in sum function 😝.

And replace object with function in return statement.

let sum = (
    i => {
        let v = i;
        return i => v += i
    }
)(0);

Here we change many things like we don't return a object return value only, Zero is starting value of sum function.

Now our task is Completed

let sum = (i => { let v = i; return i => v += i })(0);

console.log(sum(14)) /* output --> 14 */
console.log(sum(13)) /* output --> 27 */
console.log(sum(10)) /* output --> 37 */

final result

let sum = (a => b => a += b )(0)

😁😁😁🎉