erlish.erl

-module(erlish).
-export([init/0, manager/1, get/1, set/2, keys/0, del/1, expire/2]).

manager(State) ->
    receive
        {get, Key, Sender} ->
            Value = case maps:is_key(Key, State) of
                        true ->
                            maps:get(Key, State);
                        _ ->
                            {error, [no_such_key, Key]}
                    end,
            Sender ! Value,
            manager(State);

        {set, Key, Value, Sender} ->
            New_State = maps:put(Key, Value, State),
            Sender ! ok,
            manager(New_State);

        {del, Key, Sender} ->
            New_State = maps:remove(Key, State),
            Sender ! ok,
            manager(New_State);

        {keys, Sender} ->
            Sender ! maps:keys(State),
            manager(State);

        {expire, Key, Seconds, Sender} ->
            timer:send_after(Seconds * 1000, {del, Key, self()}),
            Sender ! ok,
            manager(State);

        _ ->
            manager(State)
    end.

get(Key) ->
    manager ! {get, Key, self()},
    receive T -> T end.

set(Key, Value) ->
    manager ! {set, Key, Value, self()},
    receive T -> T end.

keys() ->
    manager ! {keys, self()},
    receive T -> T end.

del(Key) ->
    manager ! {del, Key, self()},
    receive T -> T end.

expire(Key, Seconds) ->
    manager ! {expire, Key, Seconds, self()},
    receive T -> T end.

init() ->
    register(manager, spawn(erlish, manager, [#{}])).

z_usage

73> erlish:init().
true
74> erlish:set(test, 123).
ok
75> erlish:expire(test, 10).
ok
76> erlish:get(test).
123
76> erlish:set(test, xyz).
ok
76> erlish:get(test).
xyz
77> erlish:get(test).
{error,[no_such_key,test]}

Did you try using the receive...after... syntax instead of sending yourself a del message?d

receive
  {expire, Key, Seconds, Sender} -> ...
after
  1000 ->
    manager(remove_expired_keys(state))
end

👍 Very cool!