# [erlang-questions] concentate solution well ??

Roelof Wobben r.wobben@REDACTED
Mon Feb 2 08:02:45 CET 2015

```Richard A. O'Keefe schreef op 2-2-2015 om 3:25:
> On 2/02/2015, at 6:27 am, Roelof Wobben <r.wobben@REDACTED> wrote:
>> This solution better ?
>>
>> concatenate([]) ->
>>      [].
>>
>> concatenate([List] ) ->
>>      concatenate2(List1, []).
>>
>> concatenate2([], List) ->
>>      List;
>>
> No.,  To be honest, it is a b----y bad solution.
>
> WHERE ARE THE [UNPRINTABLE] COMMENTS?
> Because of this thread, I know what concatenate/2
> is supposed to do, BUT YOU HAVE NOT TOLD US WHAT
> concatenat2/2 IS SUPPOSED TO DO.
>
> In fact concatenate2/2 appears to be reversal,
> which is something you definitely do NOT want.
>
> What you have here is
>
>   > concatenate([]).
>   []
>   > concatenate([[a,b,c]]).
>   [c,b,a]
>   > concatenate([[a,b,c], [1,2,3]]).
>   NO MATCH
>
> The basic scheme for processing lists by recursion is
>
> g([H|T], Context) ->
>      f(H, g(T, Context), Context);
> g([], Context) ->
>      e(Context).
>
> where g is the function we are trying to define
>        e is what to do for an empty list
>        f is what to do for a non-empty list
>          GIVEN the result of a recursive call on the tail.
>        e() and f(_,_) do not have to be literal function
>        calls; they could be any expression.
>
>
> So we are looking for
>
> concatenate([H|T]) ->
>      f(H, concatenate(T));
> concatenate([]) ->
>      e().
>
> You know what concatenate([]) is, so we're looking for
>
> concatenate([H|T]) ->
>      f(H, concatenate(T));
> concatenate([]) ->
>      [].
>
> Now H : list(X)
>      concatenate (list(list(X)) -> list(X))
> so  concatenate(T) : list(X)
> and you need to find an expression f(A, B)
> such that when A and B are lists, so is f(A, B),
> and the result has all the elements of A followed
> by all the elements of B.
>
> If you really do want a helper function (and there is
> a built-in operator that does *precisely* what you
> need), start by writing the comment:
>
> %   concatenate_helper(A : list(X), B : list(X)) -> R : list(X)
> %   R is a list containing all the elements of A followed by
> %   all the elements of B and nothing else.
>
> By this point in the book, if you haven't heard of the built-in
> operator that does this, you have probably written your own
>
>
>

Thanks,

Now Im doubt or looking for a erlang book which takes lesser steps and
explain things  like recursion in smaller steps or that Erlang is not
the language for me.

Roelof

```