[erlang-questions] erlang improvement - objective c (or smalltalk) syntax

[Tony Rogvall]

I like the idea.

just think about the way you handle variant functions:

format(value:V) ->
	format(value:V precision:0 width:0 pad:$\s).
format(value:V width:W) ->
	format(value:V precision:0 width:W pad:$\s).
format(value:V precision:P) ->
	format(value:V precision:P width:0 pad:$\s).
...
format(value:V precision:P width:W pad:C) ->
	format_v(value:V precision:P width:W pad:C).

The API designer still has to specify several cases but the user can  
use the variants more freely.

	format(value:"Hello" width:12)

	format(value:3.13 precision:2)

	format(value:16#4562 width:8 pad:$0)

To simplify the API designers work a syntax for default values could  
be designed.
  (Without thinking much about syntax! or the gory cases ;-)

format(value:V precision:P=0 width:W=0 pad:C=$\s) ->
	format_v(value:V precision:P width:W pad:C).

The translator must in this case generate all versions of format (note  
the argument name sorting)

format_value(V) -> format_pad_precision_value_width($\s,0,V,0).
format_precision_value(V,P) -> format_pad_precision_value_width($ 
\s,P,V,0).
format_width_value(V,W) -> format_pad_precision_value_width($\s,0,V,W).
... etc

To make this change and preserve backwards compatibility then old  
functions must be mapped to the
new or vice versa (depending on situation)

keysearch(Key,Index,List) -> keysearch(key:Key index:Index list:List).

OR
keysearch(key:Key index:Index list:List) -> keysearch(Key,Index,List).

The new keysearch will probably be called something like

	keysearch_key_index_list/3


On my which list is also some kind of syntax (sugar) to change some  
arguments in "recursive" functions
without having to specify every one again:

my_func(X1, X2, X3, X4, X5, X6, X7, X8) ->
	case X1 of
		1 -> my_func(X1-1, X2, X3, X4, X5, X6, X7, X8);
		2 -> my_func(X1, X2-1, X3, X4, X5, X6, X7, X8);
		3 -> my_func(X1, X2, X3-3, X4, X5, X6, X7, X8);
		...
	end.

Someway of grouping the arguments ?

my_func(As=#(x1=X1 x2=X2 x3=X3, x4=X4, x5=X5,x6=X6,x7=X7,x8=X8)) ->
	case X1 of
		1 -> my_func(As# {x1=X1-1});
		2 -> my_func(As# {x2=X2-1});
		3 -> my_func(As# {x3=X3-1})
		..
	end.

A record like syntax? other suggestions?  Maybe even anonymous  
arguments as a group.

/Tony



	

On 5 jun 2009, at 10.09, Vlad Dumitrescu wrote:

> On Fri, Jun 5, 2009 at 09:46, Bengt Kleberg <bengt.kleberg@REDACTED 
> > wrote:
>> The drawback with
>> string:substring_string_start_length(S, X, J)
>> is that you might still have made a mistake. If/When
>> string:substring(string:S, start:X, length:J)
>> is introduced the compiler will put things in the correct position.
>
> Yes, but you can still write "start:J, length:X" and make a mistake
> :-) Nothing is completely error-proof.
>
>> It could also make sure that the function (ought to) exist, at  
>> least for
>> OTP functions. That would be nice.
>> The number of times I have written
>> lists:length/1 is embarrassing.
>
> Yeah, me too :-)
>
> This is a different can of worms. There is no reason the compiler
> couldn't check if lists:length exist now either, if it wanted to. But
> then we couldn't compile each erl file separately, only the whole
> system together.
>
> dialyzer can check if the target of a call exists.
>
> regards,
> Vlad
>
> ________________________________________________________________
> erlang-questions mailing list. See http://www.erlang.org/faq.html
> erlang-questions (at) erlang.org
>