Sum a dimension N square matrix main and anti diagonal values

help.md

Sum a dimension N square matrix main and anti diagonal values.

Given the Matrix:

[ [ 1,  2,  3,  4]
, [ 5,  6,  7,  8]
, [ 9, 10, 11, 12]
, [13, 14, 15, 16]
]

The main diagonal is:

[ [ 1,   ,   ,   ]
, [  ,  6,   ,   ]
, [  ,   , 11,   ]
, [  ,   ,   , 16]
]

And the anti diagonal is:

[ [  ,   ,   ,  4]
, [  ,   ,  7,   ]
, [  , 10,   ,   ]
, [13,   ,   ,   ]
]

Take and sum these values.

Be careful! Non-square matrices should not return the sum.

matrix-diagonals-sum.js

const
  always = x => () =>
    x

, composeN = (...fs) => y =>
    fs.reduceRight((x, f) => f(x), y)

, c =
    composeN

, not = prop =>
    !prop

, map = f => xs =>
    xs.map(f)

, reduce = f => xs =>
    xs.reduce(f)
    
, concat = xs => ys =>
    ys.concat(xs)
    
, eq = x => y =>
    x === y
  
, prop = p => o =>
    o[p]
    
, at =
    prop
    
, at2d = i => j =>
    c(at(i), at(j))

, len =
    prop('length')
    
, all = pred => xs =>
    xs.every(pred)
    
, sum = x => y =>
    x + y

, uncurry2 = f => (x, y) =>
    f(x)(y)

, upto = n =>
    Array.from({length: n})
      .map((_, i) => i)

, mainDiagonal = M =>
    map(i => at2d(i)(i)(M))
       (upto(len(M)))

, antiDiagonal = M => {
    if (c(not, isSquareMatrix)(M)) {
      return Maybe.Nothing()
    }
    
    return Maybe.Just(
      map(i => at2d(len(M) - i - 1)(i)(M))
         (upto(len(M)))
    )
  }

, isSquareMatrix = M => {
    let
      [xs, ...ys] = M
    
    , height = len(M)  
    
    , headLength = len(xs)
      
    return eq(height)(headLength)
           && all(c(eq(headLength), len))(ys)
  }

, Maybe = (() => {
    const
      sym = Symbol.for('Maybe')
      
    , Nothing =
        always({
          [sym]: 'Nothing'
        })
        
    , Just = value =>
        ({
          [sym]: 'Just',
          value,
        })
      
    , isJust = m =>
        m[sym] === 'Just'
        
    , map = f => m=>
        isJust(m) ? Just(f(m.value)) : Nothing()
        
    , toString = m =>
        isJust(m) ? `Just(${m.value})` : 'Nothing()'
    
    return {map, Nothing, Just, isJust, toString}
  })()

, M =
    [ [ 1,  2,  3,  4]
    , [ 5,  6,  7,  8]
    , [ 9, 10, 11, 12]
    , [13, 14, 15, 16] // Comment this line
    // , [13, 14, 15]  // And uncomment this to error
    ]
    
, solve = M =>
    c(
      Maybe.toString,
      Maybe.map(reduce(uncurry2(sum))),
      Maybe.map(concat(mainDiagonal(M)))
    )(antiDiagonal(M))
    
solve(M)