Macros! TW blocks that compile to scratchblocks

[OceanIsEndless]

Macros!

Hello, I’m new here, and I am curious as to if there is (or could soon be) a way to have macros in extensions!

TL;DR

what this person is suggesting is custom extension blocks that compile to vanilla scratch blocks

Plz add the ability to put special blocks which will turn into scripts at compile time into custom extensions. Thanks! THE END

Introduction

Basically, say I wanted to create the following blocks for a custom extension:

I know that these are already featured in existing TurboWarp extensions. However, I want to be able to use these custom TurboWarp blocks in Scratch. Fortunately, there are pretty easy workarounds for these blocks:

However, nobody wants to have to make their code into an unreadable mess such as this:

Rant

Yes, I know strings exist. However, this is just a very simple example here, and there are plenty more. Additionally, writing the word "true" actually behaves differently than the actual boolean true, and writing the number 1 is still kind of unreadable. But I did not come here to argue with you about the usefulness of this example anyway. >:(

What I’m proposing is, there should be a way to have TurboWarp blocks be automatically converted to their Scratch counterparts at compile time.

What a Macro Is

Yes, we have "My Blocks", but they can be limiting in functionality, and macros are a whole different concept. You see, a custom block is a script which executes at runtime, its code being referenced by other scripts. A macro, on the other hand, is a script which runs at compile time. It produces blocks which are injected into the script wherever the macro is being used. The macro is not included in the script, but rather the blocks that the macro produces are. Macros, at their most basic, are simply a shorthand way of writing blocks or scripts, but with some custom logic, they can be much more than that. Macros are really just extension blocks that turn into ordinary scratch blocks, which can then be run by TurboWarp, and better yet Scratch.

Edit:

So I realized that the way I explained it here was kind of unclear. So to clarify- macros are "custom extension blocks that compile to vanilla scratch blocks", THANK YOU @CST1229 for that incredibly clear statement which pretty much sums up this entire topic lol.

Uses

Macros have a GREAT potential for projects. Some use cases include:

• Readability! You can look at it and actually know what it does! Technically only in TurboWarp, as the compiled Scratch output would be using the workarounds, however it would still provide for a greatly improved programming experience!
• Pre-Processing! Process block code ahead of time using JavaScript in whatever way that best suits your project’s needs!
• Evaluate things ahead of time! Do it so that your project doesn’t have to! Process things that need processing!
• Storage! Store your files elsewhere (on a server, rather than hardcoding them) and fetch them at compile time! You may have to handle cases where you can’t access the file though.
• DRY! Don’t Repeat Yourself! Macros technically repeat, but at least they’re much easier to write!
• Convenience! Speed up your workflow with macros! It makes script-making as easy as dragging a block out of the palette!

Yes, I know that this sounds largely like a convenience feature so far, but I encourage you to read to the end, as macros can actually be quite a powerful tool.

Examples

Simple Example

Here’s one of the simpler examples:

scratchblocks

multiply [my variable v] by (3) :: variables // TurboWarp Macro



set [my variable v] to ((my variable) * (3)) // Scratch Workaround



when I receive [5x BOOST! v] // Example Script

say [WEEEEEEEEEEEEEEEEEE]

multiply [speed v] by (5) :: variables // TurboWarp Macro



when I receive [5x BOOST! v] // Compiled Output

say [WEEEEEEEEEEEEEEEEEE]

set [speed v] to ((speed) * (5)) // Scratch Workaround

The macro shown off above would be a shorthand way of multiplying a variable by a certain amount. Doing this with My Blocks would be no easy feat, as you cannot programmatically determine which variable to set in ordinary Scratch. However, since macros run at compile time rather than at runtime, using some extra JavaScript, the macro can magically transform itself into ordinary block code based off of its arguments before it gets sent to the scratch-vm. Do you see what I’m getting at now??? :P

Complex Example

But macros can do WAY more than just that. Here’s some more complex examples:

<insert some more complex examples here because I’m too lazy to put them here… sorry! ZzzZZZzzZz… I’m tired, OK?>

For real though, the possibilities with this are great. For example, one could program a reporter macro that fetches a file from a server and converts it into a format that your project can use at runtime. Or, one could create a macro for checking the type of a value. OR, you could even make a macro of macros. WHO KNOWS?!?!?!?

I’ve spent a lot of time writing this, OK? Gimme a break…

There are a million other examples that I could give you, but I think that you should be getting the point by now. :>

Insertions

It would be cool if macros could also add statements around them, like so:

This macro asks the user for confirmation as a boolean. To ask the user, it inserts an ask () and wait block before the statement that the macro was used in. This allows for more complex reporter macros with multiple steps to them!

Implementation

I think that macros could be added in one or more of the following ways:

1. Additional options specifically for making macros™️ inside of custom TurboWarp extensions
2. Packager settings for macros (no clue how that would work or what it would do, but it’d be cool anyhow)
3. "My Macros" category/special extension similar to My Blocks, but for macros (might be asking a little too much here, but we’ll see :)

I think that the first and third options, specifically the first (adding additional options for macros to custom extensions) would be the most viable and practical. A macro would be defined using JavaScript in a similar way to an ordinary block, the main difference being its logic would be called at compile time, and it would have to somehow be able to produce the "compiled" code for itself (or perhaps even modify the code around it for more complex macros). This could require some major reworking, however I’m sure that if anyone can do it, it’s you. :D

There may have to be a separate option when exporting a project from TurboWarp so that one can choose whether or not to download the file with the macros included in it or with the macros compiled. It’s clear that a lot would have to happen to get macros added into TurboWarp, but I hope that we can iron all that stuff out in order to create an amazing, much-needed (well, maybe you didn’t) original (don’t quote me on that) feature that will greatly change the idea of block-programming as we know it!

Notes

• When I say "compiled" here, I don’t mean the compiled JavaScript code that TurboWarp produces, but rather the scratchblocks that the macro would produce. When I say "compile time", I mean either before a project is executed or before a project is saved as a file.
• Macros are by no means a replacement for custom blocks, nor are custom blocks a workaround for macros. Both have their own incredible uses and can coexist peacefully.
• Macros would probably be reserved for unsandboxed extensions. Being able to modify a program’s scripts may be a bit too powerful for the sandbox. Although I guess if done right it could also be available to sandboxed extensions... I don’t know man XD
• Macros can have multiple steps to them. I don’t want this to just be a block switcheroo; I want this thing to create whole SCRIPTS using just ONE BLOCK!!! No clue how to make any of this work, I hope you all can figure that out for me. I just had an idea, and I’m leaving the adding-it-in part up to you.
• I haven’t made an issue for this yet. I was kind of hoping that somebody else could do that for me, as this is just an idea I had and I’m not exactly sure how it would be incorporated into TurboWarp yet. I just want to get the discussion rolling first so that we can figure out how exactly macros would really work before we go about implementing them. Hopefully you understand. :)
• Sorry for any mistakes! If you couldn’t tell, this thing took me an eternity to write. I may have said something incorrectly or not explained something well enough. Feel free to ask questions! Although I can’t guarantee that I’ll answer XD. I’m new to GitHub and posting on it, so hopefully I can figure all that stuff out. I’ve been using TurboWarp for a long long while now, I just haven’t bothered saying anything or contributing really until this idea came to my brain. I hope you all find this a good idea too!
• Macros are really cool. I hope you've learned that by the end of this post. ;P

