protofsm: eliminate outer option layer in EmmittedEvent

We'll have the empty slice tuple represent the None case instead.

protofsm/state_machine.go

@@ -34,11 +34,11 @@ type EmittedEvent[Event any] struct {
 	// InternalEvent is an optional internal event that is to be routed
 	// back to the target state. This enables state to trigger one or many
 	// state transitions without a new external event.
-	InternalEvent fn.Option[[]Event]
+	InternalEvent []Event
 
 	// ExternalEvent is an optional external event that is to be sent to
 	// the daemon for dispatch. Usually, this is some form of I/O.
-	ExternalEvents fn.Option[DaemonEventSet]
+	ExternalEvents DaemonEventSet
 }
 
 // StateTransition is a state transition type. It denotes the next state to go
@@ -573,46 +573,31 @@ func (s *StateMachine[Event, Env]) applyEvents(currentState State[Event, Env],
 				// With the event processed, we'll process any
 				// new daemon events that were emitted as part
 				// of this new state transition.
-				//
+				for _, dEvent := range events.ExternalEvents {
-				//nolint:ll
+					err := s.executeDaemonEvent(
-				err := fn.MapOptionZ(events.ExternalEvents, func(dEvents DaemonEventSet) error {
+						dEvent,
-					log.Debugf("FSM(%v): processing "+
+					)
-						"daemon %v daemon events",
+					if err != nil {
-						s.cfg.Env.Name(), len(dEvents))
+						return err
-
-					for _, dEvent := range dEvents {
-						err := s.executeDaemonEvent(
-							dEvent,
-						)
-						if err != nil {
-							return err
-						}
 					}
-
-					return nil
-				})
-				if err != nil {
-					return err
 				}
 
-				// Next, we'll add any new emitted events to
+				// Next, we'll add any new emitted events to our
-				// our event queue.
+				// event queue.
 				//
 				//nolint:ll
-				events.InternalEvent.WhenSome(func(es []Event) {
+				for _, inEvent := range events.InternalEvent {
-					for _, inEvent := range es {
+					log.Debugf("FSM(%v): adding "+
-						log.Debugf("FSM(%v): adding "+
+						"new internal event "+
-							"new internal event "+
+						"to queue: %v",
-							"to queue: %v",
+						s.cfg.Env.Name(),
-							s.cfg.Env.Name(),
+						lnutils.SpewLogClosure(
-							lnutils.SpewLogClosure(
+							inEvent,
-								inEvent,
+						),
-							),
+					)
-						)
 
-						eventQueue.Enqueue(inEvent)
+					eventQueue.Enqueue(inEvent)
-					}
+				}
-				})
 
 				return nil
 			})

protofsm/state_machine_test.go

@@ -80,9 +80,7 @@ func (d *dummyStateStart) ProcessEvent(event dummyEvents, env *dummyEnv,
 		return &StateTransition[dummyEvents, *dummyEnv]{
 			NextState: &dummyStateStart{},
 			NewEvents: fn.Some(EmittedEvent[dummyEvents]{
-				InternalEvent: fn.Some(
+				InternalEvent: []dummyEvents{&goToFin{}},
-					[]dummyEvents{&goToFin{}},
-				),
 			}),
 		}, nil
 
@@ -114,13 +112,13 @@ func (d *dummyStateStart) ProcessEvent(event dummyEvents, env *dummyEnv,
 				canSend: d.canSend,
 			},
 			NewEvents: fn.Some(EmittedEvent[dummyEvents]{
-				ExternalEvents: fn.Some(DaemonEventSet{
+				ExternalEvents: DaemonEventSet{
 					sendEvent, sendEvent2,
 					&BroadcastTxn{
 						Tx:    &wire.MsgTx{},
 						Label: "test",
 					},
-				}),
+				},
 			}),
 		}, nil
 	}