fed-sx-m1: Step 5a — pure-functional registry (new/register/lookup/list) + 14 tests

next/kernel/registry.erl

@@ -0,0 +1,69 @@
+-module(registry).
+-export([new/0, kinds/0, register/4, lookup/3, list/2]).
+
+%% Pure-functional registry for the seven bootstrap kinds.
+%%
+%% State is a property list keyed by kind atom; each kind's value
+%% is itself a property list of {Name, Entry} pairs. Entry is
+%% opaque — typically a proplist with :cid, :schema, :semantics,
+%% :supersedes fields, but the registry doesn't enforce that here.
+%%
+%% A gen_server wrapper (Step 5b) will own the global registry
+%% process; the pure functions in this module remain the canonical
+%% API and are usable for tests and for offline projection-replay.
+%%
+%% Return shapes:
+%%   new/0            -> State
+%%   kinds/0          -> [Atom, ...]
+%%   register/4       -> {ok, NewState} | {error, unknown_kind}
+%%   lookup/3         -> {ok, Entry} | not_found | {error, unknown_kind}
+%%   list/2           -> [{Name, Entry}, ...] | {error, unknown_kind}
+
+new() -> [].
+
+kinds() ->
+    [activity_types, object_types, projections,
+     validators, codecs, sig_suites, audience].
+
+register(Kind, Name, Entry, State) ->
+    case is_valid_kind(Kind) of
+        false -> {error, unknown_kind};
+        true ->
+            Entries = kind_entries(Kind, State),
+            Updated = put_pair(Name, Entry, Entries),
+            {ok, set_kind_entries(Kind, Updated, State)}
+    end.
+
+lookup(Kind, Name, State) ->
+    case is_valid_kind(Kind) of
+        false -> {error, unknown_kind};
+        true ->
+            find_pair(Name, kind_entries(Kind, State))
+    end.
+
+list(Kind, State) ->
+    case is_valid_kind(Kind) of
+        false -> {error, unknown_kind};
+        true  -> kind_entries(Kind, State)
+    end.
+
+%% ── Internal ────────────────────────────────────────────────────
+
+is_valid_kind(K) -> lists:member(K, kinds()).
+
+kind_entries(Kind, State) ->
+    case find_pair(Kind, State) of
+        not_found -> [];
+        {ok, V}   -> V
+    end.
+
+set_kind_entries(Kind, Entries, State) ->
+    put_pair(Kind, Entries, State).
+
+put_pair(K, V, []) -> [{K, V}];
+put_pair(K, V, [{K, _} | Rest]) -> [{K, V} | Rest];
+put_pair(K, V, [P | Rest]) -> [P | put_pair(K, V, Rest)].
+
+find_pair(_, []) -> not_found;
+find_pair(K, [{K, V} | _]) -> {ok, V};
+find_pair(K, [_ | Rest]) -> find_pair(K, Rest).