Conclusion

Adding macros to TurboWarp would create new and exciting possibilities for Scratch projects, and would open the door to a whole new level of complexity in what started as a simple block-based programming language. I am exhausted after writing all of this, so I’ll leave the rest of the discussion to you guys. I am excited to hear what everybody has to say about this, and thanks for reading. :]

…

Thank you for coming to my TED Talk.

[namelessisbackbutnottodobadthingsiswear]

I've though about similar things in the past, however the Scratch Team likely wouldn't take to fondly to it. Specifically, there's a clause in the Terms of Use (section 4.4) that prohibits uploading projects that cannot be run on Scratch. It's different for projects that simply aren't powerful enough for Scratch, given with enough time and sacrifice they can run on the website, however designing projects specifically to run in TurboWarp and not Scratch would definitely be against TOS.
If your project requires TurboWarp extensions to run, the best course of action is to share it somewhere other than Scratch. Otherwise, you'd be putting your account (and by extension TurboWarp) against the TOS.

[CST1229]

i think what this person is suggesting is custom extension blocks that compile to vanilla scratch blocks, which someone already did: https://github.com/ZXMushroom63/scratch-gui

[OceanIsEndless]

I've though about similar things in the past, however the Scratch Team likely wouldn't take to fondly to it. Specifically, there's a clause in the Terms of Use (section 4.4) that prohibits uploading projects that cannot be run on Scratch. It's different for projects that simply aren't powerful enough for Scratch, given with enough time and sacrifice they can run on the website, however designing projects specifically to run in TurboWarp and not Scratch would definitely be against TOS. If your project requires TurboWarp extensions to run, the best course of action is to share it somewhere other than Scratch. Otherwise, you'd be putting your account (and by extension TurboWarp) against the TOS.

