# Everything as an expression – DEV Community

In my journey of studying F#, I’ve come throughout the idea of “every part is an expression” which was an eye-opening expertise for me. Now earlier than I’m going into extra particulars, let’s simply clear up the distinction between an expression and a press release.

I like to think about an expression as something that evaluates to a price. This contains arithmetic operations, ternary operators, perform outcomes, and so forth.

``````// arithmetic expression that evalues to 36
5 * 6

// perform name that evalues to 120
factorial(5)

// ternary operator that evalues to 9
isEven(11) ? 8 : 9
``````

Discover how all of those consider to a price that may very well be saved in a variable. Now let’s take a look at some examples of a press release.

``````// project
let b = 7

// branching
if (x % 7) {
// some code goes right here
} else {
// some code goes right here
}

// loops
whereas (true) { /* some code */ }
for (let i = 0; i < 10; i++) { /* some code */ }
``````

for instance you might be designing a brand new language and you do not like this arbitrary distinction between expressions and statements, what can we do to repair this with out making the language unusable?

We will begin by combining if-statements and ternary expressions into one by making if-statements return the final worth of their our bodies.

``````let a = if (b > 10) {
/* some code */
5
} else {
/* some code */
3
}
``````

You may discuss with Binding and continuations in ML for why blocks expressions consider to the final worth of their our bodies.

What about whereas/for loops? their performance might be simply replicated by recursion so let’s do away with them. For instance, the next:

``````let i = 0;
whereas (i < 10) {
print("good day world")
i++
}
``````

may very well be transformed to make use of recursion like this:

``````let loop = (i, finish) => {
if (i < finish) {
print("good day world")
loop(i + 1, finish)
}
}

loop(0, 10)
``````

This leaves us with let-statements. in ML languages, we’ve let-in expressions which is impressed by Mathematics

``````(* this is identical as (5 * 5) + 1 *)
let x = 5 in (x * x) + 1
``````

Discover that in our earlier instance, we’re not assigning to a variable. As an alternative, we are saying that `x` will stand for the worth `5` within the expression after the `in` key phrase.

Since let-statements take expression after the `in` key phrase and since they’re themselves expressions, we are able to do one thing like this:

``````let x = 5 in (let y = 6 in x + y)
``````

if we take away the parenthesis and do some little bit of formatting, we might find yourself with one thing like this:

``````let x = 5 in
let y = 6 in
x + y
``````

So why all of that is necessary? Effectively, I believe grokking the idea “every part as an expression” is significant to understanding why pure purposeful programming languages are likely to keep away from mutations and unwanted effects.

The Article was Inspired from tech community site.
Contact us if this is inspired from your article and we will give you credit for it for serving the community.