Is dense good? The Vigenère cipher in JavaScript & Haskell

I cannot decide what I feel about the differences between my JavaScript and Haskell solution of the Vigenère cipher.

In natural languages, we speak about information density and as far as I know, information density evens out if we provide time as a parameter. That is, a dense language is spoken and understood more slowly than a 'chatty' counterpart.

How should we think about terse programming languages? I am divided. They are more elegant surely. But how should we value this aspect? What does dense expressions lead to? Something elegant usually takes more time to articulate, but usually also more time to understand. Given a context that does not favor quick-fix solutions, this is most likely something good (especially in the long run) but what about environments that want results fast?


function vigenere(key) {
  const AZ_LENGTH = 26;
  const alphabetAZ = Array
      {length: AZ_LENGTH},
      (_, i) => String.fromCharCode(i + 65)
  const table = alphabetAZ.reduce((table, v, i) => ({...table, [v]: i}), {});
  const cryptoStr = (msg, key) => ''.padStart(msg.length, key);
  const cryptoStrLetterAt = (msg, key, pos) => cryptoStr(msg,key)[pos];
  return {
    encrypt: (msg) => msg
        (char, i) => alphabetAZ[
            (table[char] + table[cryptoStrLetterAt(msg, key, i)]) % AZ_LENGTH
    decrypt: (msg) => msg
        (char, i) => alphabetAZ[
          (table[char] - table[cryptoStrLetterAt(msg, key, i)] + AZ_LENGTH) % AZ_LENGTH

// --------------------------------
const code = vigenere('LEMON');
console.log(code.encrypt('ATTACKATDAWN')); // LXFOPVEFRNHR
console.log(code.decrypt('LXFOPVEFRNHR')); // ATTACKATDAWN


import Data.Char

shift (senLetter, keyLetter) fn = chr $ start + (ord senLetter `fn` ord keyLetter) `mod` azLength
    start = ord 'A'
    azLength = 26

encode sentence key = map (`shift` (+)) $ zip sentence $ cycle key
decode sentence key = map (`shift` (-)) $ zip sentence $ cycle key

-- --------------------------------