[use case] Yuescript as a Single Page Application embeddable language?

[offray]

Hi and thanks for this language! I just discover it yesterday and it's pretty much the response to something I was looking for. I will explain myself in detail here and given that discussions are not yet enabled in this repository, I'll make my comment in the "issues" part, but this is more a conversation on speculative design and the role that Yuescript can play there, to see if can be implemented in practice. If discussions are enabled, I will continue this talk over there (in the "questions" or "ideas" tabs, that are usually available then).

I'm a user of TiddlyWiki, an extensible wiki engine self contained in a single HTML file and I use it for my personal bliki (blog + wiki), my TTRPG group games or research project like one related with the linguistic revitalizing in 4 indigenous communities in the Colombian Amazonas.

And while TiddlyWiki (TW) is a pretty extensible and versatile tool for projects like this, when you start to stretch its usage, you find its limits. To deal with them, we have created TiddlyWikiPharo, a tool that allow us to replicate and import the data model from TiddlyWiki inside the Pharo/GToolkit computing environment, to create interactive documents about how to migrate from Hugo to TiddlyWiki or from WordPress to TiddlyWiki or how to store and visualize the evolution of a wiki (in Spanish). All those use case are possible because we are extending and manipulating TW externally from Pharo/GToolkit, that is where I do almost all of my coding, without dealing too much with the idiosyncrasies of JavaScript and using TW's custom filters and operators language just in the "right amount".

But I would like to extend TiddlyWiki also from inside, without failing into the JS insanity and while keeping the TW's advantages that put it apart from other wiki engines, regarding high malleability, small footprint, the possibility to work offline and a gentle learning curve between being a wiki creator content wiki of creator and functionality.

And given Lua's high embeddability, including the existence of the Fengari JS port of Lua, I made a proposal of a speculative piped Lua variant that would extend TiddlyWiki, with a syntax like the following one (tiddler is TW's name for the unit of content, functionality and/or interface):

tiddlers()
  |> tagged("member")
  |> ramdomized()
  |> template("MemberTemplate")

This is where I imagine that Yuescript could play a role, as already has the proposed syntax and now I wonder:

1. Could I use Fengari instead of WASM to embed Yuescript in a web page?
2. Can I call Lua functionality inside Yuescript (and vice-versa), similarly to what is possible with Fennel?
3. Out of curiosity:
   • Can the example given above be written as a one liner in Yuescript?
   • Have you thought in using Yuescript as a language to program Neovim extensions, again in a similar way to how Fennel is being used?

In this lazy early-year holidays I will slowly familiarize myself with Fengari and Yuescript, and I would like to start implementing something similar to the pipe operator example in Pluto language:

local { http, json } = require "pluto:*"
http.request("https://httpbin.org/get")
|> json.decode
|> dumpvar
|> print
--> {
-->     ["args"] = {},
-->     ["headers"] = {
-->         ["Host"] = string(11) "httpbin.org",
-->         ["User-Agent"] = string(56) "Mozilla/5.0 (compatible; Soup Library; +https://soup.do)",
-->         ["X-Amzn-Trace-Id"] = string(40) "Root=1-65e05b66-6aa8b7c94e7580774a804c24",
-->         ["Accept-Encoding"] = string(13) "deflate, gzip",
-->     },
-->     ["origin"] = string(13) "1.2.3.4",
-->     ["url"] = string(23) "https://httpbin.org/get",
--> }

How can I make something similar using Yuescript?

Thanks in advance any constructive talk and ideas to come,

[pigpigyyy]

Thank you for your thoughtful and detailed post! It’s great to see your interest in exploring how YueScript could enhance your TiddlyWiki projects. Let me address your questions and provide some insights here.

Pipe Operator Syntax in YueScript

YueScript already supports the pipe operator syntax, which matches your example beautifully. Here’s how your use case would look in YueScript:

tiddlers!
  |> tagged "member"
  |> ramdomized
  |> template "MemberTemplate"

:http, :json = require "pluto:*"
http.request "https://httpbin.org/get"
  |> json.decode
  |> dumpvar
  |> print

This compiles directly to Lua like so:

template(ramdomized(tagged(tiddlers(), "member")), "MemberTemplate")
local http, json
do
  local _obj_0 = require("pluto:*")
  http, json = _obj_0.http, _obj_0.json
end
return print(dumpvar(json.decode(http.request("https://httpbin.org/get"))))

You can see that the Lua output retains simplicity and readability, making it seamless to integrate into projects that use Lua-compatible environments.

The one liner version can be written as below, you have to add the braces carefully to prevent ambiguous:

tiddlers! |> tagged("member") |> ramdomized |> template("MemberTemplate")

Fengari and WASM

Since YueScript compiles to Lua, you can use the compiled Lua code directly with Fengari, which is a Lua-to-JS runtime. This allows you to leverage YueScript without needing a WASM compiler. While it’s technically possible to use a WASM compiler for YueScript, I wouldn’t recommend it for web-based projects. YueScript’s macro functionality requires file system access for cross-source analysis, which isn’t easily supported in WASM environments.

YueScript for Neovim Extensions

I haven’t personally used YueScript to develop Neovim extensions, but it’s definitely feasible. YueScript compiles cleanly to Lua, so it should integrate smoothly with Neovim’s Lua-based plugin ecosystem. On a related note, I’ve successfully used YueScript for game scripting in my Dora SSR game engine, which demonstrates its versatility in different domains.

Documentation and Resources

For more details about YueScript features, I recommend checking out the official document https://yuescript.org. It’s a great starting point for exploring YueScript’s syntax, features, and other capabilities.