7 ms·

In Scheme, the only way to loop is via recursion. In Clojure, all high level functions and looping macros (for/doseq) are implemented via recursion as well (loo

• mratsim 7y ago
  When you need efficient parallel map or reduction you often go back to low-level C loops wrapped in a pretty map/reduce/array package like numpy or R. I'd argue that Einstein Summation like `C[i, j] = A[i, k] * B[k, j]` is much more natural than any composition of map reduce you may use to describe the loops of matrix multiplication.
  • dan-robertson 7y ago
    Einstein summation for matrix multiplication isn’t really a great example because we have a perfectly good way to describe matrix multiplication without loops or sufficies or anything else: C = AB Rate is multiplication (and matrix-vector multiplication) is easy to denote. Tensor multiplication (well really tensor contraction) is annoying to denote and that is the point of summation notation. Notation is easier when there is less to denote: - Matrix multiplication: only one thing you can do (well you can add to but this distributes) - Tensor multiplication: all you can do is add, tensor product, and contract. First two are easy, last one you add extra notation for. This notation can also express permuting indices but this is the same as multiplication by a particular tensor and contraction so ok to do. - map,reduce,fold,etc. These can do quite a lot but not everything (eg processing multiple and in particular different data structures is often annoying. Processing things out of the usual order is often annoying. Processing eg consecutive elements is often annoying). One gets convenience for common things by making it impossible/hard to express uncommon things. If you see something that looks like map(f,x), you know the size of the input is the same as the size of the output and (hopefully) f acts independently on each element. - loops/tail recursion these give you more power to do things so looking at a loop there are many things that could possible happen and one must look carefully to find which.
    • uryga 7y ago
      > Processing eg consecutive elements is often annoying the only place i saw a higher-order function for this is the K language with its `eachpair` combinator (spelled `':` iirc). i wonder why it isn't more common! (though in Haskell i'd just stick a `tails` somewhere to turn `[a,b,c]` into `[[a,b,c],[b,c],[c],[]]` and map over that)
  • MayeulC 7y ago
    That might be true in some way, but having a map/reduce abstraction could help map the operation on a computing cluster if necessary, or more generally abstractions allow to make use of more complex processing techniques (that take into account cache locality, NUMA, advanced matrix multiplication algorithms [1], etc.). So, I would say that the thing you wrote is easier to understand if you look at the low-level code, but you have to look at it, while you could have the same overview at a high level, which provides a different perspective. In C++, that would be overloading the * operator to perform the loop in a method. It boils down to top-bottom vs bottom-up, I think. And even though I often use the looping technique, I feel like a lot of my code is spent writing these "useless" loops, while caring for the index, boundaries, etc. I really like vectorization as used in Matlab/Octave to deal with that sort of things, and I feel like this is an answer of its own to the topic. [1]: https://en.wikipedia.org/wiki/Matrix_multiplication#Complexity https://en.wikipedia.org/wiki/Matrix_multiplication#Complexi...
• dheera 7y ago
  Scheme has a "do" loop that doesn't require recursion. It's just that the people who generally teach Scheme are hell-bent on recursion rather than irritation.
  • reificator 7y ago
    > It's just that the people who generally teach Scheme are hell-bent on recursion rather than irritation. Freudian slit?
  • chowells 7y ago
    Have you ever looked at how that's implemented? Seems kind of like saying that since it has the y combinator, you never need to use recursion.
• smartstakestime 7y ago
  unless you actually start with these language , then move to loops. Which is really easy. Map/reduce is fundamental to scheme like the closure is fundamental to javascript. Im not sure how many colleges teach it 1st year but Northeastern University uses scheme as the intro language. The professor there wrote the blue book.
  • onychomys 7y ago
    The University of Minnesota also uses it in their very first CS course.
  • LandR 7y ago
    I know of zero universities that use Scheme or any LISP. Most nowadays that I know of start with Javascript. My old university started with C. It now goes straight to javascript.
    • brlewis 7y ago
      Actually I think you do know of more than zero universities, since you replied to a comment that named Northeastern. A sibling comment to yours named another. Here's another: https://cs.brown.edu/courses/info/csci0170/ https://cs.brown.edu/courses/info/csci0170/
    • akavi 7y ago
      Yale started you off with scheme back in 2012. Not sure if they still do, however.
    • lispm 7y ago
      Just close your eyes and when you learn about recursion, closures, serialized data, evaluation, ... in Javascript, then just pretend you are using Lisp with a fancy notation. Even the original developer of Javascript wanted to do some Lisp/Scheme, was hired to do so and ended up with a slightly different language... https://thenewstack.io/brendan-eich-on-creating-javascript-in-10-days-and-what-hed-do-differently-today/ https://thenewstack.io/brendan-eich-on-creating-javascript-i...
  • 7y ago
• tomtomtom777 7y ago
  In this list of loop-special-languages, XQuery also deserves an honorable mention. With the sequence being the root datatype, it makes loops rather implicit. You can write declare function local:formatName($person) { xs:concat($person/@firstName, " ", $person/@lastName) }; and it will format the name of zero, one or many persons. Working with XQuery makes you think differently about iteration and shows how much plumbing we normally use for it.
  • thrownaway954 7y ago
    OMG!!! I remember writing code generators for ColdFusion in XQuery. Total mind shift and, dare I say, ALOT OF FUN!!! It's amazing what XQuery did.
• leshow 7y ago
  Haskell as well uses recursion as it's primary mechanism of iteration.
• agumonkey 7y ago
  What I like about applicative/functional is that it linearize the thinking process. - function arguments represent what imperative programming means as state - each recursive call is a step in the walk toward convergence - every step has to reduce[0] something in the arguments - every step is clearly identified in the recursive call I don't think it is "better" than mutable state + while () { }, but it helps my brain massively. It may also be linked with old research (Turing and others) about expressing program space as a N-dim vector that has to reach a point in this N-dim space. Some people might be able to make sense of complex imperative code, old array/string algorithms are a bit like that, maybe Knuth has some dedicated brain area I don't know of. But all in all, starting with functional may be a better pedagogical space. [0] see htdp, sicp, friedman the <adj> <verb>er books