# Functional JS with ES6 — Church Booleans, Conditionals, and Operators

In my last&nbsp;<a href="https://medium.com/dailyjs/functional-js-with-es6-recursive-patterns-b7d0813ef9e3" target="_blank">Functional JS article</a>, we went over recursive patterns that allow you to operate/iterate over array values. This time, we’re going to get a bit more abstract to hopefully explain some of the bare fundamentals of functional programming.

I’ll start this article with a warning, I mention the use of Lambda Calculus, but do not let that scare you! I promise, no knowledge of λ-Calculus is required to understand or use the main concepts in this article! Phew!

In my last Functional JS article, we went over recursive patterns that allow you to operate/iterate over array values. This time, we’re going to get a bit more abstract to hopefully explain some of the bare fundamentals of functional programming.

### A moment on Currying

You’ll notice that we never define a function with more than 1 argument. We return a new function for every additional argument needed. This is a technique used very commonly in functional programming that has its roots in Lambda Calculus. This has multiple benefits, but is used mainly to simplify partial application of functions.

### What are we doing?

Glad you asked! We’re going to re-create: true, false, ||(or), &&(and), !(not), ==(equals), and !=(not equals). As a bonus, we’re going to use some magical Lambda Calculus to make our functions much more efficient!

### Let’s get started!

The first functions we need to define are our booleans: true and false. How we define these functions makes more sense once they’re used with the conditional function we soon define. The way we represent booleans as functions is a concept known as Church Booleans.

### TRUE (true):

No, I’m not trying to yell, I’m using this naming convention because true in all lowercase is a reserved word and can’t be used to name our function. This function takes two arguments and will always return the first argument. In comparison, the FALSE function does the same, but always returns the second argument. These functions are also known as selectFirst and selectSecondin other languages.

```const TRUE = (x) => (y) => x
TRUE('foo')('bar') // => 'foo'
TRUE(10)(5) // => 10
```

### FALSE (false):

Almost identical to the TRUE function, but returns the second argument rather than the first.

```const FALSE = (x) => (y) => y
FALSE('foo')('bar') // => 'bar'
FALSE(10)(5) // => 5
```

### Conditional (cond):

The next function we need to define is our function that will handle conditional logic. Normally we’d use an if/else statement or a ternary to do this, but we want everything to be a function. It’s functions all the way down, this comes in handy later on.

If you break down a conditional in JavaScript, you end up with 3 parts:

1. Conditional Statement
2. Expression when true
3. Expression when false

To mimic this, we will create a function that takes 3 arguments and returns the conditional function with both expressions applied. If you notice, I place the conditional last rather than first. This is a functional programming convention that helps when creating partially applied functions.

If you remember how we defined our booleans, they are both functions that when called with 2 arguments, return one of these arguments. This is exactly how our conditional function is going to work. The conditional function (TRUE or FALSE) passed in is called with 2 arguments, our expressions when true and false.

```const cond = (isTrue) => (isFalse) => (conditional) =>
conditional(isTrue)(isFalse)
// use partial application to store the first two arguments and return a function ready to accept the last
const trueOrFalse = cond('This is true.')('This is false.')
trueOrFalse(TRUE) // => 'This is true.'
trueOrFalse(FALSE) // => 'This is false.'
// The follow will not work, we must use the defined TRUE and FALSE functions
trueOrFalse(true) // => TypeError: conditional is not a function
trueOrFalse(false) // => TypeError: conditional is not a function
```

### Not (!)

This is the first logical operator we will define. It takes a single argument: x. If x is TRUE it returns FALSE, if x is FALSE it returns TRUE. We make use of the previously defined cond function to handle the conditional logic. Within the conditional: if x is TRUE we return FALSE otherwise we return TRUE .

```const not = (x) => cond(FALSE)(TRUE)(x)
not(FALSE) // => TRUE
not(TRUE) // => FALSE
cond('Foo')('Bar')(not(TRUE)) // => 'Bar'
```

### Or (||)

