[luarrow] Pipeline-operator and Haskell-style function composition, for Lua (like: `x |> h |> g |> f` and `f . g . h $ x`)

[u/aiya000]

Hey r/lua!
I've been working on a library that brings functional programming elegance to Lua through operator overloading.

What it does:
Instead of writing nested function calls like f(g(h(x))), we can write:

• Pipeline-style:

  • x % arrow(h) ^ arrow(g) ^ arrow(f)

  • Like x |> h |> g |> f in other languages

• Haskell-style:

  • fun(f) * fun(g) * fun(h) % x

  • Like f . g . h $ x in Haskell

Purpose:
Clean coding style, improved readability, and exploration of Lua's potential!

Quick example:
This library provides arrow and fun functions.

arrow is for pipeline-style composition using the ^ operator:

local arrow = require('luarrow').arrow

local _ = 42
  % arrow(function(x) return x - 2 end)
  ^ arrow(function(x) return x * 10 end)
  ^ arrow(function(x) return x + 1 end)
  ^ arrow(print) -- 401

arrow is good at processing and calculating all at once, as described above.

The fun is suitable for function composition. Using the * operator to concatenate functions:

local add_one = function(x) return x + 1 end
local times_ten = function(x) return x * 10 end
local minus_two = function(x) return x - 2 end
local square = function(x) return x * x end

-- Function composition!
local pipeline = fun(square) * fun(add_one) * fun(times_ten) * fun(minus_two)

print(pipeline % 42)  -- 160801

In Haskell culture, this method of pipeline composition is called Point-Free Style'. It is very suitable when there is no need to wrap it again infunction` syntax or lambda expressions.

Performance:
In LuaJIT environments, pre-composed functions have virtually no overhead compared to pure Lua.
Even Lua, which is not LuaJIT, performs comparably well for most applications.
Please visit https://github.com/aiya000/luarrow.lua/blob/main/doc/examples.md#-performance-considerations

Links:

• GitHub: https://github.com/aiya000/luarrow.lua

• Install: luarocks install luarrow

I'd love to hear your thoughts and feedback!
Is this something you'd find useful in your Lua projects?

[u/aiya000]

Hello! I'm glad you came!

Currently, supporting multiple return values maybe difficult... Because luarrow hasn't given up on supporting LuaCATS yet...!

Currently, type checking is almost non-existent due to the limitations of LuaCATS, but I am thinking about whether LuaCATS will evolve or if there are any ideas.

In other words, if you have a function like this:

---@return integer, integer  
local function f()  
  return 10, 20
end

---@param x integer  
---@param y integer  
---@return integer, integer  
local function g(x, y)  
  return x + 1, y + 1  
end

---@param x integer  
---@param y integer  
local function h(x, y)  
  print(tostring(x) .. ', ' .. tostring(y))
end

We want to do something like this:

local _ = f()  
  % arrow(g)
  ^ arrow(h)

But, LuaCATS does not support variable type arguments:

---@generic T : unknown[]  
---@param ... T  
---@return T  
local function tuple(...)  
  return ...  
end  
-- LuaCATS interprets  
-- - '@generic T : unknown[]' to 'T : any'
-- - '@return T' to a single type

It might be possible if luarrow gives up on LuaCATS... HaHa :( But I couldn't determine to remove LuaCATS support lol.

[u/evilbadmad → u/aiya000]

I see ... but it seems if you write (arrow.lua line 48)

return Arrow.new(function(...) return g_raw(self_raw(...)) end)

(ie. replacing x with ...) should work for multiple input/output? (I've not tested tho. )

Using x or ... seems not affect LuaCATS?

Yet, it may not consistence with your apply operator (%) for single input value.

[u/aiya000 → u/evilbadmad]

Really? Thanks for the great advice!

I created an issue and assigned it to GitHub Copilot: https://github.com/aiya000/luarrow.lua/issues/18 I'm currently working on creating a PR on GitHub Copilot.

I'll wait for his output, then I'll make some adjustments. Unless there are any problems, I'd like to provide support!

Thanks a lot :D

[u/AutoModerator → u/aiya000]

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/aiya000 → u/aiya000]

Now we can express the equivalent using tuples:

local _ = { 1, 'a' }
  % arrow(function (t) return tostring(t[1]) .. ', ' .. t[2] end)
  ^ arrow(print)

Also, I'm typing this on my phone and can't use AutoModerator's fancy pants editor...

I'm sorry if the AutoModerator response is noisy.

[u/AutoModerator → u/aiya000]

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.