kalisjoshua

// Utility Function Definition
// A pipeline will call a series of functions pipe-ing output to input.
function pipe () {
  return [].slice.call(arguments)
    .reduce(function (acc, fn) {
      return fn(acc)
    })
}

// The above code compresses better then the ES2015 version.

kalisjoshua

// 1.
// replace instances with different replacement strings
const qwerty = 'qw#rt#'.replace(/#/g, [].shift.bind(['e', 'y']));

// 2.
// make Array.slice available as a function instead of a method
const slice = Function.prototype.call.bind(Array.prototype.slice);

// 3.
// ASI (failure) working in conjunction with the comma operator

kalisjoshua

#! /bin/bash

ROOT=/opt/fact
FACTORIO="$ROOT/factorio/bin/x64/factorio"
VERSION=$($FACTORIO --version | xargs echo | cut -d ' ' -f 2)

if [ "$1" = "start" ]; then

  echo 'starting server'
  # echo $$ > $ROOT/factorio.pid

kalisjoshua

function pubsubFactory() {
  let subscribers = [];
  const pub = publish;
  const sub = subscribe;
  const remove = unsubscribe;

  function publish(message) {
    if (!message) {
      throw new Error('Not going to publish an empty message to subscribers.', 'pubsub.js');
    }

kalisjoshua

Curry-ing Functions In JavaScript

I don't know why, but this morning I felt like exploring function curry-ing and writing a little bit about it. First I watched a video on curry-ing from the JS Weekly newletter. Then I wanted to write my own implementation. After that I thought I would share what I did with my team at work and then this.

Brain-dump over.

The only reason I created two different implementations is becuase semantically I think that a function is only curried once; as I understand it - to curry - is a process by which you convert a single function which takes multiple arguments into a series of multiple functions each taking exactly one argument.

So, while the implementations work identically from the point of view of the user the differ in their implementation; basically only semantically.

kalisjoshua

standardDELETE:
    responses:
      200:
        description: <<200description>>
        body:
          application/json:
            example: <<200jsonExample>>
            schema: <<200jsonSchema>>
      202:
        description: <<202description>>

kalisjoshua

// What does this code achieve?

function toArray(args) {
  return Array.prototype.slice.call(args);
}

// When would you use it? Why does it need to be implemented this way? And what about the following code?

function log(args) {
  Function.prototype.apply.call(console.log, console, args);

kalisjoshua

{
    init: function(elevators, floors) {
        var TOP_LEVEL = floors.length - 1;

        floors.requestQueue = [];
        
        /**/
        function _padd(len, str, char) {
            str = '' + str;
            while(str.length < len) {str = str + char;}

kalisjoshua

// ----
// Sass (v3.4.7)
// Compass (v1.0.1)
// ----

@mixin size($size, $modulo: 5) {
  @if $size % $modulo == 0 {
    width: unquote('#{$size}%') !important;  
  }
}

kalisjoshua

(function (doc) {
    doc.body.style.fontSize = '115%';
    doc.body.style.margin = '0 auto';
    doc.body.style.maxWidth = '37em';

    var count,
        rPage = /\[\s*?page\s*?(\d+?)\s*?\]/i,
        TOP = 'top-of-document';

    function turn(delta) {