recursive | Recursive Mono & Sans is a variable font family

There are several problems here.

Problem 1 is that the non-recursive clauses for your recursive predicates look like this:

Your split splits the list in two ordered halves, so merge consumes its first argument first and then just produces the second half in full. In other words it is equivalent to ++, doing redundant comparisons on the first half which always turn out to be True.

In the true mergesort the merge actually does twice the work on random data because the two parts are not ordered.

The split though spends some work on the partitioning whereas an online bottom-up mergesort would spend no work there at all. But the built-in sort tries to detect ordered runs in the input, and apparently that extra work is not negligible.

To the best of my knowledge, you can only override particular values of YAML anchors. Attempts to 'pass arguments' won't work.

Instead, Bitbucket Pipelines provide Deployments - an ad-hoc way to assign different values to your variables depending on the environment. You'll need to create two deployments (say, dev and uat), and use them when referring to a step:

The code doesn't work completely properly. Would you please explain my mistakes?

You were quite close. The main problem is that the return keyword in front of the recursive calls terminates the for loop and the entire f function prematurely. This will cause it to visit only the nodes on the first possible branch, not all of them.

The other issue is that branches might be empty at the end of the function, yet you still access [0][0]. Instead return the entire array from f, and access the first tuple on in getResult.

These two small fixes already make the function work¹:

In Haskell these kinds of things aren't the most trivial ones, indeed. You would really like to have some in-place mutations going on to save up on memory and time, so I don't see any better way than equipping the frightening ST monad.

This could be done over various data structures, arrays, vectors, repa tensors. I chose HashTable from hashtables because it is the simplest to use and is performant enough to make sense in my example.

First of all, introduction:

Note: When referring to documentation and source code, I provide links to an unofficial GitHub mirror of R's official Subversion repository. The links are bound to commit 97b6424 in the GitHub repo, which maps to revision 81461 in the Subversion repo (the latest at the time of this edit).

substitute is a "special" whose arguments are not evaluated (doc).

Laziness to the rescue. We can recursively define a list of all the sub-automata, such that their transitions index into that same list:

One answer to the linked question mentions adding an extra type parameter, so that instead of Tree (Labeled a) we use Tree Labeled a:

The optimization is called "call-pattern specialization" (a.k.a. SpecConstr) this specializes functions according to which arguments they are applied to. The optimization is described in the paper "Call-pattern specialisation for Haskell programs" by Simon Peyton Jones. The current implementation in GHC is different from what is described in that paper in two highly relevant ways:

1. SpecConstr can apply to any call in the same module, not just recursive calls inside a single definition.
2. SpecConstr can apply to functions as arguments, not just constructors. However, it doesn't work for lambdas, unless they have been floated out by full laziness.

Here is the relevant part of the core that is produced without this optimization, using -fno-spec-constr, and with the -dsuppress-all -dsuppress-uniques -dno-typeable-binds flags: