Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


Alternate Expressions

Time to put on our detective caps: using deductive reasoning, we can make our lambda expression even shorter. Here's what we have to start:

```cs
bool hasEvenNumbers = Array.Exists(numbers, (int num) => num % 2 == 0 );
```

The type of `num` is `int`. It's great to be explicit like this to avoid errors, but some developers wouldn't include `int`. To them, it's obvious! Here's their reasoning:
* The modulo operator (`%`) is only used with numbers, so `num` must be a number
* The result of the operation `num % 2` is compared to the integer `0`. We can only compare similar types, so num must also be an integer!
 
Therefore, we can remove `int` without causing any errors:

```cs
bool hasEvenNumbers = Array.Exists(numbers, (num) => num % 2 == 0 );
```
 
When there is just one parameter in a lambda expression, we don't need the parentheses around the parameter either:

```cs
bool hasEvenNumbers = Array.Exists(numbers, num => num % 2 == 0 );
```
 
We just learned two new shortcuts "within" the lambda expression shortcut. Though we don't need to use them all the time, we do need to recognize them in other developers' code:
1. We can remove the parameter type if it can be inferred
2. We can remove the parentheses if there is one parameter


Shorter Lambda Expressions

The next shortcut, _lambda expressions_, are great for situations when you need to pass a method as an argument.

In the past exercise, we used `IsEven()` to check that an even value exists in the array `numbers`:

```cs
int[] numbers = {1, 3, 5, 6, 7, 8};

public static bool IsEven(int num)
{
  return num % 2 == 0;
}

bool hasEvenNumber = Array.Exists(numbers, IsEven);
```

When using the original definition (with curly braces and `return`), it takes multiple lines to define the `IsEven()` method and other developers will need to jump around our code to find the definition. With a lambda expression, we can define `IsEven()` directly in the method call. We don't even need to give it a name:

```cs
bool hasEvenNumber = Array.Exists(numbers, (int num) => num % 2 == 0 );
```

This might look similar to an expression-bodied definition. It sort of is! What makes a lambda expression unique is that it is an _anonymous method:_ it has no name. 

Generally lambda expressions with one expression (like the above example) take this form. They use the fat arrow, no curly braces, and no semicolon (`;`):

```
(input-parameters) => expression
```

Lambda expressions with more than one expression use curly braces and semicolon:

```
(input-parameters) => { statement; }
```

Here's an example of the second structure, which checks if any element in `numbers` is a multiple of 12 and greater than 20:
```cs
bool hasBigDozen = Array.Exists(numbers, (int num) => {
  bool isDozenMultiple = num % 12 == 0;
  bool greaterThan20 = num > 20;
  return isDozenMultiple && greaterThan20;
});
```

Since this lambda expression includes multiple expressions (3 in this case), then we must use curly braces and semicolons.


Lambda Expressions

Before we get into the next shortcut, we need to understand how methods are passed to other methods as arguments. This is possible and sometimes necessary in C#. 

For example, say we need to check if there are even values in an array (you don't need to know much about arrays here, except that they are lists of values).

First you need an array of values and the `IsEven()` method that returns `true` if its argument is even:

```cs
int[] numbers = {1, 3, 5, 6, 7, 8};

public static bool IsEven(int num)
{
  return num % 2 == 0;
}
```

Pass both of these as arguments to the method `Array.Exists()`, which returns a boolean value:

```cs
bool hasEvenNumber = Array.Exists(numbers, IsEven);
```

You can see that `IsEven`, a method, is passed as the second argument to `Array.Exists()`.

In the background, this is what `Array.Exists()` does: 
* The `IsEven()` method is called with each value in the array. We can imagine each of these being called:
```cs
IsEven(1);
IsEven(3);
IsEven(5);
IsEven(6);
```
* If any of these return `true`, `Array.Exists()` returns `true`. 

By the end, `Array.Exists()` returns `true` because `isEven(6)` returns `true`. 

There are other methods that accept methods as arguments, which you will encounter later on. For now, you need to understand that we can use a method's name like a variable, e.g. `IsEven` is a variable representing the method `IsEven()`. We pass this variable to another method, like `Array.Exists()`, which will probably invoke that method-argument at least once within its own body.

Methods as Arguments

_Expression-bodied definitions_ are the first "shortcut" for writing methods. They're great for writing one-line methods, like this one:

```cs
bool IsEven(int num)
{
  return num % 2 == 0;
}
```

We can rewrite this definition as an expression-bodied definition by:
* removing the curly braces and `return` keyword, and 
* adding the "fat arrow", or `=>`, which is composed of the equal sign, `=`, and greater than, `>`, symbols

```cs
bool isEven(int num) => num % 2 == 0;
```

This also works for methods that return nothing, aka `void`:

```cs
void Shout(string x) => Console.WriteLine(x.ToUpper());
```

This type of definition can only be used when a method contains one expression. This helps us remember the name: _expression_-bodied definitions are method definitions with one _expression_.

Fun fact: some developers also call the fat arrow notation, `=>`, a squid! 🦑


Expression-bodied Definitions

Well done! We learned two shortcuts for defining methods:

_Expression-bodied definitions_ can be used for one-line method bodies.
```cs
bool isEven(int num) => num % 2 == 0;
```

_Lambda expressions_ can be used to create an anonymous method:
```cs
bool hasEvenNumbers = Array.Exists(numbers, (int num) => num % 2 == 0 );
```
 
You learned two "sub-shortcuts" within lambda expressions:

* You can remove the parameter type if it can be inferred:
```cs
bool hasEvenNumbers = Array.Exists(numbers, (num) => num % 2 == 0 );
```

* You can remove the parentheses if there is one parameter:
```cs
bool hasEvenNumbers = Array.Exists(numbers, num => num % 2 == 0 );
```


Review


Good developers don't work too hard. We all push ourselves to get better at coding, but when something seems difficult or repetitive, there's usually a better way to do it!

Methods are a good example:

```cs
bool IsEven(int num)
{
  return num % 2 == 0;
}
```

Why bother with these curly braces (`{ }`) and `return` keywords for such a short method?

In C# there are other ways to define a method, which can save us effort in typing and make our code easier to read. They're called _expression-bodied definitions_ and _lambda expressions_. 

From now on, when you see these phrases just think: "These are shortcuts for defining methods!" This lesson will show you how to use them.