This is the first logical operator we will define. It takes 2 arguments: x and y. If either x or y is TRUE, we will return TRUE, otherwise we return FALSE. Again, we use the cond function to handle this. Within the conditional: if x is TRUE we return TRUE otherwise we return y .

```const or = (x) => (y) => cond(TRUE)(y)(x)
or(TRUE)(FALSE) // => TRUE
or(FALSE)(FALSE) // => FALSE
or(FALSE)(TRUE) // => TRUE
or(TRUE)(TRUE) // => TRUE
```

### And (&&)

This function takes 2 arguments: x and y. Both x and y must be TRUE for this to return TRUE, otherwise it will return FALSE. We make use of the condfunction again, not much is different. Within the conditional: if x is TRUE we return y otherwise we return FALSE.

```const and = (x) => (y) => cond(y)(FALSE)(x)
and(TRUE)(FALSE) // => FALSE
and(FALSE)(TRUE) // => FALSE
and(FALSE)(FALSE) // => FALSE
and(TRUE)(TRUE) // => TRUE
```

### Equal (==)

This function takes 2 arguments: x and y. Both x and y must be the same value for this to return TRUE otherwise it returns FALSE. We need to use the cond function and the not function to handle this one! Within the conditional: if x is TRUE we return y otherwise we return not(y)to only return TRUE when y is also FALSE.

```const equal = (x) => (y) => cond(y)(not(y))(x)
equal(TRUE)(FALSE) // => FALSE
equal(FALSE)(TRUE) // => FALSE
equal(FALSE)(FALSE) // => TRUE
equal(TRUE)(TRUE) // => TRUE
```

### Not Equal (!=)

This function takes 2 arguments: x and y. x and y must not be the same value for this to return TRUE, otherwise FALSE is returned.

```const notEqual = (x) => (y) => cond(not(y))(y)(x)
notEqual(TRUE)(FALSE) // => TRUE
notEqual(FALSE)(TRUE) // => TRUE
notEqual(FALSE)(FALSE) // => FALSE
notEqual(TRUE)(TRUE) // => FALSE
```

### EXTRA: β (Beta) Reductions through λ-Calculus

Disclaimer: do not feel the need to understand this at all as it is not a requirement to understand and use functional concepts. However, I think it’s an interesting topic to learn about and helps demonstrate the power of functional programming through math. I will gloss over topics as I am not the best resource to learn λ-Calculus, it is not the focus of this article, just an added bonus. These optimizations are handled automatically with most statically compiled functional languages.

#### And (&&) Reduction

In the following example, we use β reduction to remove the use of our condfunction entirely from our and function. Our and function is now composed entirely with booleans and is mathematically equivalent!

```// original and function
const _and = (x) => (y) => cond(y)(FALSE)(x)
// this function can also be written as:
// λx.λy.cond y FALSE x
// it uses `cond` internally which can be written as:
// cond = λe1.λe2.λc.c e1 e2
// let's grab the function body and start reducing
// cond y FALSE x
// expand `cond` function
// (λe1.λe2.λc.c e1 e2) y FALSE x
// (λe2.λc.c y e2) FALSE x
// (λc.c y FALSE) x
// x y FALSE
// which results in:
const and = (x) => (y) => x(y)(FALSE)
```

#### Or (||) Reduction

Again, we use reduction to remove the use of our cond function entirely from our or function. Like before, our or function is now composed entirely with booleans and is mathematically equivalent.

```// original and function
const _or = (x) => (y) => cond(TRUE)(y)(x)
// this function can also be written as:
// λx.λy.cond TRUE y x
// it uses `cond` internally which can be written as:
// cond = λe1.λe2.λc.c e1 e2
// let's grab the function body and start reducing
// cond TRUE y x
// expand `cond` function
// (λe1.λe2.λc.c e1 e2) TRUE y x
// (λe2.λc.c TRUE e2) y x
// (λc.c TRUE y) x
// x TRUE y
// which results in:
const or = (x) => (y) => x(TRUE)(y)
```

#### Equal (==) Reduction

Just like before, we use reduction to remove the use of our cond function entirely from our equal function. Our equal function is now composed entirely with booleans and is mathematically equivalent.

```// original and function
const _equal = (x) => (y) => cond(y)(not(y))(x)
// this function can also be written as:
// λx.λy.cond y (not y) x
// it uses `cond` internally which can be written as:
// cond = λe1.λe2.λc.c e1 e2
// it uses `not` internally which can be written as:
// not = λx.cond FALSE TRUE x
// let's grab the function body and start reducing
// cond y (not y) x
// expand `cond` function
// λx.λy.(λe1.λe2.λc.c e1 e2) y (not y) x
// (λe1.λe2.λc.c e1 e2) y (not y) x
// (λe2.λc.c y e2)(not y) x
// (λc.c y (not y)) x
// (x y (not y))
// expand `not` function
// (x y (cond FALSE TRUE y))
// expand `cond` function
// (x y ((λe1.λe2.λc.c e1 e2) FALSE TRUE y))
// (x y ((λe2.λc.c FALSE e2) TRUE y))
// (x y ((λc.c FALSE TRUE) y))
// (x y (y FALSE TRUE))
// which results in:
const equal = (x) => (y) => x(y)(y(FALSE)(TRUE))
```

#### Not Equal(!=) Reduction

For the last time, we remove the use of our cond function entirely from our notEqual function. Our notEqual function is now composed entirely with booleans and is mathematically equivalent.

```// original and function
const _notEqual = (x) => (y) => cond(not(y))(y)(x)
// this function can also be written as:
// λx.λy.cond y (not y) x
// it uses `cond` internally which can be written as:
// cond = λe1.λe2.λc.c e1 e2
// it uses `not` internally which can be written as:
// not = λx.cond FALSE TRUE x
// let's grab the function body and start reducing
// cond (not y) y x
// expand `cond` function
// (λe1.λe2.λc.c e1 e2) (not y) y x
// (λe2.λc.c (not y) e2) y x
// (λc.c (not y) y) x
// x (not y) y
// expand `not` function
// x ((λx.cond FALSE TRUE x) y) y
// x (cond FALSE TRUE y) y
// expand `cond` function
// x ((λe1.λe2.λc.c e1 e2) FALSE TRUE y) y
// x ((λe2.λc.c FALSE e2) TRUE y) y
// x ((λc.c FALSE TRUE) y) y
// x (y FALSE TRUE) y
// which results in:
const notEqual = (x) => (y) => x(y(FALSE)(TRUE))(y)
```

### Wrapping Up

I hope this helped demonstrate the power and flexibility of functions. This logic can be shared and re-written in any language that has first-class functions!

The functions and concepts used in the article will be expanded in a later article where we use Church numerals to represent natural numbers as pure functions. We will even implement arithmetic and comparison operators for these numbers!

By :Casey Morris

## JavaScript Tutorial: if-else Statement in JavaScript This JavaScript tutorial is a step by step guide on JavaScript If Else Statements. Learn how to use If Else in javascript and also JavaScript If Else Statements. if-else Statement in JavaScript. JavaScript's conditional statements: if; if-else; nested-if; if-else-if. These statements allow you to control the flow of your program's execution based upon conditions known only during run time.

Decision Making in programming is similar to decision making in real life. In programming also we face some situations where we want a certain block of code to be executed when some condition is fulfilled.
A programming language uses control statements to control the flow of execution of the program based on certain conditions. These are used to cause the flow of execution to advance and branch based on changes to the state of a program.

JavaScript’s conditional statements:

• if
• if-else
• nested-if
• if-else-if

These statements allow you to control the flow of your program’s execution based upon conditions known only during run time.

• if: if statement is the most simple decision making statement. It is used to decide whether a certain statement or block of statements will be executed or not i.e if a certain condition is true then a block of statement is executed otherwise not.
Syntax:
``````if(condition)
{
// Statements to execute if
// condition is true
}
``````

