Comments for Benjamin Halsted

Comment on Erlang Programming Exercise: 3-7 by halzy

halzy — Wed, 09 Mar 2011 02:11:50 +0000

I haven’t made it far enough in the book to use the list comprehension. I saw it when reading through the other book, but wanted to keep with what had been taught so far in this book.

Comment on Erlang Programming Exercise: 3-5 by Carlo

Carlo — Fri, 25 Feb 2011 16:44:31 +0000

Hi, I’m studying erlang too.
My version of concatenate use only two functions, but instead, the helper has one more case:

concatenate(Lists) ->
reverse(concatenateHelper(Lists, [])).

concatenateHelper([], Acc) -> Acc;
concatenateHelper([H | T], Acc) ->
Acc2 = concatenateHelper(H, Acc),
concatenateHelper(T, Acc2);
concatenateHelper(X, Acc) ->
[X | Acc].

Thinking about flatten, I realized that this can also be used to flatten a list.

concatenate([[1,[2,[3],[]]], [[[4]]], [5,6]]).
[1,2,3,4,5,6]

Do you think that my reasoning is correct?

Comment on Erlang Programming Exercise: 3-5 (refactor) by Sergey Shelukhin

Sergey Shelukhin — Sun, 13 Feb 2011 21:31:16 +0000

With restriction of using concatenate very similar function can be written:

flatten2(List) -> reverse( flatten_helper(List,[]) ).
flatten_helper([],Dst) -> Dst;
flatten_helper([H|T],Dst) when is_list(H) -> flatten_helper( concatenate([H,T]), Dst );
flatten_helper([H|T],Dst) -> flatten_helper( T, [H|Dst] ).

you could avoid is_list by matching [[HH|HT]|T] and [[]|T] separately as in your example.

I am now trying to break it

Comment on Erlang Programming Exercise: 3-5 by Andrei Marius

Andrei Marius — Tue, 14 Dec 2010 17:02:53 +0000

Hi,
Nice job with the exercises
My observation is that the exercise with the concatenation is not tail-recursive.
I like to see your way of resolving after I first tried on my own.
So here is the tail-recursive version I wrote, since, probably, a lot of people is reading your site when they get to the exercises. I have tested it with the sample from the book.

concatenate([]) ->
[];
concatenate(ListOfLists) ->
concatenate_acc(ListOfLists, []).

concatenate_acc([], ConList) ->
lists:reverse(ConList);
concatenate_acc([H|T], ConList) ->
concatenate_acc(H, T, ConList).
concatenate_acc([H|T], Lists, ConList) ->
concatenate_acc(T, Lists, [H|ConList]);
concatenate_acc([], Lists, ConList) ->
concatenate_acc(Lists, ConList).

Andrei Marius

Comment on Erlang Programming Exercise: 3-5 (refactor) by Nate Kidwell

Nate Kidwell — Sat, 20 Nov 2010 18:18:03 +0000

Heya-

Found your blog while doing the exercises and searching for the answer to a question I had about 3.5 (writing flatten). Basically it says to use “concatenate to solve flatten” and even though I solved flatten similarly to the first way you did (my code below), I also didn’t use concatenate.

What I’m OCDing on is I actually think his hint on using concatenate is wrong here, because erlang’s lists are untyped (so you never know if your dealing with a list of lists (which is what concatenate takes) until you navigate it).

Regardless, great blog, and I’m going to start following your solutions to his book.

************************

flatten([], Accum) ->
Accum;
flatten([H|[]], Accum) ->
flatten(H, Accum);
flatten([H|T], Accum) ->
flatten(H, flatten(T, Accum));
flatten(Val, Accum) ->
[Val | Accum].

flatten(List) ->
flatten(List,[]).

Comment on Erlang Programming Exercise: 3-7 by Andy

Andy — Tue, 14 Sep 2010 21:02:24 +0000

“case” in match/2 can be omitted:

match(Element, Db) ->
lists:filter(fun({_, E}) -> E =:= Element end, Db).

but original exercise required that match/2 returns list of keys, not list of tuples, so it could look like:

match(Element, Db) ->
MatchedTuples = lists:filter(fun({_, E}) -> E =:= Element end, Db),
element(1, lists:unzip(MatchedTuples)).

But this is rather too complicated. Using list comprehension gives us a simpler version:

match(Element, Db) ->
[Key || {Key, E} <- Db, E =:= Element].

Comment on Erlang Programming Exercise: 3-8-1 (update) by Paul Cowan

Paul Cowan — Fri, 04 Jun 2010 23:42:01 +0000

I am going through the same tests right now.

Here is my parser, it does not do unary minus yet but it does double digits:

http://github.com/dagda1/erlang_sandbox/blob/master/compiler/parser.erl

Comment on Erlang Programming Exercise: 3-4 by Erlang Programming Exercise: 5-1 « Benjamin Halsted

Erlang Programming Exercise: 5-1 « Benjamin Halsted — Fri, 21 May 2010 01:00:28 +0000

[...] through the "Programming Erlang" book by Joe Armstrong I ended up doing an exercise very much like Exercise 3-4, but I made a mistake and implemented it as a server, like this exercise. It's fun to compare my [...]

Comment on Erlang Programming Exercise: 3-4 by Erlang Programming Exercise: 3-7 « Benjamin Halsted

Erlang Programming Exercise: 3-7 « Benjamin Halsted — Tue, 23 Mar 2010 16:58:28 +0000

[...] this exercise we get to rewrite Exercise 3-4 using the lists module. The author asks us how much shorter the newer version is from the first [...]

Comment on Erlang Programming Exercise: 3-6 (quicksort) by halzy

halzy — Sat, 20 Mar 2010 00:20:38 +0000

Andrea, thank you for the link! Section 2.4 is exactly what I was seeing. It also explains the performance similarity between [H]++Acc and [H|Acc]:
“Or it would be more efficient if the the compiler did not automatically rewrite [H]++Acc to [H|Acc].”

If you get a chance, check out the book that the exercises are from:
http://www.erlangprogramming.org/

So far, I like this book better than the other ones. I’ll continue to work through the exercises and post them as my schedule permits.

Cheers,
-Halzy