branch | Wrapper around Branch.io HTTP API | REST library

In my case, I used BitBucket via HTTPS and not via SSH. Therefore I had to change it.

1. Follow this guide to create and add a new SSH key.
2. Follow this guide to switch from HTTPS to SSH.

Unrelated and optional:

While you are at this security related task, activate 2FA in your BitBucket security settings.

I fixed it by changing uses value to

• uses: google-github-actions/setup-gcloud@master

I think I may have figured out the problem. It appears that this is related to the use of conditionals in the variable setup. While the variables will be set in any valid trigger configuration, it appears that the proper values are not used during validation and that may have been causing the problem. Switching my conditional variables to first set a default value and then replace the value conditionally seems to have fixed the problem.

It would be nice if Microsoft would give a more useful error message here, something to the extent of the values not being found for a given variable, but adding defaults does seem to have fixed the problem.

Their relationship is like between cargo build and cargo rustc: cargo doc performs all the usual work, for an entire workspace, including dependencies (by default). cargo rustdoc allows you to pass flags directly to rustdoc, and only works for a single crate.

Here is the execution code for cargo rustdoc. Here is the code for cargo doc. The only differences is that cargo rustdoc always specify to not check dependencies while cargo doc allows you to choose (by default it does, but you can specify the flag --no-deps), and that cargo rustc allows you to pass flags directly to rustdoc with the flags after the --.

Code readability, short-circuiting and it is not guaranteed that Ord will always outperform a || operand. Computer systems are more complicated than expected, even though they are man-made.

There was a case where a for loop with a much more complicated condition ran faster on an IBM. The CPU didn't cool and thus instructions were executed faster, that was a possible reason. What I am trying to say, focus on other areas to improve code than fighting small-cases which will differ depending on the CPU and the boolean evaluation (compiler optimizations).

Unfortunatelly, it's not possible to use expressions with uses now.

One possible workaround (that I used for myself) is to push reusable workflow(s) to one of the stable branches (main/master/develop/etc.) and use SHA as a ref.

Additional benefit here is that using SHA is actually the recommended way described here.

Use pure from Control.Functor.Linear instead, as well as the IO from System.IO.Linear, because contents of Prelude are simply not declared as linear.

Note that this even simpler example does not compile too:

Rust uses the type for matching, so it doesn't know the bounds as per your logic. But you do.

For being explicit you can use unreachable!:

Indicates unreachable code.

This is useful any time that the compiler can’t determine that some code is unreachable. For example:

Match arms with guard conditions. Loops that dynamically terminate. Iterators that dynamically terminate. If the determination that the code is unreachable proves incorrect, the program immediately terminates with a panic!.

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¹: