It’s not just call, so how much is needed to make snap turring complete?

I tried myself a few times, but I always ran into tons of issues

the issues

Issue 1, run:
using call with stack blocks works but always gives an error unless there is a report at the end

Issue 2, join:
join is an essential function in metaprogrammming along with split, both of these functions are impossible to preform

Issue 3, lists:
You can make lists using vardradics, but any other function related to lists are impossible to create

Issue 4, math:
Without at the very least division and addition it is impossible to preform math functions

Issue 5, comparisons:
Without equal to, greater than, and add. you cannot recreate comparison operations

Issue 6, literally everything related to not data:
Every block in the following categories,
Are literally impossible to recreate

With all this given it is obviously impossible to recreate all of snap, or even just make snap turring complete with only call and make a block. But this brings up another question.

What is the minimum amount of blocks needed to make snap turring complete, or remake all of snap?
This is where you come in, obviously I’m not going to know how to work around some blocks. So if you know any workarounds please state them!

(You can use HTML for Italics and Formatting: <i></i>)

Snap! is Turing complete. My guess for the minimum subset is Variables/Lists and Operators (maybe even just Operators with short-circuiting in and and or).

Yes I know it is, I’m saying just how much could you strip down snap for it to still be Turing complete (by that I mean remove as many blocks as possible)

can make variables so that solves that issue

How would adding and dividing be possible

(() + ())
(() / ())
I think lambda calculus is Turing complete, so Snap! could be stripped to that fundamental level. Brian, can you confirm this (I'm assuming he is reading this, so I didn't tag him)?

@18001767679 had a fun time playing with it:

what does turing complete mean? Seriously im doing a history project on computers

Turing completeness is a mathematical concept. As such, it leaves out lots of things that real programming environments have to do, most importantly about input and output. Turing machines don't worry about things like printing some text in red, or in italics. They don't have a filesystem.

What Turing machines are good at is computing functions. And yes, they can implement math functions, JOIN, and the other functions in that list, in terms of more fundamental operations. And yes, all you need to make a Turing complete language, i.e., a language that can compute any function that a Turing machine can compute, are gray rings (lambda) and CALL. (Note that I didn't say Make a Block. These functions don't have names attached. The only way to give a function a name is to use it as the input value to some other procedure, so that the corresponding formal parameter serves as a name for the function inside the body of that other procedure.)

It's 2am so I'm not saying any more about this tonight.


ill get on to making some sort of list of needed blocks

Here's a brief Snap! tutorial on arithmetic with only λ and CALL:
Church.pdf (1.3 MB)

I guess you could start with an upper bound by making a simple turing machine without any regard towards size and then minimize it from there?
Edit: sorry for the necropost, didn't notice the date on this

Just noticed this: It should say "can solve any solvable computational problem." Some problems can't be solved (by a Turing machine or any other computational mechanism, including brains).