How similar to specs? about apecs HOT 1 CLOSED

There are some similarities, defining components is pretty much identical to specs, for example:

#[derive(Debug)]
struct Position(f32);

impl Component for Position {
    type Storage = VecStorage<Self>;
}

fn main() {
  let mut world = World::new();
  world.register::<Position>();
  world.create_entity().with(Position(0.0)).build();
}

vs

newtype Position = Position Double deriving Show

instance Component Position where
  type Storage Position = Map Position

makeWorld "MyWorld" [''Position]

main = do
  newEntity (Position 0)
  ...

They have very different interpretations of the idea of a system, however. In specs, a system is something you build and explicitly dispatch, whereas in apecs, a system is just a statement. Consider:

struct HelloWorld;

impl<'a> System<'a> for HelloWorld {
    type SystemData = ReadStorage<'a, Position>;

    fn run(&mut self, position: Self::SystemData) {
        use specs::Join;

        for position in position.join() {
            println!("Hello, {:?}", &position);
        }
    }
}

fn main() {
  ...
  let mut dispatcher = DispatcherBuilder::new().with(SysA, "sys_a", &[]).build();
  dispatcher.setup(&mut world.res);
  dispatcher.dispatch(&mut world.res);
}

vs

main = do
  ...
  cmapM_ $ \(p :: Position) -> liftIO . putStrLn $ "Hello, " ++ show p

You don't get any automatic parallelism, but it's easy to do yourself. You use forkSys to run a system on a new thread, and atomically to eliminate race conditions by lifting it into the STM monad. How you combine these is up to you, but here's an example in which we spawn a thread that continuously executes a system, prints a message, sleeps for a period of time, and then repeats:

forkSys . forever $ do
  atomically . cmap $ \(Position p, Velocity v) -> Position (p+v)
  liftIO (putStrLn "Stepped positions")
  liftIO (threadDelay 1000)

does that answer your question?

from apecs.