Realize that only non library functions get decoded to functions

Author: DynamicCake

src/glua.gleam

@@ -59,6 +59,33 @@ pub type Value
 /// that will return references to the values instead of decoding them.
 pub type ValueRef
 
+/// A decoded lua function
+/// Accepts decoded values and returns decoded values
+pub type LuaFunc {
+  LuaFunc(func: fn(Lua, List(Value)) -> #(Lua, List(Value)))
+}
+
+@external(erlang, "glua_ffi", "is_lua_func")
+fn is_lua_func(a: anything) -> Bool
+
+@external(erlang, "glua_ffi", "coerce")
+fn coerce_lua_func(a: anything) -> LuaFunc
+
+pub fn decode_func() {
+  use then <- decode.then(decode.dynamic)
+  echo then
+  case is_lua_func(then) {
+    True -> decode.success(coerce_lua_func(then))
+    False ->
+      decode.failure(
+        LuaFunc(func: fn(_, _) { panic as "unreachable" }),
+        "LuaFunc",
+      )
+  }
+}
+
+// {NewState, Ret} = Fun(State, Transformed),
+
 pub opaque type Output {
   Output(lua: Lua, refs: List(ValueRef))
 }
@@ -169,17 +196,14 @@ pub fn function(
   f: fn(Lua, List(dynamic.Dynamic)) -> #(Lua, List(Value)),
 ) -> Value {
   // we need a little wrapper for functions to satisfy luerl's order of arguments and return value type
-  wrap_trans_function(f)
+  function_transform(f, default_transformation)
 }
 
 pub fn function_transform(
   f: fn(Lua, List(dynamic.Dynamic)) -> #(Lua, List(Value)),
   transformation: Transformation,
 ) -> Value {
-  case transformation {
-    NoTransform -> wrap_function(f)
-    ProplistTransform -> wrap_trans_function(f)
-  }
+  wrap_function(f, transformation)
   // we need a little wrapper for functions to satisfy luerl's order of arguments and return value type
 }
 
@@ -236,11 +260,7 @@ pub fn userdata(v: anything) -> Value
 @external(erlang, "glua_ffi", "wrap_fun")
 fn wrap_function(
   fun: fn(Lua, List(dynamic.Dynamic)) -> #(Lua, List(Value)),
-) -> Value
-
-@external(erlang, "glua_ffi", "wrap_trans_fun")
-fn wrap_trans_function(
-  fun: fn(Lua, List(dynamic.Dynamic)) -> #(Lua, List(Value)),
+  transformation: Transformation,
 ) -> Value
 
 @external(erlang, "luerl", "decode_list")
@@ -249,21 +269,32 @@ fn do_decode_list(ref: List(ValueRef), lua: Lua) -> List(dynamic.Dynamic)
 @external(erlang, "luerl", "decode")
 fn do_decode(ref: ValueRef, lua: Lua) -> dynamic.Dynamic
 
-@external(erlang, "glua_ffi", "proplist_to_map")
-fn proplist_to_map(a: anything) -> dynamic.Dynamic
+/// Precondition: ONLY luerl decoded terms can be added here or else it will SPECTACULARLY FAIL
+@external(erlang, "glua_ffi", "transform")
+fn transform(a: luerl_value, transformation: Transformation) -> dynamic.Dynamic
 
+/// Internally in luerl, when a `Value` is decoded it has proplists and difficult to decode functions.
+/// This poses some problems; proplists make decoding difficult and erlang functions are hard to decode in gleam.
+///
+/// Glua has decided to greatly improve type safety at a marginal performance cost.
+/// If you wish to remove these transformations for whatever reason, you may use the functions that accepts a `Transformation`.
 pub type Transformation {
-  NoTransform
-  /// Default
-  ProplistTransform
+  Transformation(
+    /// If true, transforms proplists (ex. `[#("key", "value")]`) into dicts
+    proplist: Bool,
+    /// If true, transforms functions to `LuaFunc`s making them callable with glua
+    func: Bool,
+  )
 }
 
+pub const default_transformation = Transformation(proplist: True, func: True)
+
 /// The decoder will always receive a list of values
 pub fn dec(
   output: Result(Output, LuaError),
   using decoder: decode.Decoder(a),
 ) -> Result(#(Lua, a), LuaError) {
-  dec_transform(output, decoder, ProplistTransform)
+  dec_transform(output, decoder, default_transformation)
 }
 
 pub fn dec_transform(
@@ -272,16 +303,9 @@ pub fn dec_transform(
   transformation tf: Transformation,
 ) {
   use output <- result.try(output)
-  let dyn =
-    do_decode_list(output.refs, output.lua)
-    |> dynamic.list()
-
-  let dyn = case tf {
-    NoTransform -> dyn
-    ProplistTransform -> proplist_to_map(dyn)
-  }
-
-  dyn
+  do_decode_list(output.refs, output.lua)
+  |> list.map(transform(_, tf))
+  |> dynamic.list()
   |> decode.run(decoder)
   |> result.map(pair.new(output.lua, _))
   |> result.map_error(UnexpectedResultType)
@@ -292,7 +316,7 @@ pub fn dec_one(
   output: Result(Output, LuaError),
   using decoder: decode.Decoder(a),
 ) -> Result(#(Lua, a), LuaError) {
-  dec_one_transform(output, decoder, ProplistTransform)
+  dec_one_transform(output, decoder, default_transformation)
 }
 
 /// Assume there will be only one item to decode
@@ -641,27 +665,43 @@ fn do_eval_file(
   path: String,
 ) -> Result(#(Lua, List(ValueRef)), LuaError)
 
-pub fn call_function(
+pub fn call_function_ref(
   state lua: Lua,
   ref fun: ValueRef,
   args args: List(Value),
 ) -> Result(Output, LuaError) {
-  do_call_function(lua, fun, args)
+  do_call_function_ref(lua, fun, args)
   |> result.map(to_output)
 }
 
 @external(erlang, "glua_ffi", "call_function")
-fn do_call_function(
+fn do_call_function_ref(
   lua: Lua,
   fun: ValueRef,
   args: List(Value),
 ) -> Result(#(Lua, List(ValueRef)), LuaError)
 
+@external(erlang, "glua_ffi", "call_enc_function")
+fn do_call_function(
+  lua: Lua,
+  fun: LuaFunc,
+  args: List(Value),
+) -> Result(#(Lua, List(ValueRef)), LuaError)
+
+pub fn call_function(
+  state lua: Lua,
+  func func: LuaFunc,
+  args args: List(Value),
+) -> Result(Output, LuaError) {
+  do_call_function(lua, func, args)
+  |> result.map(to_output)
+}
+
 pub fn call_function_by_name(
   state lua: Lua,
   keys keys: List(String),
   args args: List(Value),
 ) -> Result(Output, LuaError) {
   use fun <- result.try(get(lua, keys))
-  call_function(lua, fun.ref, args)
+  call_function_ref(lua, fun.ref, args)
 }

src/glua_ffi.erl

@@ -2,34 +2,23 @@
 
 -import(luerl_lib, [lua_error/2]).
 
--export([coerce/1, coerce_nil/0, coerce_userdata/1, wrap_fun/1, wrap_trans_fun/1, sandbox_fun/1,
+-export([coerce/1, coerce_nil/0, coerce_userdata/1, wrap_fun/2, sandbox_fun/1,
          get_table_keys/2, get_private/2, set_table_keys/3, load/2, load_file/2, eval/2, eval_file/2,
-         eval_chunk/2, call_function/3, alloc/2, proplist_to_map/1]).
-
-% This could be improved on perhaps
-proplist_to_map(Term) when is_list(Term) ->
-    case is_proplist(Term) of
-        true ->
-            maps:from_list([{K, proplist_to_map(V)} || {K, V} <- Term]);
-        false ->
-            case Term of
-                [] -> #{};
-                _  -> [proplist_to_map(E) || E <- Term]
-            end
+         eval_chunk/2, call_function/3, call_enc_function/3, is_lua_func/1, alloc/2, transform/2]).
+
+% Precondition: [[See glua.gleam]]
+transform(Term, {transformation, false, false}) ->
+    Term;
+transform(Term, Settings = {transformation, Proplist, _Funcs}) when is_list(Term) ->
+    Result = [{K, transform(V, Settings)} || {K, V} <- Term],
+    case Proplist of
+        true -> maps:from_list(Result);
+        false -> Result
     end;
-proplist_to_map(Term) when is_map(Term) ->
-    maps:from_list([{K, proplist_to_map(V)} || {K, V} <- maps:to_list(Term)]);
-proplist_to_map(Term) when is_tuple(Term) ->
-    list_to_tuple([proplist_to_map(E) || E <- tuple_to_list(Term)]);
-proplist_to_map(Other) ->
-    Other.
-
-is_proplist(L) when is_list(L), L =/= [] ->
-    lists:all(fun(E) ->
-        is_tuple(E) andalso tuple_size(E) =:= 2
-    end, L);
-is_proplist(_) ->
-    false.
+transform(Func, {transformation, _Proplist, true}) when is_function(Func, 2) ->
+    {lua_func, Func};
+transform(Term, {transformation, _Proplist, _Funcs}) ->
+    Term.
 
 %% turn `{userdata, Data}` into `Data` to make it more easy to decode it in Gleam
 maybe_process_userdata(Lst) when is_list(Lst) ->
@@ -146,17 +135,10 @@ alloc(St0, {usrdef,_}=Value) ->
 alloc(St0, Other) ->
     {St0, Other}.
 
-wrap_fun(Fun) ->
-    fun(Args, State) ->
-            Decoded = luerl:decode_list(Args, State),
-            {NewState, Ret} = Fun(State, Decoded),
-            luerl:encode_list(Ret, NewState)
-    end.
-
-wrap_trans_fun(Fun) ->
+wrap_fun(Fun, Settings) ->
     fun(Args, State) ->
             Decoded = luerl:decode_list(Args, State),
-            Transformed = [proplist_to_map(Arg) || Arg <- Decoded],
+            Transformed = [transform(Arg, Settings) || Arg <- Decoded],
             {NewState, Ret} = Fun(State, Transformed),
             luerl:encode_list(Ret, NewState)
     end.
@@ -200,10 +182,18 @@ eval_file(Lua, Path) ->
     to_gleam(luerl:dofile(
                  unicode:characters_to_list(Path), Lua)).
 
+is_lua_func({lua_func, Func}) when is_function(Func, 2) ->
+    true;
+is_lua_func(_Other) ->
+    false.
+
 call_function(Lua, Fun, Args) ->
     {EncodedArgs, State} = encode_list(Args, Lua),
     to_gleam(luerl:call(Fun, EncodedArgs, State)).
 
+call_enc_function(Lua, {lua_func, Func}, Args) ->
+    Func(Args).
+
 get_private(Lua, Key) ->
     try
         {ok, luerl:get_private(Key, Lua)}