You are facing several challenges in this scenario -

1. Effectively accessing deeply nested data in an uncertain object
2. Organizing an array of intricate data using functional methods
3. Safely and unchangeably modifying deeply nested data in an uncertain object

---

1. The use of .map and .chain may seem rudimentary, additional levels of abstraction should be incorporated as the syntax becomes cumbersome –

const state =
  { tree:
      { type: "sequoia"
      , children: [ "a", "b", "c" ]
      }
  }

recSafeProp(state, [ "tree", "type" ])
  .getOrElse("?") // "sequoia"

recSafeProp(state, [ "tree", "foobar" ])
  .getOrElse("?") // "?"

recSafeProp(state, [ "tree", "children", 0 ])
  .getOrElse("?") // "a"

recSafeProp(state, [ "tree", "children", 1 ])
  .getOrElse("?") // "b"

recSafeProp(state, [ "tree", "children", 99 ])
  .getOrElse("?") // "?"

We can easily implement recSafeProp by creating our own utility function, safeProp, in the process –

const { Nothing, fromNullable } =
  require("data.maybe")

const recSafeProp = (o = {}, props = []) =>
  props.reduce // for each props as p
    ( (r, p) => // safely lookup p on child
        r.chain(child => safeProp(child, p))
    , fromNullable(o) // init with Maybe o
    )

const safeProp = (o = {}, p = "") =>
  Object(o) === o // if o is an object
    ? fromNullable(o[p]) // wrap o[p] Maybe
    : Nothing()  // o is not an object, return Nothing

---

2. The Comparison module. Given your familiarity with functional modules, let's delve into it –

const { empty, map } =
  Comparison

const prioritySort =
  map(empty, record => record.priority || 0)

// or...
const prioritySort =
  map(empty, ({ priority = 0}) => priority)

myarr.sort(prioritySort)

If you require an immutable sort –

const isort = ([ ...copy ], compare = empty) =>
  copy.sort(compare)

const newArr =
  isort(origArr, proritySort)

Here's the Comparison module. It is introduced in this Q&A. Refer to it there to see how to create complex sorters in a functional manner –

const Comparison =
  { empty: (a, b) =>
      a < b ? -1
        : a > b ? 1
          : 0
  , map: (m, f) =>
      (a, b) => m(f(a), f(b))
  , concat: (m, n) =>
      (a, b) => Ordered.concat(m(a, b), n(a, b))
  , reverse: (m) =>
      (a, b) => m(b, a)
  , nsort: (...m) =>
      m.reduce(Comparison.concat, Comparison.empty)
  }

const Ordered =
  { empty: 0
  , concat: (a, b) =>
      a === 0 ? b : a
  }

Combining sorters –

const { empty, map, concat } =
  Comparison

const sortByProp = (prop = "") =>
  map(empty, (o = {}) => o[prop])

const sortByFullName =
  concat
    ( sortByProp("lastName")  // primary: sort by obj.lastName
    , sortByProp("firstName") // secondary: sort by obj.firstName
    )

data.sort(sortByFullName) // ...

Composable sorters –

const { ..., reverse } =
  Comparison

// sort by `name` then reverse sort by `age` –
data.sort(concat(sortByName, reverse(sortByAge)))

Functional prinicples –

// this...
concat(reverse(sortByName), reverse(sortByAge))

// is the same as...
reverse(concat(sortByName, sortByAge))

As well as –

const { ..., nsort } =
  Comparison

// this...
concat(sortByYear, concat(sortByMonth, sortByDay))

// is the same as...
concat(concat(sortByYear, sortByMonth), sortByDay)

// is the same as...
nsort(sortByYear, sortByMonth, sortByDay)

---

3. The easiest solution to consider in this situation is Immutable.js. If time permits, I will demonstrate a low-fi approach to this specific problem later on.

It appears to me that your solution may be a bit excessive.

Functional programming encompasses various concepts, and while there isn't a concise definition, focusing on pure functions and avoiding data mutation is a key aspect of being a functional programmer. While the Either monad can offer powerful advantages in certain situations, it seems like in this code, there is an attempt to force the use of Either where it may not be the best fit.

Here is a suggestion on how to approach this code. I made some assumptions along the way, such as the need for an asynchronous process when fetching data from a server, using methods like Promises, async-await, or similar alternatives such as Tasks or Futures. Additionally, I assumed that the part where you reference mocked_firewall involves the actual asynchronous call. Although your sample code treated it as an object for looking up results from a path, the logic was a bit unclear regarding its resemblance to a real service. Lastly, the use of

fold(() => log(...), x => log(x))

was merely for demonstration purposes to showcase the code's functionality.

With these considerations in mind, I suggested a version with an object mapping type to functions, each taking data and state as inputs and returning a new state. The central function, fetchData, takes something akin to your mocked_firewall (or a modified version to return a Promise) and returns a function that accepts a state and returns a new state.

The revised code snippet looks as follows:

🎈 Here's a concise approach:

My approach involves using ramda, where you can combine functions to achieve the desired result ✨:

const prioritySort = R.compose(
  R.when(
    R.propEq('type', 'tree'),
    R.over(
      R.lensProp('children'),
      R.map(child => prioritySort(child))
    )
  ),
  R.when(
    R.propEq('type', 'table'),
    R.over(
      R.lensProp('records'),
      R.sortBy(R.prop('priority')),
    )
  ),
)

const fetchData = R.pipe(
  endpoint => fetch(`https://your-api.com/${endpoint}`, opts).then(res => res.json()),
  R.andThen(prioritySort),
)

fetchData(`tree`).then(console.log)
fetchData(`table`).then(console.log)

Explore the demo

You can easily inspect the process using the function

const log = value => console.log(value) || value

R.pipe(
  // some code
  log,
  // some code
)

It will display the value as it passes through the pipe.