# [erlang-questions] how: Another library flatten function?

Fri Feb 26 23:07:13 CET 2010

```On Fri, Feb 26, 2010 at 9:58 PM, Bengt Kleberg <>
wrote:

> Greetings,
>
> I have the following list: ["asd",[["Flow","kalle"]],["Sub","F"]]
> I would like to flatten it to: ["asd","Flow","kalle","Sub","F"]
> lists:flatten/1 is too effective. It gives me: "asdFlowkalleSubF"
>
> Is there another flatten somewhere?
>

The following page tells us that lists:flatten/1 is expensive and even more
expensive than ++.
http://www.erlang.org/doc/efficiency_guide/listHandling.html
And in some cases, lists:append/1 is used for avoiding calling the
lists:flattten/1.

On Fri, Feb 26, 2010 at 11:50 PM, Dmitry Belayev <> wrote:

> You can write your own:
>
> f(List) ->
>   lists:reverse(f(List, [])).
>
> f([], A) ->
>   A;
> f([L|_]=I, A) when is_number(L) ->
>   [I | A];
> f([H|Tail], A) ->
>   f(Tail, f(H, A)).
>

My solution without lists:reverse/1,

flatten([]) ->
[];
flatten([[S|Ss]|Xs]) when is_number(S) ->
[[S|Ss]|flatten(Xs)];
flatten([Xs|Ys]) ->
flatten(Xs ++ Ys).

Every string occurring in the head of a list is picked out first, or a head
of a list which is also
a list is appended. Though it looks not efficiency, the page
http://www.erlang.org/doc/efficiency_guide/myths.html#id2253656
says that it's somewhat OK.

On Sat, Feb 27, 2010 at 1:29 AM, Jayson Vantuyl <> wrote:

> Or:
>
> flat(L) -> lists:map(fun lists:flatten/1,L).
>
> Or:
>
> flat(L) -> [ lists:flatten(X) || X <- L ].
>
> Sent from my iPhone
>
>
>
lists:flatten/1 is more expensive than ++.
```