Niche Portobello Mushroom

    ifd

    0.1.0 • Public • Published

    ifd - Life Extending Ternary Abstractions

    license npm Dependencies Status wercker status

    As of late my affection for the conciseness-niceness of ternary operators is sky high. However, nesting ternaries is a one-way ticket to the ternary infirmary. A place where you second guess yourself, proceed to curse and raise your blood pressure resulting in your eventual but early death. In a nutshell, nested ternaries kill. The goal of ifd is to provide an alternative to the ternary infirmary by purveying two synergetic abstractions in one tasty punch. One abstraction is to deal with default values, and the other is for nested ternaries both with the goal of extending your life.

    Sidenote: Admittedly, ifd is the definition of feature creep, but I got sick of working on mind-numbing documentation, and after toying with an idea or two the challenge was too tempting to turn down.

    Core Concepts

    The mode of action for ifd is entirely dependent on its arguments. In other words, ifd has two distinct responsibilities under the same action, thus flipping the bird to the single responsibility principle. You may find this to be a questionable or even outright foolish design decision, and on many levels, I would agree. I could have separated ifd into two separate methods or functions, but it came at a cost I was unwilling to pay.

    This documentation is relatively brief, so it's in your best interest to look through the tests as well. Each test is separated from one another. The .js file is the test and the .md file is the description of the test. For the most part, each test focuses on a single aspect and the .md file should give you a good general gist of what should happen along with auxiliary notes if I saw fit.

    The "Default" Abstraction

    Info: Default values at times can be a pain in the butt. For the majority of cases, the pipe operator does the trick, but sometimes the pipe does not make the cut. When I can't pipe, more times than not, I find myself writing logic that for some reason or another turns into a janky mess that tends to creep into my ternaries. To solve this issue, ifd first and foremost acts as a truth-teller of identity.

    Action: Returns first "truth" or returns the last argument if no default option Object property is defined.

    Syntax

    ifd(<condition>, <condition>, ..., <options>)

    The Falsey Problem

    // if 0 is not a "falsey" value, then we gotz a problem
    const foo = 0 || 5;

    The Falsey Solution

    const foo = ifd(0, 5, {
      // 0 is not false
      zero: true
    });
     
    // foo === 0

    A Volume Bump

    // creates custom identity thunk
    const isAnArrayOfTwo = ifd({
      identity: function (val) {
        return Array.isArray(val) && val.length === 2;
      }
    });
     
    const foo = isAnArrayOfTwo([1, 2, 3], 'te', [4, 5], [6, 7]);
     
    //foo === [4, 5]

    Thoughts: While the "default" abstraction is splendid all by itself, it really spreads its wings when it teams up with its main man the "ternary" abstraction.

    Test Location: /__tests__/default-abstraction

    The "Ternary" Abstraction

    Info: As I mentioned earlier, nesting ternaries will land you in the ternary infirmary resulting in premature death, and from what I hear death isn't all that its cracked up to be. To postpone deaths looming inevitability, ifd creates an abstraction over array arguments which emulates that of the arguments in a ternary condition in more or less words.

    Action: If ifd has at least two arguments whose arguments are Array values excluding the last optional option argument Object; ifd evaluates the arguments using the "ternary" abstraction mode of action. In this mode ifd evaluates the <condition> arguments via the set "default" abstraction until a truthy <condition> is met in which case ifd then returns the <return> argument for the <condition>. If no truthy evaluation for the <condition> arguments is met, then the last <return> argument is returned if no default option Object property is defined.

    Syntax

    ifd([<condition>, <return>], [<condition>, <return>], ..., <options>)

    The Nested Ternary Problem

    const one   = false;
    const two   = false;
    const three = true;
     
    // while this gives us the desired outcome the
    // logic is hard to reason about
    const foo = one ? 1 : two ? 2 : three ? 3 : 4;
    // foo === 3

    The Nested Ternary Solution

    const one   = false;
    const two   = false;
    const three = true;
     
    const foo = ifd([one, 1], [two, 2], [three, 3], { default: 4 });
    // foo === 3

    "Ternary" Abstraction + "Default" Abstraction

    const one   = false;
    const two   = 'Kool';
    const three = false;
     
    const foo = ifd(
      [[ifd, false, null, one], 1],
      [[ifd, two, null], 2],
      [three, 3], {
        default: false
      }
    );
    // foo === 2
     
    // Additionaly, you can use a placeholder
    // to return the passing condition
    const returnCondition = ifd(
      [[ifd, false, null, one], 1],
      //default placeholder = %p
      [[ifd, two, null], '%p'],
      [three, 3], {
        default: false
      }
    );
    // returnCondition === 'Kool'

    Function Evaluation

    const one   = false;
    const two   = false;
    const three = true;
     
    const foo = ifd([one, 1], [two, 2], [three, 3], { default: 4 });
    // foo === 3

    A Volume Bump

    // creates custom identity thunk
    const isAnArrayOfTwo = ifd({
      // if isAnArryOfTwo does not met identity
      // then we want to return false as the default value
      default: false,
      identity: function (val) {
        return Array.isArray(val) && val.length === 2;
      }
    });
     
     
    // lazy evaluation of arguments
    const foo = ifd(
      [[isAnArrayOfTwo, false, true, 0, [2]], 'Not Me!'],
      [[isAnArrayOfTwo, [2, 3, 4], false, 'not-an-array'], 'Or Me Either!'],
      // [1, 2] === truthy -> <return>
      [[isAnArrayOfTwo, undefined, [1, 2], null, [2]], 'Pick Me, And Return This String'],
      [[isAnArrayOfTwo, null, []], 'will not be evaluated']
    );

    Thoughts: ifd goes up to eleven if you need that extra push over the cliff. Right now if you're scratching your head in all likelihood, ifd is probably not the package for you because the reason why you would potentially want to use ifd should click right away.

    Test Location: /__tests__/default-abstraction

    Options

    Truth Tellers

    • all: <Boolean | true>
      • Sets all default conditions
    • emptyString: <Boolean | false>
      • Return on empty String
    • false: <Boolean | false>
      • Return on false
    • NaN: <Boolean | false>
      • Return on NaN
    • null: <Boolean | false>
      • Return on null
    • undefined: <Boolean | false>
      • Return on undefined
    • zero: <Boolean | false>
      • Return on zero

    Identity

    • identity: <Function, [Function] | false>
      • Curstom identity Function
    • everyIdentity: <Boolean | false>
      • If identity is an Array of Functions, it must pass all identities
    • self: <All | Null>

    Flow

    • arrayArgs: <Boolean | true>
      • Assume ternary abstraction if all Array Arguments
    • condition: <Boolean | true>
      • Check returning condition for truth
    • create: <Boolean | true>
      • Return an ifd instance with set options
    • default: <All | null>
      • Default return if condition not met
    • invoke: <Boolean | true>
      • Invoke Function's in ifd
    • placeholder: <String | '%p'>
      • Placeholder return

    Best, te

    Install

    npm i ifd

    DownloadsWeekly Downloads

    0

    Version

    0.1.0

    License

    MIT

    Last publish

    Collaborators

    • artisin