Nire Bryce

Destructuring match statements like in ocaml and rust are pretty amazing. If you squint at em they're like switch statements, but so much more expressive

if..let, while..let and especially let..else!

OCaml's try-with expressions for exception handling are quite nice, mostly because they are, well, expressions and not statements. This means you can return a value from a try-with expression and even put it inside a different expression. Unlike, say, Java's try-catch, this means that handling exceptions does not need to completely mess up the flow of your function!

It's also a nice bonus that you can use these as exception patterns in a regular match expression like this

let value = match arr.(42) with
    | exception Not_Found -> "nope" 
    | 0 -> "zero"
    | x -> string_of_int x

This can be much more convenient sometimes

Rust match blocks (like a switch statement on steriods) are like the fourth best feature of the language. Trying to code without a good sum type is something I cannot go back to.

The Common Lisp equivalent of a for loop, DO, lets you define multiple loop variables with init/step forms instead of just 1 like in C. As a result, it's somewhat common to have empty loop bodies and the whole loop logic is in the variable update.

Fun fact about Rust loops: they are expressions and can return a value. If you use break with an argument, that's the return value.

rusts if let and especially match {} are soooo good. its a switch on steroids

i like to eliminate explicit loops by using map or each in janet-lang which applies a function over a provided sequence: (map collects results in an array, each is mostly used for evoking side-effects)

(map inc [1 2 3 4 5]) => @[2 3 4 5 6]

(each inc [1 2 3 4 5]) => nil

because the iteration isnt really the important bit here, it's the operation applied that matters...

oh shoot, forgot cond and case:

cond lets you evaluate an expression, its like a list of else-ifs and case is basically a switch except with the usual dynamic typing going on

https://janetdocs.com/cond

https://janetdocs.com/case

Two suggestions:

1. Is it possible in your language to reduce the number of control loop keywords? E.g., I think that what go does with for to handle all the looping is kind of cute.
2. I find python for...else and while...else statements more useful than I thought I would when I first encountered them. This is just a loop with an else tagged onto it: the else happens if the loop exits normally by its condition becoming false, and doesn't happen if the loop exits because of a break or return. Incredibly useful when you're writing a loop to find something, want to break when you find it, and want to run some code when you didn't find what you were looking for.

And another related idea from go that rust also has that isn't really new control-flow constructs: ditch the parentheses around the condition, but require the braces around the loop body.

I like Python list comprehensions.

Lots of uses including generating and filtering lists.

I'm not a rubyist any more but I've always been a huge fan of x.times from an ergonomics standpoint

One I don’t see here is Clojure’s ‘cond’, which I’m pretty sure is equivalent to chained if-elseif but mush easier to read (at least for me).

Labelled breaks. Otherwise known as "goto that doesn't trigger people". It's a goto where the target can only be the end of a scope you're already inside, e.g.

for (...)
{
  for (...)
  {
    while (...)
    {
      if (...)
      {
        break we_outta_here;
      }  
    }
  }
  we_outta_here:
}

One I've used a lot is Elixir's with operation

with pattern_match <- operation do
  # ...ops
else
  negative_match_1 -> 
    # ...other ops
  negative_match_2 ->
    # ...other other ops
end

If the positive condition matches a pattern (or patterns, comma separated in the with section) from the output of a function or pattern match, then run in the do block, otherwise, try and match on anything that exists in the else block and run code there.

Surprised that nobody has mentioned call-with-current-continuation in Scheme yet. It’s the mother of all control flow structures. You can use it to implement exceptions, early return, suspendible coroutines… it’s one of the reasons Scheme is so delightfully minimal (perhaps even pathologically minimal). Haskell also provides them, as they fall out fairly easily when you have lazy semantics, but the docs warn that “abuse of continuations can produce code that is impossible to understand or maintain,” which is in my experience totally valid.

Streams

My personal favorite is a concatenative-style while. It comes in many flavors, but the important part is that unlike C-style while () {} or do {} while () you can have logic both before and after the predicate check. This is similar in spirit to break, but still only allows a single breakpoint in the loop which helps visibility, and actually allows rewriting many break usecases without the problematic keyword. No matter if its Factor's [ pred ] [ body ] while or Forth's BEGIN pred WHILE body REPEAT or even Quackery's [ pred while body again ].

TIL'd about catch when in C# and think it's very nice! Snippet from docs:

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Console.WriteLine(MakeRequest().Result);
    }

    public static async Task<string> MakeRequest()
    {
        var client = new HttpClient();
        var streamTask = client.GetStringAsync("https://localHost:10000");
        try
        {
            var responseText = await streamTask;
            return responseText;
        }
        catch (HttpRequestException e) when (e.Message.Contains("301"))
        {
            return "Site Moved";
        }
        catch (HttpRequestException e) when (e.Message.Contains("404"))
        {
            return "Page Not Found";
        }
        catch (HttpRequestException e)
        {
            return e.Message;
        }
    }
}

Prolly not my favourite though. That'd be the else statement on Python loops that others have mentioned.

Oh, python

Oh that's neat! an "if/else" where the else has to leave in some way - makes it easier to scan code below the inner-most indentation and see what's going to happen.