DEV Community: Muthukumaran

Declarative Optional.Js

Muthukumaran — Mon, 03 Jan 2022 07:30:12 +0000

I have created a small Functional programming library in javascript , which supports developing code by chaining asynchronous and synchronous operations.

Consider this example

function getFromUserService({username, password}) {
    return new Promise((function (resolve) {
        resolve({name: "user", isAdmin: true})
    }))
}
async function login(input) {

 if (null == input) {
        throw new Error("Input Cannot be Null")
    }

const {username, password} = input
    if (null == username || null == password) {
        throw new Error("Input Cannot be Null")
    }
    const result = await getFromUserService(username, password)
    if (result.isAdmin) {
        redirectTo("adminPage")
    } else {
        redirectTo("userPage")
    }
}

The same can be rewritten as

const page = await Optional.of(input)
       .filter(({username, password}) => (null != username && null != password))
        .map(getFromUserService)
        .map(result => result.isAdmin ? "adminPage" : "userPage")
        .toAsync();
    page.ifPresentOrElse(redirectTo, () => {
        throw new Error("Input Cannot be Null")
    })

Using with Fetch

const rawResults = await fetch('https://jsonplaceholder.typicode.com/todos/' + item);
const response = await rawResults.json();
if (response.completed) {
    return response.title
} else {
    return null
}

The above can be rewritten as

return await Optional.of('https://jsonplaceholder.typicode.com/todos/' + item)
    .map(fetch)
    .map(response => response.json())
    .filter(response => response.completed == true)
    .map(response => response.title)
    .getAsync();

Chaining of expressions enables the code concise and help to reasonate better, can easily be composed , combined.

Installation & Usage

 npm install declarative-optional   

//ES6
 import Optional from "declarative-optional";

//Common Js
  const Optional = require( "declarative-optional");


//Increment a Number , which may be null
 Optional.of(input)
    .map(val=>val+1)
    .get()

Links
npm
github

DeclarativeX — A Composable approach to exception & conditions in Java

Muthukumaran — Fri, 03 Sep 2021 17:24:52 +0000

The idea of utilizing functional programming is to enable declarative programming along with supporting concurrency & state issues.

Most of the items are already better with Java 8 in terms of declarative programming, with the help of Optional Monad, Streams API.

I could sense a need, especially in exception handling and conditions. We might need a composable api to effectively handle exceptions and multi conditions.

The Declarativex library attempts to solve the issue through some functional and fluent interface way.

Chaining Exceptions

If all your functions has the same parameter within chaining, You can use this alternative

Catching Exceptions based on Type and Performing appropriate actions

Logging / peeking

Composing Conditions

Usage
Add Dependency

<dependency>
    <groupId>io.github.muthuishere</groupId>
    <artifactId>declarativex</artifactId>
</dependency>

Import with

import declarativex.Try;
import declarativex.Filter;

Github URL

Reactive Programming Basics - adding of two numbers and beyond

Muthukumaran — Sat, 17 Oct 2020 11:30:29 +0000

Disclaimer : I am not going to explain observables, Observer,Subscriptions,Subscriber,preventing memory leaks… Just simple reactive programming.

a=74
b=18
c= a +b

The value of c => 92

If our program is completed here , we don’t have to go into reactive programming.

Now consider

a=a + 1

Stop..

It appears lame to use variables like a,b,c usage and incrementing one of it.

We will consider practical situation

Scenario

Donald Trump born on 14 June 1946 & Cheguara on same day (14 June) of 1928 , the age difference between these two is 18 years
Now we can write these as

let ageOfTrump = 74
let ageOfCheGuara = ageOfTrump + 18

so ageOfCheGuara would be 92
And the long kept secret about Age is , it always kept incrementing on birthday 😊

So if there is a method happyBirthdayTrump which increase age of trump

function happyBirthDayToTrump(){
    ageOfTrump=ageOfTrump + 1   
}

What should be the value of ageOfCheGuara after this method has been called?

Still  92,

The contract (ageOfCheGuara = ageOfTrump + 18) denotes
ageOfCheGuara should always be sum of ageOfTrump & 18 , But unfortunately it was not always.

How to fix it

So to fix it , Whenever Trump got a birthday and his age gets incremented

We should also be updating ageOfCheGuara ,something like this

function happyBirthDayToTrump(){
    ageOfTrump=ageOfTrump + 1
    ageOfCheGuara =  ageOfTrump + 18

}

Now things are fine, Because i keep on insisting that relationship again.

Is there a way , I could specify only once the relationship and use it across the application

if I could update ageOfTrump, ageOfCheGuara should automatically be updated.

This is a common problem, if you are from C or C++ background you could have used pointer to look into address than its value, which will help us to solve these kindda issues.

But This is Javascript, we don’t do that. How can we do ?

By making every relationship as sacred and final and no unwanted updates for sake of programming, you have already been making your system reactive.

Making Reactive with RxJS

There are many ways to achieve it , We use Rx Libraries to achieve it here

So the
ageOfTrump = 74
ageOfCheGuara = ageOfTrump + 18

instead of using as variables we will have something like

const ageOfTrump = new BehaviorSubject(74)

BehaviourSubject helps us to set a default value 74
We can retrieve its current value by using getValue method

Don’t worry about these syntax, There are more than 100’s of operators. Just focus on the concept.

const ageOfCheGuara = ageOfTrump.pipe(
                        map(val=>val + 18)
                        )

by using pipe operator with ageOfTrump , we are specifying ageOfCheGuara depends on it.map operator accepts a function , which will receive the value from trump and transform the value

The happyBirthDayToTrump method will be

function happyBirthDayToTrump(){
    const incrementedAge =ageOfTrump.getValue() + 1
    ageOfTrump.next(incrementedAge)
}

The currentValue to be retrieved with getValue method

The value should be set with next method

Now we have made these variables reactive.

The entire source code is available on Link

The same has been demonstrated in video and available on

Link