3 ms·

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

dwb 3y ago
When loopless constructs are a design principle of a language, they become much more than just a convenience wrapper.
kibwen 3y ago
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.
- kelseyfrog 3y ago
  > 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 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 https://github.com/passy/awesome-recursion-schemes
- accrual 3y ago
  Viewing loops as a stronger GOTO is a really interesting perspective which makes sense to me, thanks for the insight.
  - otikik 3y ago
    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”
  - deleted 3y ago
    [deleted]
dan-robertson 3y ago
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.
- erik_seaberg 3y ago
  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)))))
ksherlock 3y ago
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.
- lamerose 3y ago
  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.
ssivark 3y ago
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.
d0mine 3y ago
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)
- deleted 3y ago
  [deleted]
epanchin 3y ago
each is a necessary evil of K. It can often be avoided by more thoughtful use of vectors.

dwb 3y ago

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

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.

kelseyfrog 3y ago
> 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 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 https://github.com/passy/awesome-recursion-schemes
accrual 3y ago
Viewing loops as a stronger GOTO is a really interesting perspective which makes sense to me, thanks for the insight.
- otikik 3y ago
  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”
- deleted 3y ago
  [deleted]

dan-robertson 3y ago

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.

erik_seaberg 3y ago
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)))))

ksherlock 3y ago

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.

lamerose 3y ago
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.

ssivark 3y ago

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.

d0mine 3y ago

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)

deleted 3y ago
[deleted]

epanchin 3y ago

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