[erlang-questions] Elixir Protocols in Erlang & a Strange Warning

[Fred Hebert]

Hi.

Despite what Joe says in his book, the history of the feature is that
tuple calls, the form you're using, were kept to allow the deprecation
of parametrized modules.

In my humble opinion, the 'stateful module' things you're trying to
accomplish for you stringification is non-intuitive and not erlangish (I
would be confused by reading that in a code base). May I suggest the
simpler form, without changing your module:

    stringer:to_string(MyValue)

instead? You will notice it even saves two characters when being called
over:

    ?stringer(MyValue):to_string().

Without including the macro definition work required, and is more
idiomatic overall. To use it as a function, simply use 

    F = fun stringer:to_string/1,
    F(MyValue).

Regards,
Fred.

On 12/13, Kaveh Shahbazian wrote:
> I do not thing so. Parametrized modules are different than stateful
> modules. Parametrized modules are deprecated and they were always
> provisional.
> 
> Joe Armstrong in Programming Erlang (2nd Edition, Page 418) talked about
> them and in this same book he was promoting "coming soon" features of R17
> and It's highly unlikely for them to be deprecated.
> 
> Kaveh Shahbazian
> “Walking on water and developing software from a specification are easy if
> both are frozen.”
> ― Edward Berard
> <http://goo.gl/ZZ2TMu>
> <http://stackoverflow.com/users/54467/kaveh-shahbazian>
> 
> 
> On Fri, Dec 13, 2013 at 11:40 AM, Dmitry Kolesnikov
> <dmkolesnikov@REDACTED>wrote:
> 
> > Hello,
> >
> > Essentially you are trying to use parametrized modules, which get
> > deprecated in R14/15 and dropped from R16.
> > See for details:
> >  * http://www.erlang.org/news/35
> >  * http://www.erlang.se/workshop/2003/paper/p29-carlsson.pdf
> >
> > This type of problems are solvable either via pattern match or currying:
> >
> > -module(stringer).
> > -export([stringer/1,sample/0]).
> >
> > stringer(V) when is_list(V) ->
> >     fun() -> to_string(V, nop) end;
> > stringer(V) when is_atom(V) ->
> >     fun() -> to_string(V, nop) end;
> > stringer(_V) ->
> >     fun() -> not_implemented end.
> >
> > to_string(V, _Nop) ->
> >     Buffer = io_lib:format("~p",[V]),
> >     lists:flatten(Buffer).
> >
> > sample() ->
> >     io:format("~p~n", [(stringer([1,2]))()]),
> >     io:format("~p~n", [(stringer(cute_atom))()]),
> >     io:format("~p~n", [(stringer(13))()]).
> >
> >
> > Best Regards,
> > Dmitry
> >
> > On Dec 13, 2013, at 8:31 AM, Kaveh Shahbazian <kaveh.shahbazian@REDACTED>
> > wrote:
> >
> > I wanted to write something like ((IStringer)object).ToString() (in C#)
> > in Erlang. After some studying I've learnt that Elixir has something called
> > Protocols that pretty much resembles the same thing of C# (in an inside-out
> > manner). Then I came up with this idea/code in Erlang - which is nice
> > enough to me like:
> >
> > ?stringer(my_val):to_string().
> >
> > And it either returns the expected value or not_implemented atom!
> >
> > But 2 questions:
> >
> > 1 - Why nobody use this or promote things based on stateful modules in
> > Erlang? (OTP aside and from talking to some Erlangers they did not know
> > that actually OTP is built around this! So really there is a need to change
> > how Erlang is being taught and promoted. It's possible that I am confused.).
> >
> > 2 - Why I get this warning? That call actually never fails.
> >
> > The warning:
> >
> > stringer.erl:18: Warning: invalid module and/or function name; this call will always fail
> > stringer.erl:19: Warning: invalid module and/or function name; this call will always fail
> > stringer.erl:20: Warning: invalid module and/or function name; this call will always fail
> >
> > The code:
> >
> > -module(stringer).
> > -export([to_string/1,sample/0]).
> >
> > -define(stringer(V), {stringer, V}).
> >
> > to_string({stringer, V}) when is_list(V) ->
> >     to_string(V, nop);
> > to_string({stringer, V}) when is_atom(V) ->
> >     to_string(V, nop);
> > to_string({stringer, _V}) ->
> >     not_implemented.
> >
> > to_string(V, _Nop) ->
> >     Buffer = io_lib:format("~p",[V]),
> >     lists:flatten(Buffer).
> >
> > sample() ->
> >     io:format("~p~n", [?stringer([1,2]):to_string()]),
> >     io:format("~p~n", [?stringer(cute_atom):to_string()]),
> >     io:format("~p~n", [?stringer(13):to_string()]).
> >
> > And the output is:
> >
> > "[1,2]"
> > "cute_atom"
> > not_implemented
> >
> >  _______________________________________________
> > erlang-questions mailing list
> > erlang-questions@REDACTED
> > http://erlang.org/mailman/listinfo/erlang-questions
> >
> >
> >

> _______________________________________________
> erlang-questions mailing list
> erlang-questions@REDACTED
> http://erlang.org/mailman/listinfo/erlang-questions