What's the cleanest fp way to get a property pointed by another property

Question

Given an object that may be null and may have the following properties:

{
  templateId: "template1",
  templates: {
    template1: "hello"
  }
}

How would you get the template in a failsafe way? (templateId might not be defined, or the template it reffers might be undefined)

I use ramda and was trying to adapt my naive version of the code to use something like a Maybe adt to avoid explicit null/undefined checks.

I'm failing to come up with an elegant and clean solution.

naive ramda version:

const getTemplate = obj => {
  const templateId = obj && prop("templateId", obj);
  const template = templateId != null && path(["template", templateId], obj);
  return template;
}

this does work but I would like to avoid null checks, as my code has a lot more going on and it would be really nice to become cleaner

Edit I get from severall answers that the best is to ensure clean data first. That's not allways possible though. I also came up with this, which I do like.

const Empty=Symbol("Empty"); 
const p = R.propOr(Empty);
const getTemplate = R.converge(p,[p("templateId"), p("templates")]);

Would like to get feedback regarding how clean and how readable it is (and if there are edge cases that would wreck it)

Answer 1

Here is an ADT approach in vanilla Javascript:

// type constructor

const Type = name => {
  const Type = tag => Dcons => {
    const t = new Tcons();
    t[`run${name}`] = Dcons;
    t.tag = tag;
    return t;
  };

  const Tcons = Function(`return function ${name}() {}`) ();
  return Type;  
};

const Maybe = Type("Maybe");

// data constructor

const Just = x =>
  Maybe("Just") (cases => cases.Just(x));

const Nothing =
  Maybe("Nothing") (cases => cases.Nothing);

// typeclass functions

Maybe.fromNullable = x =>
  x === null
    ? Nothing
    : Just(x);

Maybe.map = f => tx =>
  tx.runMaybe({Just: x => Just(f(x)), Nothing});

Maybe.chain = ft => tx =>
  tx.runMaybe({Just: x => ft(x), Nothing});

Maybe.compk = ft => gt => x => 
  gt(x).runMaybe({Just: y => ft(y), Nothing});

// property access

const prop =
  k => o => o[k];

const propSafe = k => o =>
  k in o
    ? Just(o[k])
    : Nothing;

// auxiliary function

const id = x => x;

// test data

// case 1

const o = {
  templateId: "template1",
  templates: {
    template1: "hello"
  }
};

// case 2

const p = {
  templateId: null
};

// case 3

const q = {};

// case 4

const r = null; // ignored

// define the action (a function with a side effect)

const getTemplate = o => {
  const tx = Maybe.compk(Maybe.fromNullable)
    (propSafe("templateId"))
      (o);

  return Maybe.map(x => prop(x) (o.templates)) (tx);
};

/* run the effect,
   that is what it means to compose functions that may not produce a value */


console.log("case 1:",
  getTemplate(o).runMaybe({Just: id, Nothing: "N/A"})
);

console.log("case 2:",
  getTemplate(p).runMaybe({Just: id, Nothing: "N/A"})
);

console.log("case 3:",
  getTemplate(q).runMaybe({Just: id, Nothing: "N/A"})
);

As you can see I use functions to encode ADTs, since Javascript doesn't support them on the language level. This encoding is called Church/Scott encoding. Scott encoding is immutable by design and once you are familiar with it, its handling is a piece of cake.

Both Just values and Nothing are of type Maybe and include a tag property on which you can do pattern matching.

[EDIT]

Since Scott (not the encoding guy from just now) and the OP asked for a more detailed reply I extended my code. I still ignore the case where the object itself is null. You have to take care of this in a preceding step.

You may think this is overengineered - with certainty for this contrived example. But when complexity grows, these functional style can ease the pain. Please also note that we can handle all kinds of effects with this approach, not just null checks.

I am currently building an FRP solution, for instance, which is essentially based on the same building blocks. This repetition of patterns is one of the traits of the functional paradigm I would not want to do without anymore.

Answer 2

As others have told you, ugly data precludes beautiful code. Clean up your nulls or represent them as option types.

That said, ES6 does allow you to handle this with some heavy destructuring assignment

const EmptyTemplate =
  Symbol ()

const getTemplate = ({ templateId, templates: { [templateId]: x = EmptyTemplate } }) =>
  x
  
console.log
  ( getTemplate ({ templateId: "a", templates: { a: "hello" }}) // "hello"
  , getTemplate ({ templateId: "b", templates: { a: "hello" }}) // EmptyTemplate
  , getTemplate ({                  templates: { a: "hello" }}) // EmptyTemplate
  )

You can continue to make getTemplate even more defensive. For example, below we accept calling our function with an empty object, and even no input at all

const EmptyTemplate =
  Symbol ()

const getTemplate =
  ( { templateId
    , templates: { [templateId]: x = EmptyTemplate } = {}
    }
  = {}
  ) =>
    x
 
console.log
  ( getTemplate ({ templateId: "a", templates: { a: "hello" }}) // "hello"
  , getTemplate ({ templateId: "b", templates: { a: "hello" }}) // EmptyTemplate
  , getTemplate ({                  templates: { a: "hello" }}) // EmptyTemplate
  , getTemplate ({})                                            // EmptyTemplate
  , getTemplate ()                                              // EmptyTemplate
  )

Above, we start to experience a little pain. This signal is important not to ignore as it warns us we're doing something wrong. If you have to support that many null checks, it indicates you need to tighten down the code in other areas of your program. It'd be unwise to copy/paste any one of these answers verbatim and miss the lesson everyone is trying to teach you.

Answer 3

You can use R.pathOr. Whenever any part of the path isn't available, a default value is returned. For example:

const EmptyTemplate = Symbol();

const getTemplateOrDefault = obj => R.pathOr(
  EmptyTemplate,
  [ "templates", obj.templateId ],
  obj
);

A collection of tests can be found in this snippet. The example shows that pathOr handles all (?) "wrong" cases quite well:

const tests = [
  { templateId: "a",  templates: { "a": 1 } }, // 1
  {                   templates: { "a": 1 } }, // "empty"
  { templateId: "b",  templates: { "a": 1 } }, // "empty"
  { templateId: null, templates: { "a": 1 } }, // "empty"
  { templateId: "a",  templates: {        } }, // "empty"
  { templateId: "a"                         }  // "empty"
];

Edit: To support null or undefined inputs, you could compose the method with a quick defaultTo:

const templateGetter = compose(
  obj => pathOr("empty", [ "templates", obj.templateId ], obj),
  defaultTo({})
);

Answer 4

Try this,

const input = {
  templateId: "template1",
  templates: {
    template1: "hello"
  }
};

const getTemplate = (obj) => {
    const template = obj.templates[obj.templateId] || "any default value / simply remove this or part";
    //use below one if you think templates might be undefined too,
    //const template = obj.templates && obj.templates[obj.templateId] || "default value"
    return template;
}
console.log(getTemplate(input));

You can use a combination of && and || to short-circuit an expression.

Also, use [] (instead of .) with objects to get the value if the key is stored in a variable.

Complete check

const getTemplate = (obj) => {
    const template = obj && obj.templateId && obj.templates && obj.templates[obj.templateId] || "default value"
    return template;
}