Functional core for elevator system design

Question

How can Gary Bernhardt's "Functional Core / Imperative Shell" architecture be used to design software for an elevator system?

Specifically, let's say there are a few elevators, each with call buttons (one per floor). Each elevator has sensors that report speed, position, and button status, and a controller that accepts instructions such as go up, go down, stop. Also each floor has sensors that report the status of the up and down call buttons.

Pick whatever is easiest for IO, like reliable messages or whatever. And pick whatever you is best in terms of concurrency (multiprocessing, multithreading or just asynchronous code).

An advanced elevator system bases its decisions on more than just current position, speed of each elevator and the state of request buttons on the floors and inside the elevator. In particular, to provide instructions to the elevators, it would need to know how long ago various events happened (to improve fairness) and perhaps even what the recent history was (this would help predict future requests).

But providing so much information as an input to a pure function seems very messy.

Am I thinking about it wrong, or is this problem just not well suited to that architecture?

Edit: as @ThomasKilian pointed out, the talk I'm referring to may not be as well known as I thought. So let me expand the question: I'm interested in any approach where all the non trivial business logic is mostly coded using functional programming style.

Answer 1

If you encapsulate your data into objects, and decompose your functions suitably, I think you could easily use the functional core approach. Imagine a Floor object to keep track of the buttons pressed on each floor, an Elevator object that keeps track of the speed and buttons inside the elevator. For keeping track of the history, you could take advantage of immutability and push states onto a stack instead of replacing them. The interaction between the shell and core could look something like:

List<Stack<Elevator>> elevators;
List<Stack<Floor>> floors;

while(true) {
  orders = core(elevators, floors);

  runOrders(orders);

  foreach (elevator in elevators) {
    elevator.push(getNewState(elevator.peek()));
  }

  foreach (floor in floors) {
    floor.push(getNewState(floor.peek()));
  }
}

The imperative code passes the orders on to the real-life elevators, retrieves their new states, and pushes those states onto the stacks. Inside the core, you don't need anything non-functional.

Yes it's a lot of data to pass around, but that's because you require a lot of data. Any code to manage positions, speeds, buttons, histories, etc. is going to be complicated. Do you have any reason to think an imperative implementation would be simpler than a referentially-transparent functional one?