Haskell translation

I'm really enjoying this kata! It's interesting and unique. It has multiple levels of discovery for the uninitiated to a) braille unicode (cool!) b) Hamming distance (also cool!). However, I got bogged sown on the ligatures and text parsing. I think this kata could be split into two. The easy version without ligatures, then a harder version with ligatures. Really love this concept and very fun to grapple with, but will have to come back later to aolve as the ligatures are throwijg me for a loop. Without them i'd have solved already with "very" satisfied rating.

Solutions containing trailing whitespaces should be accepted as well. I had to tweak my solution to remove them.

javascript translation

Please add upper limit for base b in description.

What should I do when the base is greater than 36? I don`t understand :(

Okay, now finally back to this kata:

There is a difference (and hence confusion) between what the kata adverises to be and what the task actually is. The kata advertises to be "given an LFSR sequence, finds and emulates the LFSR and use it to generate LFSR sequences". What you actually wanted is "given an LFSR sequence, extend the sequence".

This is why there has been lots of confusion among what the kata actually is, what the specs are and whether they make sense. And I don't think you understand the difference either, with the description putting too much emphasis on "what the LFSR used to generate this sequence is", and with you contradicting yourself throughout the issues (first saying "yes I can add seed not in the sequence", then saying "but the seed is really actually in the sequence, even if if isn't in the input").

To be more technical, the current kata setup is logically tautological because of the following: to you, you generate an LFSR sequence, pick an element, then truncate the sequence somewhere around it as input. To us, we only see a sequence, and then given an arbitrary seed. If we assume the seed is in the sequence, then generate the LFSR sequence with this seed and one of the possible configurations computed from the input, then we find that it's really in the input sequence... which is what was assumed. (The real situation is more complicated because the kata asks for sequence uniqueness, but you get the idea.) For arbitrary seeds, there is a very high chance the seed will generate non-unique sequences given all possible configurations computed from the input, and by the definition of the kata they should return None.

I don't think these confusions will settle unless the kata makes it clear what it actually asks in its description and design:

• Title and description needs to be rewritten to be more specific what is being asked. "Reverse engineering" is a very broad term, and "emulates the LFSR" can be easily taken as "replicate the internal state of the LSFR", when what is actually asked is "predict the future sequence". Similarly, the description creates a big red herring but putting too much emphasis on what the underlying LSFR could be, when all we're concerned about is the future values.

• Since you actually want to extend the sequence, you don't even need to pass a seed to us: the output can be parameterless while generating the future elements as long as they can be uniquely determined. (And if you want, you can make it start from the beginning of the input.) Then there should be no confusion.

In the Javascript random BigInt tests, it includes base values > 36. Is this correct?

I don't quite get what beep() should return. I understand this should be a "signal" of a particular "length" but what is implied by it is unclear...

Pattern is still looking bad in description, at least in Chrome.
Perhaps can you use a <pre> formatting block?