functional programming stuff... in js.

.env

ENV=development
HOST=http://localhost:5000

function-composition.js

const fs = require('fs');

function pipe(...fns) {
  return function _piped(...args) {
    let current_value = fns[0](...args);

    for (let i = 1; i < fns.length; i++) {
      current_value = fns[i](current_value);
    }

    return current_value;
  };
}

const Result = {};

Result.Ok = function(value) {
  return {
    map: fn => Result.Ok(fn(value)),
    catchMap: () => Result.Ok(value),
    flatMap: fn => fn(value),
    cata: (error, success) => success(value),
  };
}

Result.Err = function(value) {
  return {
    map: () => Result.Err(value),
    catchMap: fn => Result.Err(fn(value)),
    flatMap: () => Result.Err(value),
    cata: (error, success) => error(value),
  };
}

Result.make_safe = function(fn) {
  return function(...args) {
    try {
      return Result.Ok(fn(...args));
    } catch(e) {
      return Result.Err(e);
    }
  }
}

const Maybe = function(value) {
  if(value == null) {
    return Maybe.Nothing();
  }

  return Maybe.Just(value);
}

Maybe.Just = function(value) {
  return {
    map: fn => Maybe.Just(fn(value)),
    catchMap: () => Maybe.Just(value),
    flatMap: fn => fn(value),
    cata: (nothing, just) => just(value),
  };
}

Maybe.Nothing = function() {
  return {
    map: () => Maybe.Nothing(),
    catchMap: fn => fn(),
    flatMap: () => Maybe.Nothing(),
    cata: (nothing, just) => nothing(),
  };
}

Maybe.wrap_fun = function(fn) {
  return function(...args) {
    return Maybe(fn(...args));
  }
} 


function cat(filepath) {
  return fs.readFileSync(filepath, 'utf-8');
}

function grep(pattern) {
  return function(content) {
    const exp = new RegExp(pattern);
    const lines = content.split('\n');

    return lines.find(line => exp.test(line));
  }
}

function cut({ delimiter, fields }) {
  return function(str) {
    return str.split(delimiter)[fields - 1];
  }
}

const chain = fn => m => m.flatMap(fn);
const unwrap_or = fallback => fm => 
  fm.cata(() => fallback, value => value);


const safer_cat = Result.make_safe(cat);
const maybe_host = Maybe.wrap_fun(grep('^HOST='));
const get_value = Maybe.wrap_fun(cut({delimiter: '=', fields: 2}));

const get_host = pipe(
  safer_cat,
  chain(maybe_host),
  chain(get_value),
  unwrap_or('http://127.0.0.1:3000')
);

console.log( get_host('.env') );