// JS, TypeScript, Scala
(x, y) => x + y
 
// Java
(x, y) -> x + y
 
// Haskell
\x y -> x + y
 
// Python
lambda x, y : x + y
 
// Clojure
(fn [x y] (+ x y))
 
// Rust
|x, y| x + y

const toSeconds = h => m => s => (h*60 + m)*60 + s;
// ===>
const toSeconds = 
        h =>        // return a function with single parameter m
          ( m =>    // return a function with single parameter s
            ( s => (h*60 + m)*60 + s )
          )
 
 
const [hour, min, sec] = [7, 23, 48];
const ss = toSeconds(hour)(min)(sec);
// ===>
const toSecWithBoundHour = toSeconds(hour);            // partial application
const toSecWithBoundHourMin = toSecWithBoundHour(min); // partial application
const ss = toSecWithBoundHourMin(sec);

// curried function
const runCmd = root => cmd => api => {
    const cwd = path.resolve(root, api.apiPath, api.majorVersion);
    const result = shell.exec(cmd, { cwd, env });
    return result.code;
};
 
const rootPath = argv["root-path"];
const cmd = argv._.join(' ');
 
const run = runCmd(rootPath)(cmd);  // capture two variables
 
apiRepo.apiList(rootPath)
    .then(... process the api list ...)
    .then(_.map(run))               // apply the closure to each API
    .then(success => {
        if (success) {
            process.exit(0);
        } else {
            console.log('runforeach got at least one failure')
            process.exit(1);
        }
    })

function remoteGet(url){
  return httpGet(encode(preformat(trim(url))));
}
 
// becomes
 
const remoteGet = compose(
  httpGet,
  encode,
  preformat,
  trim
);
 
remoteGet(url1);
remoteGet(url2);

lines.map(line => trim(line));
 
 
lines.map(trim);

const getAdminEmail = 
  _.pipe(
    _.filter(_.pipe(
      _.property('role'),
      _.eq('admin')
    )),
    _.map(_.property('contact.email')),
  )

const mapName = 
  _.map(owner => 
    (owner.type === 'group')
      ? owner.name + owner.contact.name
      : 'user-' + owner.name
  )

// {scheme}://{host}/foo/v1 ====> foo/v1
const convert = _.flow([
  _.split('/'),
  (segments) => {
    const idx = _.findLastIndex(containAny(['{', '}', ':']))(segments);
    return _.drop(idx+1, segments);
  },
  _.reject(_.isEmpty),
  _.join('/'),
]);

let data;
 
if (extSysIntegrated) {
  data = fetchRemote();
} else {
  data = loadFromDb();
}
 
process(data);

// JavaScript
 
let data;
 
if (extSysIntegrated) {
  data = fetchRemote();
} else {
  data = loadFromDb();
}
 
process(data);

// const data = 
//   if (extSysIntegrated) {
//     fetchRemote(); 
//   } else {
//     loadFromDb();
//   }
 
const data = 
  extSysIntegrated 
  ? fetchRemote() 
  : loadFromDb();
 
process(data);

// Java 14
 
final int ndays = switch(month) {
    case JAN, MAR, MAY, JUL, AUG, OCT, DEC -> 31;
    case APR, JUN, SEP, NOV -> 30;
    case FEB -> {
        if (year % 400 ==0) yield 29;
        else if (year % 100 == 0) yield 28;
        else if (year % 4 ==0) yield 29;
        else yield 28; 
    }
};

const list2object = (list) => {
  const result = {};
  list.forEach(item => {
    result[item.id] = item;
  });
  return result;
};

// run a function 100 times
_.forEach(doSomething)(_.range(100))
 
// convert a list
const output = _.map((item) => {
  // process the item and return the new value
})(input);

// reducer: (memo, value) => newMemo
const maxMin = ([max, min], value) => {
  const newMax = value > max ? value : max;
  const newMin = value < min ? value : min;
  return [newMax, newMin];
}
 
const input = [3, 5, 2, 2, 9, 8];
 
// reduce(reducer, init, list)
const [max, min] = 
  _.reduce(
    maxMin, 
    [input[0], input[0]],
    input
  );
// ===> [9, 2]

  function metrics2Lines(input: Metrics[]): string[] {
    const result: string[] = [];
    _.forEach(input, (metrics) => {
      // Measurement
      let oneLine = `${metrics.name}`;
      // Tag set
      _.forEach(metrics.tags, (value, key) => { oneLine += `,${key}=${value}`; });
      // Field set
      let tagStr = '';
      _.forEach(metrics.fields, (value, key) => { tagStr += `,${key}=${value}`; });
      oneLine += ` ` + tagStr.slice(1, tagStr.length);
      // Timestamp
      oneLine += ` ${metrics.timestamp ? metrics.timestamp * 1000000 : Date.now() * 1000000}`;
      // New line
      result.push(oneLine);
    });
    return result;
  }

public <A, B, C> Function<A, Function<B, C>> curry(final BiFunction<A, B, C> f) {
  return (A a) -> (B b) -> f.apply(a, b);
}

function removeUndefinedOrNull(source) {
    return _.pickBy(source,
        (val) => ((val !== undefined) && (val != null)));
}
 
function removeUndefinedOrNull(source) {
    return _.pickBy(source,
        (val) => !_.isNil(val);
}
 
// arrow function notation
const removeUndefinedOrNull = source => _.pickBy(source, (val) => !_.isNil(val));
 
const removeUndefinedOrNull = source => _.omitBy(source, (val) => _.isNil(val));
 
// beta reduction
const removeUndefinedOrNull = source => _.omitBy(source, _.isNil);
 
// currying and partial application
// curryRight(_.omitBy) ====> omitBy(predicate)(obj)
const removeUndefinedOrNull = _.curryRight(_.omitBy)(_.isNil);

const name = "charles"
 
const greet = name => `Hello, ${name}`
const capitalize = str => str.toUpperCase()
const exclaim = str => `${str}!!!`
 
const loudGreeting = name 
                      |> greet
                      |> capitalize
                      |> exclaim
 
console.log(loudGreeting) // HELLO, CHARLES!!!