Aren’t those things just convenience wrappers around loops? I don’t understand the fundamental difference.

They're loops with stronger semantics (in other words, they're more restrictive (in other words, they're easier to reason about)), in the same way that loops themselves are `goto` with stronger semantics.

> they're more restrictive (in other words, they're easier to reason about))

That's a great point. Often in my programming career, I've used the rule of least power[1]. In the looping/flow control ladder, I'd list descending

* JMP/GOTO

* for/while

* map/filter/reduce

If a problem only needs a map, using a for introduces needless complexity(ie: state). Personally, I think we have a pedagogical problem in that we teach people loops first and people confuse what they've been taught first with what is a reasonable choice[2].

For completeness, recursion has it's own ladder

* PUSH,POP,JMP

* function call

* recursion schemes[3]

Side note: recursion schemes have an enormous hurdle to adoption in that mathematicians got there first and the naming are so off putting that no one will take you serious if you bring up even simple schemes like anamorphism and catamorphism. Folks would rather accept a FactoryFactoryFactory over a futumorphism.

1. https://en.wikipedia.org/wiki/Rule_of_least_power

2. The other side of this coin is, "Why would they teach me a bad way of doing something?"

3. https://github.com/passy/awesome-recursion-schemes

Viewing loops as a stronger GOTO is a really interesting perspective which makes sense to me, thanks for the insight.

I see them as a restricted (so, less powerful than a goto). That’s why they are better. Perhaps that’s what you meant when you said “stronger”

Aren’t loops just wrappers around goto and if statements?

The claim is that by expressing programs in terms of these array primitives, you (a) can have those primitives be super optimised and (b) better see what the program is actually about without worrying too much about eg what names to give all the loop counters, all the other intermediate state associated with iteration, etc.

Most platforms make some kind of loop into a primitive, but in Common Lisp

  (dotimes (i 10)
    (print i))

is just a predefined macro that might expand into primitives like

  (BLOCK NIL
    (LET ((I 0))
      (TAGBODY
        #:LOOP-2867
        (IF (>= I 10)
          (GO #:END-2868))
        (PRINT I)
        (PSETQ I (1+ I))
        (GO #:LOOP-2867)
        #:END-2868
        (RETURN-FROM NIL (PROGN NIL)))))

Loops themselves can be considered just convenient wrappers around goto. The point is to restrict the variety (structured programming) and make spaghetti unreadable code less likely.

Using higher-order functions instead of loops is similar e.g. loops:

    # input_ =  "1,2,3"
    numbers = (int(d) for d in input_.split(","))
    product = 1
    for n in numbers:
        product *= n

can be replaced:

    numbers = map(int, input_.split(","))
    product  = reduce(mul, numbers, 1)

Loops (Eg: in C) are a much “wilder” construct — something special could happen for i=17 or successive iterations might overwrite values, etc. more restrictive “tamer” versions help programmers & computers reason about the code.

Sure, and C is a convenience wrapper around assembly and assembly is a convenience wrapper around toggling octal codes on your front panel and punching in octal code is a convenience wrapper around rewiring vacuum tubes and relays and that's a convenience wrapper around mechanical cogs and that's a convenience wrapper around an abacus.

But it's a different paradigm than procedural programming and embracing it might lead to a different mind set.

Lol. IMO the difference between an C and Assembly (as between vacuum tubes and the abacus) is really a difference in power, since it allows the same program to be implemented on different architechtures. It's only fair to start calling things convenience wrappers once you get past C. And often enough, an abstraction aimed at convenience leads to a reduction in expressive power.

When loopless constructs are a design principle of a language, they become much more than just a convenience wrapper.

each is a necessary evil of K. It can often be avoided by more thoughtful use of vectors.

I would claim that SQL is the ubiquitous loop-less language.

Once you get into it, you start realizing what manipulating data is all about. And most of what you need can be expressed without for loops. And then the step from SQL to Scala is not long.

For me imperative languages are like Lego. SQL is like origami. You fold yourself to the solution.

That said, K is obviously one step further in that analogy.

Elm doesn't have loops, just fold/map.

Elm can do iterative recursion, which is a thinly disguised loop without side effects.

I googled "iterative recursion " and couldn't find a definition. So is it judt iteration? And then, what languages don't have iteration?

Primarily K focuses on applying functions to vectors. If using “each” can be avoided, it is.

It’s a wonderful language to work with.