Here, condition after evaluation will be either true or false. if statement accepts boolean values – if the value is true then it will execute the block of statements under it.
If we do not provide the curly braces ‘{‘ and ‘}’ after if( condition ) then by default if statement will consider the immediate one statement to be inside its block. For example,

``````if(condition)
statement1;
statement2;

// Here if the condition is true, if block
// will consider only statement1 to be inside
// its block.
``````

Flow chart:

Example:

``````<script type = "text/javaScript">

// JavaScript program to illustrate If statement

var i = 10;

if (i > 15)
document.write("10 is less than 15");

// This statement will be executed
// as if considers one statement by default
document.write("I am Not in if");

< /script>

``````

Output:

``````I am Not in if
``````
• if-else: The if statement alone tells us that if a condition is true it will execute a block of statements and if the condition is false it won’t. But what if we want to do something else if the condition is false. Here comes the else statement. We can use the else statement with if statement to execute a block of code when the condition is false.
Syntax:
``````if (condition)
{
// Executes this block if
// condition is true
}
else
{
// Executes this block if
// condition is false
}
``````

Example:

``````<script type = "text/javaScript">

// JavaScript program to illustrate If-else statement

var i = 10;

if (i < 15)
document.write("10 is less than 15");
else
document.write("I am Not in if");

< /script>

``````

Output:

``````i is smaller than 15
``````
• nested-if A nested if is an if statement that is the target of another if or else. Nested if statements means an if statement inside an if statement. Yes, JavaScript allows us to nest if statements within if statements. i.e, we can place an if statement inside another if statement.
Syntax:
``````if (condition1)
{
// Executes when condition1 is true
if (condition2)
{
// Executes when condition2 is true
}
}
``````

Example:

``````<script type = "text/javaScript">

// JavaScript program to illustrate nested-if statement

var i = 10;

if (i == 10) {

// First if statement
if (i < 15)
document.write("i is smaller than 15");

// Nested - if statement
// Will only be executed if statement above
// it is true
if (i < 12)
document.write("i is smaller than 12 too");
else
document.write("i is greater than 15");
}
< /script>

``````

Output:

``````i is smaller than 15
i is smaller than 12 too
``````
• if-else-if ladder Here, a user can decide among multiple options.The if statements are executed from the top down. As soon as one of the conditions controlling the if is true, the statement associated with that if is executed, and the rest of the ladder is bypassed. If none of the conditions is true, then the final else statement will be executed.
``````if (condition)
statement;
else if (condition)
statement;
.
.
else
statement;
``````

Example:

``````<script type = "text/javaScript">
// JavaScript program to illustrate nested-if statement

var i = 20;

if (i == 10)
document.wrte("i is 10");
else if (i == 15)
document.wrte("i is 15");
else if (i == 20)
document.wrte("i is 20");
else
document.wrte("i is not present");
< /script>

``````

Output:

``````i is 20
``````

## How to Retrieve full Profile of LinkedIn User using Javascript I am trying to retrieve the full profile (especially job history and educational qualifications) of a linkedin user via the Javascript (Fetch LinkedIn Data Using JavaScript)

Here we are fetching LinkedIn data like Username, Email and other fields using JavaScript SDK.

Here we have 2 workarounds.

1. Configuration of linkedIn developer api
2. Javascript Code to fetch records

In order to fetch records, first we need to create developer api in linkedin which will act as token/identity while fetching data from other linkedin accounts.

So to create api, navigate to https://linkedin.com/developer/apps and click on 'Create Application'.

After navigating, fill in details like name, description and other required fields and then submit.

As we submit, it will create Client ID and Client Secret shown below, which we will be using in our code while communicating to fetch records from other LinkedIn account.

Note: We need to provide localhost Url here under Oauth 2.0. I am using my localhost, but you can probably use other production URLs under Oauth 2.0 where your app is configured. It will make your api  consider the Url as trusted which fetching records.

Javascript Code to fetch records

For getting user details like first name, last name,User image can be written as,

``````<script type="text/javascript" src="https://platform.linkedin.com/in.js">
api_key: XXXXXXX //Client ID
authorize: true
</script>
<script type="text/javascript">
}

IN.API.Profile("me").result(ShowProfileData);
}

function ShowProfileData(profiles) {
var member = profiles.values;
var id = member.id;
var firstName = member.firstName;
var lastName = member.lastName;
var photo = member.pictureUrl;
//use information captured above
var stringToBind = "<p>First Name: " + firstName + " <p/><p> Last Name: " + lastName + "<p/><p>User ID: " + id + " and Head Line Provided: " + headline + "<p/>"
document.getElementById('profiles').innerHTML = stringToBind;
}
</script>
``````

Kindly note we need to include 'https://platform.linkedin.com/in.js' as src under script type as it will act on this Javascript SDK provided by Linkedin.

In the same way we can also fetch records of any organization with the companyid as keyword.

``````<head>
api_key: XXXXXXX ////Client ID
authorize: true
</script>

<body>
<script type="text/javascript">
console.log("On auth");
}

var cpnyID = XXXXX; //the Company ID for which we want updates
console.log("After auth");
}

var el = "<ul>";
var resValues = result.values;
for (var i in resValues) {
var share = resValues[i].updateContent.companyStatusUpdate.share;
var isContent = share.content;
var isTitled = isContent,
isDescription = isContent,
isThumbnail = isContent,
isComment = isContent;
if (isTitled) {
var title = isContent.title;
} else {
}
var comment = share.comment;
} else {
}
if (isDescription) {
var description = isContent.description;
} else {
var description = "No description";
}
/*
if (isThumbnailz) {
var thumbnailUrl = isContent.thumbnailUrl;
} else {
var thumbnailUrl = "http://placehold.it/60x60";
}
*/
if (share) {
var content = "<a target='_blank' href=" + link + ">" + comment + "</a><br>";
//el += "<li><img src='" + thumbnailUrl + "' alt=''>" + content + "</li>";
el += "<li><div>" + content + "</div></li>";
}
console.log(share);
}
el += "</ul>";
}
</script>
</body>
``````

We can get multiple metadata while fetching records for any any organization. We can get company updates as shown below.

Conclusion

We can also fetch any company specific data like company job updates/post, total likes, comments, and number of views along with a lot of metadata we can fetch which I have shown below.

## 7 Best Javascript Iframe Libraries Iframes let you build user experiences into embeddable ‘cross-domain components’, which let users interact with other sites without being redirected. I have compiled 7 best Javascript iframe libraries.

Iframes let you build user experiences into embeddable ‘cross-domain components’, which let users interact with other sites without being redirected. I have compiled 7 best Javascript iframe libraries.

1. Zoid

A cross-domain component toolkit, supporting:

• Render an iframe or popup on a different domain, and pass down props, including objects and functions
• Call callbacks natively from the child window without worrying about post-messaging or cross-domain restrictions
• Create and expose components to share functionality from your site to others!
• Render your component directly as a React, Vue or Angular component!
It's 'data-down, actions up' style components, but 100% cross-domain using iframes and popups!

2. Postmate

Postmate is a promise-based API built on postMessage. It allows a parent page to speak with a child iFrame across origins with minimal effort.

3. Iframe Resizer

Keep same and cross domain iFrames sized to their content with support for window/content resizing, in page links, nesting and multiple iFrames

Demo

4. Iframely

Embed proxy. Supports over 1800 domains via custom parsers, oEmbed, Twitter Cards and Open Graph

Demo

5. React Frame component

This component allows you to encapsulate your entire React application or per component in an iFrame.

Demo

6. Seamless.js

A seamless iframe makes it so that visitors are unable to distinguish between content within the iframe and content beside the iframe. Seamless.js is a JavaScript library (with no dependencies) that makes working with iframes easy by doing all the seamless stuff for you automatically.

Demo