consider the following command:
overandover(a, b, c, d, e)
that, as long as "a" is true, keeps executing "e", with "b" initially defined as "c" (*) and then changed to "d" at every iteration;
for example, a simple infinite counter would be: overandover(True, a, 0, a+1, print(a))
Would this command be enough to write every kind of program, assuming all other ways of making definitions and cycles are forbidden?
(*) both single values and whole functions can be defined this way
top tier taste, op
thanks (you talking about the pic or the command?)
lol no
what do you mean "no"?
can you give us some working loop example please. This is too much for me to imagine. Sounds nice and I would need to make an example myself to see it.
That's a good one. That "whole function" thing seems to be the key.
What manga is that?
Nvm found it (it's hen na nee-san if anyone is wondering)
How did you reach this conclusion? What's the reasoning behind it?
it doesn't evaluate arguments before passing them to the command?
That's just a weird for loop and yes, while loop programs are turing complete.
>can you give us some working loop example please. This is too much for me to imagine. Sounds nice and I would need to make an example myself to see it.
I already wrote one in the opening post:
>overandover(True, a, 0, a+1, print(a))
This is basically the same as:
>a=0
>while True:
> a=a+1
> print(a)
>That's just a weird for loop and yes, while loop programs are turing complete.
Does that even works if it's the only way to define stuff? (i.e.: no "=" and no "def")
define 'print(a)' using overandover
Can e be replaced with another instance of overandover? If so, then probably yes.
I don't see a way to control the "a" condition, so no, that wouldn't be turing complete.
So, I think if the following were true, you could maybe implement a brainfuck interpreter using overandover:
1. There exist both input and output primitives.
2. There exists a means to perform overandover more than once. One means of doing this might be to allow it to be used not only in the execution stage, but also in the variable assignment stage, where for instance c is assigned to the final value c of the next overandover statement.
3. There exists a means to dereference memory/tape
Of course it can, because you can write anything as e, you don't even need the other parameters.
You say "assuming all other ways of making definitions and cycles are forbidden?", but it's not clear what you mean by this. For example you use print in your example, so you're allowed to define external functions after all?
>Does that even works if it's the only way to define stuff?
You ddin't the define the exact semantics of what e a are limited to. If you can do arbitrary calculations, it's 100% turing complete, if not depends on what calculations you allow.
>overandover(a, b, c, d, e)
>that, as long as "a" is true, keeps executing "e", with "b" initially defined as "c" (*) and then changed to "d" at every iteration;
ah wait, I forgot to add some things:
the "b, c, d" part
could be repeated again for any number of variables you intend to use, for example:
>overandover(b>0, a, 0, a+1, b, 100, b-1, print(a,"+",b,"=",a+b))
that prints:
>1+99=100
>2+98=100
>3+97=100
>4+96=100
>5+95=100
(etc...)
>99+1=100
then stops.
Also, since there is only 1 "e" at the end, in order to do more than simply 1 command at a time, you can group varius commands into a single one using "allofthis":
>allofthis(a, b, c, ...)
means:
>execute a, then b, then c, etc...
so
>You say "assuming all other ways of making definitions and cycles are forbidden?", but it's not clear what you mean by this.
I mean that using "overandover" becomes the only way to do definitions, variable assignment and cycles. There are no more "while", "for", "def", "=", etc...
For example, you could no more write stuff like: >a=whatever
or:
>def a: whatever
instead you'll have to put "a" and "whatever" as arguments in the "overandover" command