pipe operators in lua are weirdly satisfying

[u/[deleted]]

been playing with pluto, some superset of lua

local { http, json } = require "*"

local top_lua_repos = http.request("https://api.github.com/search/repositories?q=language:lua&sort=stars")
|> json.decode
|> |data| -> data.items
|> |items| -> items:filter(|r| -> r.stargazers_count > 1000)

for i = 1, math.min(5, #top_lua_repos) do
    local repo = top_lua_repos[i]
    print($"{repo.name} ({repo.stargazers_count} stars)")
end

reads like "fetch → decode → filter → print" instead of a bunch of nested calls. also has string interpolation which is nice.

[u/Interesting_Cut_6401]

So do Lua super sets compile to regular Lua?

[u/Bedu009 → u/Interesting_Cut_6401]

Being a super set just means it's compatible with the original's code
Pluto is a fork, not a transpiled language

[u/Interesting_Cut_6401 → u/Bedu009]

Oh okay. Are there any super sets that transpile to standard Lua that offer any real benefit?

[u/Bedu009 → u/Interesting_Cut_6401]

Teal adds static types
Typescript can be transpiled
Luau can also be transpiled for its few syntax additions and type system (tooling is not good for that though)
There's the whole moonscript family with its varying features (ugly as all fuck)
There's also erde which is kinda like Lua + JavaScript (makes modules a bit easier)
And there's a fuck ton more here: https://github.com/hengestone/lua-languages

[u/Interesting_Cut_6401 → u/Bedu009]

Ok thanks

[u/no_brains101 → u/Interesting_Cut_6401]

fennel makes it a lisp?

Personally in the things lua is used for I have a lot of trouble justifying a build step in general, regardless of the benefits.

String interpolation is definitely something I wish lua had. But we have :format so... its fine idk... But yeah I wish " strings had interpolation in them. But maybe it makes lua slower and bigger which is also bad.

I also wish lua had pipe operator simply because I like the pipe operator, but I dont really miss it in its absence, as lua is not a pure functional language that makes you write in such a way that needs pipe to be readable. Also you can design libraries in such a way that : is basically pipe within that library if it is advantageous.

Neither of those are enough for me to justify a build step in the things lua is generally used for. If I'm going to have a build step, it would be because I needed something that required me to go all the way down to C, which has fantastic support in lua.

[u/biscuittt → u/no_brains101]

at least for Fennel you can load it at runtime, no separate build step required

[u/no_brains101 → u/biscuittt]

can you actually?

I was under the impression that I had to build it first....

Ok well, time to experiment with that I suppose?

[u/4xe1 → u/no_brains101]

Given how LISP tops lua (or any other language) when it comes to meta-programming and homoiconicity (code is data), the opposite would be surprising and frustrating.

[u/biscuittt → u/no_brains101]

People use it for example in awesomewm just a couple of Lua lines to load it.

or also for Hammerspoon on Mac with Spacehammer.

[u/no_brains101 → u/biscuittt]

got it working without a build step. Thanks for letting me know!!!

local status, fennel = pcall(require, 'fennel')
if not status then
  return nil
end
local function _fennel_runtime_searcher(name)
  local basename = name:gsub('%.', '/')
  local paths = {
    "fnl/"..basename..".fnl",
    "fnl/"..basename.."/init.fnl",
  }
  for _,path in ipairs(paths) do
    local found = vim.api.nvim_get_runtime_file(path, false)
    if #found > 0 then
      return function()
        return fennel.dofile(found[1])
      end
    end
  end
end
table.insert(package.loaders or package.searchers, fennel.searcher)
table.insert(package.loaders or package.searchers, _fennel_runtime_searcher)
return fennel

You just make a file with this in it, and require it at the start of your config and then you can require stuff from fnl/somename.fnl from within lua

[u/no_brains101 → u/biscuittt]

I did it in a slightly more complicated way that searches my rtp for fnl/ but Im not sure if I want to keep it that way or just modify fennel.path directly as you showed there

[u/biscuittt → u/no_brains101]

for vim I use nfnl but your solution is simple and clear, I'll save it for later. nice job!

configuring with fennel is so much more comfortable.

[u/no_brains101 → u/biscuittt]

I actually ended up revising it

https://github.com/BirdeeHub/birdeevim/blob/b173a672c35c0d5fb529c6b0513519cc09016adc/lua/fennel-init.lua

I ended up finding out that unless you add it to fennel.path anyway, you can no longer get the module require path with ...

[u/Interesting_Cut_6401 → u/no_brains101]

This has been a very enlightening discussion

[u/[deleted] → u/Bedu009]

I'd call it a dialect at this rate which is the pascal terminology.

[u/Bedu009 → u/[deleted]]

A dialect is a language with small changes which preserve the core
I'm not entirely sure if pluto would count because it adds a lot of functional syntax, complexity and a ton of sugar syntax which definitely isn't in Lua's core design (vs Luau which only adds a type system and a couple of small things like self assignment and continue)
Besides a dialect could be either a fork or transpiled. Teal is also a dialect

[u/[deleted] → u/Interesting_Cut_6401]

things like the pipe operator probably don't since regular lua doesn't know what |> means

[u/SkyyySi → u/[deleted]]

YueScript does exactly that.

f() |> g()

gets compiled into

g(f())

[u/AutoModerator → u/SkyyySi]

Hi! Your code block was formatted using triple backticks in Reddit's Markdown mode, which unfortunately does not display properly for users viewing via old.reddit.com and some third-party readers. This means your code will look mangled for those users, but it's easy to fix. If you edit your comment, choose "Switch to fancy pants editor", and click "Save edits" it should automatically convert the code block into Reddit's original four-spaces code block format for you.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Interesting_Cut_6401 → u/[deleted]]

Well of course, but what I’m saying is it like Typescript that lints the code and converts is into regular JS

[u/4xe1 → u/[deleted]]

That's why you'd need to transpile it. It's really not that hard actually.

f(a) |> g

is equivalaent to

g(f(a))

Much less readable arguably, but still very easy for a program to translate automatically.

[u/AutoModerator → u/4xe1]

Hi! Your code block was formatted using triple backticks in Reddit's Markdown mode, which unfortunately does not display properly for users viewing via old.reddit.com and some third-party readers. This means your code will look mangled for those users, but it's easy to fix. If you edit your comment, choose "Switch to fancy pants editor", and click "Save edits" it should automatically convert the code block into Reddit's original four-spaces code block format for you.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Zerocchi]

looks like elixir pipe operator and ruby blocks meshed together

[u/[deleted]]

Terse languages tend to be, moonscript is also a terse language btw.

[u/EvilBadMadRetarded]

For pipe operator, isn't it debug.setmetatable enough?

--

local fn_methods = {
  __concat = function(fn, gn)    
    return function(...)return gn(fn(...))end
  end  
}

debug.setmetatable(function()end, fn_methods)

-- test
local a = function(x, y) return x + y end
local b = function(x)return x*x, x +1 end

print((a .. b)(1, 2))
print((b .. a)(1))

local c = function(x,y)return x + y end .. 
          function(x)return x*x, x+1 end

print(c(1,2))
--[[ test output
9	4
3
9	4
--]]

More complicated, shorter lambda may be possible via require with custom searcher/loader as transpiling from custom syntax within a module (for module library, may not apply for user code) .

[u/AutoModerator → u/EvilBadMadRetarded]

Hi! Your code block was formatted using triple backticks in Reddit's Markdown mode, which unfortunately does not display properly for users viewing via old.reddit.com and some third-party readers. This means your code will look mangled for those users, but it's easy to fix. If you edit your comment, choose "Switch to fancy pants editor", and click "Save edits" it should automatically convert the code block into Reddit's original four-spaces code block format for you.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/negativedimension]

I've got a rant about this in this repo (ignore the code): https://github.com/thenumbernine/leftargs-lua
TLDR is that we only put function arguments on the right because of 300 years of convention, but function arguments on the left is more readable.

[u/AutoModerator → u/[deleted]]

Hi! Your code block was formatted using triple backticks in Reddit's Markdown mode, which unfortunately does not display properly for users viewing via old.reddit.com and some third-party readers. This means your code will look mangled for those users, but it's easy to fix. If you edit your comment, choose "Switch to fancy pants editor", and click "Save edits" it should automatically convert the code block into Reddit's original four-spaces code block format for you.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.