fuzzily | Fast fuzzy string searching/matching for Rails

I was thinking about how I could save myself from undefinition, and one idea I had was to enumerate all possible sources of partiality. At least I would know what of to beware. I found three yet:

1. Incomplete pattern matches or guards.
2. Recursion. (Optionally excluding structural recursion on algebraic types.)
3. If a function is unsafe, any use of that function infects the user code. (Should I be saying "partiality is transitive"?)

I have heard of other ways to obtain a logical contradiction, for instance by using negative types, but I am not sure if anything of that sort applies to Haskell. There are many logical paradoxes out there, and some of them can be encoded in Haskell, but may it be true that any logical paradox requires the use of recursion, and is therefore covered by the point 2 above?

For instance, if it were proven that a Haskell expression free of recursion can always be evaluated to normal form, then the three points I give would be a complete list. I fuzzily remember seeing something like a proof of this in one of Simon Peyton Jones's books, but that was written like 30 years ago, so even if I remember correctly and it used to apply to a prototype Haskell back then, it may be false today, seeing how many a language extension we have. Possibly some of them enable other ways to undefine a program?

And then, if it were so easy to detect expressions that cannot be partial, why do we not do that? How easier would life be!

I've built a sample using the Typescript playground, but the behaviour isn't related to typescript specifically. It's a bit easier to show in code (link includes compiled JS, for those looking to ignore TS):

If you extend a class which uses an indexed array as a property

On the official Python docs here, it is mentioned that:

Heaps are also very useful in big disk sorts. You most probably all know that a big sort implies producing “runs” (which are pre-sorted sequences, whose size is usually related to the amount of CPU memory), followed by a merging passes for these runs, which merging is often very cleverly organised.
It is very important that the initial sort produces the longest runs possible. Tournaments are a good way to achieve that. If, using all the memory available to hold a tournament, you replace and percolate items that happen to fit the current run, you’ll produce runs which are twice the size of the memory for random input, and much better for input fuzzily ordered.

Moreover, if you output the 0’th item on disk and get an input which may not fit in the current tournament (because the value “wins” over the last output value), it cannot fit in the heap, so the size of the heap decreases. The freed memory could be cleverly reused immediately for progressively building a second heap, which grows at exactly the same rate the first heap is melting.
When the first heap completely vanishes, you switch heaps and start a new run. Clever and quite effective!

I am aware of an algorithm called External sorting in which we:

1. Break down the input into smaller chunks.
2. Sort all the chunks individually and write them back to disk one-by-one.
3. Create a heap and do a k-way merge among all the sorted chunks.

I completely understood external sorting as described on Wikipedia, but am not able to understand the author when they say:

If, using all the memory available to hold a tournament, you replace and percolate items that happen to fit the current run, you’ll produce runs which are twice the size of the memory for random input, and much better for input fuzzily ordered.

and:

Moreover, if you output the 0’th item on disk and get an input which may not fit in the current tournament (because the value “wins” over the last output value), it cannot fit in the heap, so the size of the heap decreases.

What is this heap melting?

Say you have a Rails application that uses ActiveRecord 4.2.5 and an included gem that uses an earlier version, say 3.2.14. Do both versions get loaded and used independently (I'm guessing yes)? Is there any way I can make this gem use a newer version? The gem in question has this entry in my Gemfile.lock: