Erlang sequential programming exercises

boolean.erl

-module(boolean).
-export([b_not/1,b_and/2,b_or/2,test/0]).

b_not(false) -> true;
b_not(true) -> false.

b_and(false,false) -> false;
b_and(false,true) -> false;
b_and(true,false) -> false;
b_and(true,true) -> true.

b_or(false,false) -> false;
b_or(false,true) -> true;
b_or(true,false) -> true;
b_or(true,true) -> true.

test() -> false = b_and(true,false).

db.erl

-module(db).
-export([new/0,destroy/1,write/3,delete/2,read/2,match/2]).

new() -> [].

destroy(DbRef) -> ok.

write(Key,Element,DbRef) -> [{Key,Element}|DbRef].

delete(Key,[]) -> [];
delete(Key,[Key|T]) -> delete(Key,T);
delete(Key,[H|T]) -> [H|delete(Key,T)].

read(Key,[]) -> {error, instance};
read(Key,[{Key,Element}|_]) -> {ok,Element};
read(Key,[_|Tail]) -> read(Key,Tail).

match(Element,[{Key,Element}|T]) -> [Key|match(Element,T)];
match(Element,[_|T]) -> match(Element,T);
match(Element,[]) -> [].

list.erl

-module(list).
-compile(export_all).

filter([], _) -> [];
filter([H|T],Fun) when is_function(Fun) ->
	X = Fun(H),
	if X -> [H|filter(T,Fun)];
	   true -> filter(T,Fun)
	end;
filter([H|T], H) -> [H|filter(T,H)];
filter([_|T], H) -> filter(T,H).

reverse(Xs) -> reverse(Xs,[]).

reverse([],Acc) -> Acc;
reverse([H|T],Acc) -> reverse(T,[H|Acc]).

concatenate([]) -> [];
concatenate([H|T]) -> concat(reverse(H),concatenate(T)).

concat([],Acc) -> Acc;
concat([H|T],Acc) -> concat(T, [H|Acc]).

flatten([]) -> [];
flatten([H|T]) when is_list(H) -> concatenate([flatten(H),flatten(T)]);
flatten([H|T]) -> [H|flatten(T)].

sort([]) -> [];
sort([H|T]) ->
	concatenate([sort(filter(T,fun(X) -> X =< H end)),
	             [H],
				 sort(filter(T,fun(X) -> X > H end))
			    ]).

seq.erl

-module(seq).
-export([sum/1,sum_interval/2,create/1,reverse_create/1,print/1]).

sum(1) -> 1;
sum(N) -> N+sum(N-1).

sum_interval(N,N) -> N;
sum_interval(_,M) -> M + sum(M-1).

create(N,N) -> [N];
create(From,N) -> [From|create(From+1,N)].

create(N) -> create(1,N).

reverse_create(N,N) -> [N];
reverse_create(N,To) -> [N|reverse_create(N-1,To)].

reverse_create(N) -> reverse_create(N,1).

print(N) -> print(N,1).

print(N, N) -> io:format("Number: ~p ~n",[N]);
print(N, From) -> io:format("Number: ~p ~n",[From]), print(N,From+1).

temp.erl

-module(temp).
-export([f2c/1, c2f/1, convert/1]).

f2c(F) -> (5 * (F - 32)) / 9.
c2f(C) -> ((9 * C ) / 5) + 32. 

convert({c, C}) -> c2f(C);
convert({f, F}) -> f2c(F).