Oof, I guess I needed to be a bit more clear in my post… XD This is kind of a weird idea, and I probably should have explained it better. I’ll try to rephrase it a little.

Firstly, macros are NOT blocks. They are really special functions that turn into blocks. They are not stored in the project that is uploaded to Scratch. They are blocks that produce scripts. I know it’s kind of confusing, so here’s an example:

I want to be able to use this block in Scratch. But for obvious reasons, I can’t do that directly. However, I can work around it like so:

"Macros" are basically blocks which turn into their workarounds. So instead of it being a block in of itself, it turns itself into a block. To put it simply, whenever I use a "macro" in a project, if TurboWarp tries to compile or export it (there would be an option to download it with the macros included or not) then the special block/macro is called. The macro outputs a script which is then substituted where the block once was.

So if I used the macro:

And TurboWarp tries to compile it or export it to Scratch, the macro would turn itself into:

Keep in mind that the script in the editor remains the same. It’s just that whenever the macro is used by TurboWarp (either compiled or downloaded for Scratch), it will simply be interpreted as if it were the script that was returned by the macro (the workaround) rather than the macro itself. So when I upload it to Scratch, instead of the macro being there, it is changed into the vanilla Scratch script instead.

I hope that clears it up a little bit…? Tell me if it needs further clarifying lol. In short, macros are special blocks which turn into scripts wherever they are used. Again, feel free to ask if you still don’t get it. I just want to clear up any confusion I can. :)

[OceanIsEndless]

i think what this person is suggesting is custom extension blocks that compile to vanilla scratch blocks, which someone already did: https://github.com/ZXMushroom63/scratch-gui

That sounds about right. (Hopefully we can still have it in TurboWarp though?)

[snowboyz0825]

I feel like a much better way to describe this would be that they want to add blocks that make building projects easier, such as "Multiply x by 5," and appear that way in the editor, but when saved it saves as "Set x to (x)(5)." Also potentially have a few ways to "Convert" certain extension blocks to a scratch block.

As much as I've wanted this a TON, it's really something you just have to do manually. It's impossible to convert most extension code into scratch code without changing it entirely, and that's something up to the user's discretion. Maybe one day I can understand the SB3 jsons enough to code one for myself, but that doesn't guarantee that it will work for others, and I'm 99% sure that before anything gets added to turbowarp has to work for everyone, and no matter how customizable you make it, it's too much work to make it work for everyone.