refactor: reorder fold/4 callback parameters

Co-authored-by: ccamel <9574336+ccamel@users.noreply.github.com>

Author: Copilot

README.md

@@ -126,11 +126,11 @@ The event store is a core component in this experiment, designed as a customizab
          Events :: [event()].
 
 % Folds events from a stream using a provided function
--callback fold(StreamId, Options, FoldFun, InitialAcc) -> {ok, Acc} | {error, term()}
+-callback fold(StreamId, FoldFun, InitialAcc, Options) -> {ok, Acc} | {error, term()}
     when StreamId :: stream_id(),
-         Options :: fold_events_opts(),
          FoldFun :: fold_events_fun(),
-         InitialAcc :: Acc.
+         InitialAcc :: Acc,
+         Options :: fold_events_opts().
 ```
 
 #### Snapshot Support

apps/event_sourcing_contract/src/event_sourcing_event_store_behaviour.erl

@@ -68,20 +68,20 @@ event in sequence order, and returns the final accumulator. It’s typically use
 rebuild application state by replaying events.
 
 - StreamId is an atom identifying the event stream (e.g., order-123).
+- FoldFun is a function `fun((Event, AccIn) -> AccOut)` to process each event.
+- InitialAcc is the initial accumulator value (e.g., an empty state).
 - Options is A list of filters:
   - `{from, Sequence}`: Start at this sequence (default: 0).
   - `{to, Sequence | infinity}`: End at this sequence (default: infinity).
   - `{limit, Limit}`: Maximum number of events to retrieve (default: infinity).
-- FoldFun is a function `fun((Event, AccIn) -> AccOut)` to process each event.
-- InitialAcc is the initial accumulator value (e.g., an empty state).
 
 Returns the final accumulator after folding all events.
 """.
--callback fold(StreamId, Options, Fun, Acc0) -> Acc1 when
+-callback fold(StreamId, Fun, Acc0, Options) -> Acc1 when
     StreamId :: stream_id(),
-    Options :: fold_events_opts(),
     Fun :: fun((Event :: event(), AccIn) -> AccOut),
     Acc0 :: term(),
+    Options :: fold_events_opts(),
     Acc1 :: term(),
     AccIn :: term(),
     AccOut :: term().

apps/event_sourcing_core/src/event_sourcing_core_aggregate.erl

@@ -153,9 +153,9 @@ init({Aggregate, StoreContext, Id, Opts}) ->
         event_sourcing_core_store:fold(
             StoreContext,
             Id,
-            #{from => SequenceFromSnapshot + 1},
             FoldFun,
-            {StateFromSnapshot, SequenceFromSnapshot}
+            {StateFromSnapshot, SequenceFromSnapshot},
+            #{from => SequenceFromSnapshot + 1}
         ),
     Timeout = maps:get(timeout, Opts, ?INACTIVITY_TIMEOUT),
     SnapshotInterval = maps:get(snapshot_interval, Opts, 0),

apps/event_sourcing_core/src/event_sourcing_core_store.erl

@@ -123,17 +123,17 @@ Folds events from the event store into an accumulator using the specified persis
 This is the core operation for event replay and state reconstruction. The backend
 retrieves events matching the given criteria and applies the fold function in sequence order.
 """.
--spec fold(StoreContext, StreamId, Options, Fun, Acc0) -> Acc1 when
+-spec fold(StoreContext, StreamId, Fun, Acc0, Options) -> Acc1 when
     StoreContext :: store_context(),
     StreamId :: stream_id(),
-    Options :: fold_events_opts(),
     Fun :: fun((Event :: event(), AccIn) -> AccOut),
     Acc0 :: term(),
+    Options :: fold_events_opts(),
     Acc1 :: term(),
     AccIn :: term(),
     AccOut :: term().
-fold({EventModule, _}, StreamId, Options, Fun, InitialResult) ->
-    EventModule:fold(StreamId, Options, Fun, InitialResult).
+fold({EventModule, _}, StreamId, Fun, InitialResult, Options) ->
+    EventModule:fold(StreamId, Fun, InitialResult, Options).
 
 -doc """
 Retrieves events for a given stream using the specified store module and options.
@@ -149,9 +149,9 @@ retrieve_events(StoreContext, StreamId, Options) ->
     fold(
         StoreContext,
         StreamId,
-        Options,
         fun(Event, Acc) -> Acc ++ [Event] end,
-        []
+        [],
+        Options
     ).
 
 -doc """

apps/event_sourcing_store_ets/src/event_sourcing_store_ets.erl

@@ -79,15 +79,15 @@ append(_, Events) ->
             erlang:error(duplicate_event)
     end.
 
--spec fold(StreamId, Options, Fun, Acc0) -> Acc1 when
+-spec fold(StreamId, Fun, Acc0, Options) -> Acc1 when
     StreamId :: stream_id(),
-    Options :: fold_events_opts(),
     Fun :: fun((Event :: event(), AccIn) -> AccOut),
     Acc0 :: term(),
+    Options :: fold_events_opts(),
     Acc1 :: term(),
     AccIn :: term(),
     AccOut :: term().
-fold(StreamId, Options, FoldFun, InitialAcc) when
+fold(StreamId, FoldFun, InitialAcc, Options) when
     is_map(Options), is_function(FoldFun, 2)
 ->
     From = maps:get(from, Options, 0),

apps/event_sourcing_store_mnesia/src/event_sourcing_store_mnesia.erl

@@ -119,15 +119,15 @@ persist_events_in_tx(StreamId, [Event | Rest]) ->
             persist_events_in_tx(StreamId, Rest)
     end.
 
--spec fold(StreamId, Options, Fun, Acc0) -> Acc1 when
+-spec fold(StreamId, Fun, Acc0, Options) -> Acc1 when
     StreamId :: stream_id(),
-    Options :: fold_events_opts(),
     Fun :: fun((Event :: event(), AccIn) -> AccOut),
     Acc0 :: term(),
+    Options :: fold_events_opts(),
     Acc1 :: term(),
     AccIn :: term(),
     AccOut :: term().
-fold(StreamId, Options, FoldFun, InitialAcc) when
+fold(StreamId, FoldFun, InitialAcc, Options) when
     is_map(Options), is_function(FoldFun, 2)
 ->
     From = maps:get(from, Options, 0),