3 ms·

Are you saying recursion creates "self sustaining computing blocks" ? What does that mean and how does it do it? that will thread themselves as see fit.* Wha

Are you saying recursion creates "self sustaining computing blocks" ? What does that mean and how does it do it? that will thread themselves as see fit.* What does this mean? In a way it's more encapsulating than languages preaching encapsulation. Recursion does this? Are you talking about not depending on a stack structure in this specific instance or something else?

agumonkey 3y ago
I'm trying to make my ideas clearer but I'm not sure it will be :) > Are you talking about not depending on a stack structure in this specific instance or something else? - using recursion involves functions as basic block of logic, that represent sub-parts of a domain - often creates finite set of self dependent functions - all you do is call and pass other functions, that will call each others > In a way it's more encapsulating than languages preaching encapsulation. If you consider `map` or `fold` these create opaque functional processes that operate very automatically. It's all inductive logic at work to me. On the other hand in OO you needed (until very recently) to create iterators and empty structure to modify step by step. > Are you talking about not depending on a stack structure in this specific instance or something else? PEG parsing where the monadic flavor replaces an externally managed stack ps: maybe i'm still too high on lambda calc
- CyberDildonics 3y ago
  using recursion involves functions as basic block of logic, that represent sub-parts of a domain That's what functions do. often creates finite set of self dependent functions This doesn't have anything to do with recursion. all you do is call and pass other functions, that will call each others You this doesn't have anything to do with recursion. If you consider `map` or `fold` these create opaque functional processes that operate very automatically. I think you mean, they iterate for you. They don't use recursion. On the other hand in OO you needed (until very recently) to create iterators and empty structure to modify step by step. I really don't understand all this. You know most iteration is done with a for loop right? PEG parsing where the monadic flavor replaces an externally managed stack This seems like you're trying to write a satire of someone soaked in haskell. Everyone is else is just writing for loops and moving on.
  - agumonkey 3y ago
    > This doesn't have anything to do with recursion. recursion is compressing the domain so small it eats itself, crafting a small set of function is mirroring this, kinda like grammars > You this doesn't have anything to do with recursion. > I think you mean, they iterate for you. They don't use recursion. afaik map and fold were defined recursively ... foldl f z (x:xs) = foldl f (f z x) xs albeit accumulative recursion (maybe that's what you mean by iterating) > I really don't understand all this. You know most iteration is done with a for loop right? that was what i was pointing at, iterators are not encapsulated enough > This seems like you're trying to write a satire of someone soaked in haskell. Everyone is else is just writing for loops and moving on. I'd appreciate if you didn't make it personal. Also, you forgot ocaml, lisp, prolog.
    - CyberDildonics 3y ago
      recursion is compressing the domain so small it eats itself, crafting a small set of function is mirroring this, kinda like grammars I don't think this means anything. At best it's a completely abstract claim with nothing backing it up. It isn't "compressing a domain" to do iteration differently. afaik map and fold were defined recursively Fundamentally they are useful because the do the iteration for you. Internally it doesn't matter if the iteration is done in a roundabout way with recursion, they aren't about recursion and don't really have anything to do with them, just because some language decides to do iteration with recursion. that was what i was pointing at, iterators are not encapsulated enough You keep saying iterators, I keep saying iteration, but the only difference here is that the recursive version hides the accumulation in the arguments on the function. There isn't any more encapsulation, just a variable moved into the function argument. The brevity is from haskell's type deduction, not recursion.
      - agumonkey 3y ago
        Grammars are not iteration concepts. Map doesn't do iteration. It's not about Haskell.
        3y ago

agumonkey 3y ago

I'm trying to make my ideas clearer but I'm not sure it will be :) > Are you talking about not depending on a stack structure in this specific instance or something else? - using recursion involves functions as basic block of logic, that represent sub-parts of a domain - often creates finite set of self dependent functions - all you do is call and pass other functions, that will call each others > In a way it's more encapsulating than languages preaching encapsulation. If you consider `map` or `fold` these create opaque functional processes that operate very automatically. It's all inductive logic at work to me. On the other hand in OO you needed (until very recently) to create iterators and empty structure to modify step by step. > Are you talking about not depending on a stack structure in this specific instance or something else? PEG parsing where the monadic flavor replaces an externally managed stack ps: maybe i'm still too high on lambda calc

CyberDildonics 3y ago
using recursion involves functions as basic block of logic, that represent sub-parts of a domain That's what functions do. often creates finite set of self dependent functions This doesn't have anything to do with recursion. all you do is call and pass other functions, that will call each others You this doesn't have anything to do with recursion. If you consider `map` or `fold` these create opaque functional processes that operate very automatically. I think you mean, they iterate for you. They don't use recursion. On the other hand in OO you needed (until very recently) to create iterators and empty structure to modify step by step. I really don't understand all this. You know most iteration is done with a for loop right? PEG parsing where the monadic flavor replaces an externally managed stack This seems like you're trying to write a satire of someone soaked in haskell. Everyone is else is just writing for loops and moving on.
- agumonkey 3y ago
  > This doesn't have anything to do with recursion. recursion is compressing the domain so small it eats itself, crafting a small set of function is mirroring this, kinda like grammars > You this doesn't have anything to do with recursion. > I think you mean, they iterate for you. They don't use recursion. afaik map and fold were defined recursively ... foldl f z (x:xs) = foldl f (f z x) xs albeit accumulative recursion (maybe that's what you mean by iterating) > I really don't understand all this. You know most iteration is done with a for loop right? that was what i was pointing at, iterators are not encapsulated enough > This seems like you're trying to write a satire of someone soaked in haskell. Everyone is else is just writing for loops and moving on. I'd appreciate if you didn't make it personal. Also, you forgot ocaml, lisp, prolog.
  - CyberDildonics 3y ago
    recursion is compressing the domain so small it eats itself, crafting a small set of function is mirroring this, kinda like grammars I don't think this means anything. At best it's a completely abstract claim with nothing backing it up. It isn't "compressing a domain" to do iteration differently. afaik map and fold were defined recursively Fundamentally they are useful because the do the iteration for you. Internally it doesn't matter if the iteration is done in a roundabout way with recursion, they aren't about recursion and don't really have anything to do with them, just because some language decides to do iteration with recursion. that was what i was pointing at, iterators are not encapsulated enough You keep saying iterators, I keep saying iteration, but the only difference here is that the recursive version hides the accumulation in the arguments on the function. There isn't any more encapsulation, just a variable moved into the function argument. The brevity is from haskell's type deduction, not recursion.
    - agumonkey 3y ago
      Grammars are not iteration concepts. Map doesn't do iteration. It's not about Haskell.
      - 3y ago