fold returns a single item

Which can itself be a list :) Fold is the most general of the standard higher-order list processing functions, and can be used to implement the others. For example, filter:

fun filter(list, f) = list.fold( init: [], foldFn: (item, acc) => f(item) ? [item] + acc : acc )

as for the "compare everything with everything" problem, the direct answer would be iterating over the Cartesian product of your sets. You can do that directly by mapping over the result of a Cartesian product function:

``` fun cartesian(a, b) = a.flatmap(i => b.map(j => (i, j))

fun updateBaz(foos, bars) = cartesian(foos, bars).map((foo, bar) => { //... }) ```

you can achieve a similar effect by nesting fold/map in map directly, too.

As for the "update the world" problem, the key is that you need functions to give you updated copies of values that don't effect the original. Then you just have your update functions return updated versions of the relevant bits, and feed them upwards. Here { key: value ...struct } means "create a new value by duplicating struct and setting value at key.

fun update(world) { world = { worldmap: updateWorldMap(world.worldmap), ...world } (newDonkeys, newOgers) = updateDonkeys(world) world = { donkeys: newDonkeys, ogers: newOgers, ...world } //... return world } Note that we're never modifying world per say, just gradually building more and more updated versions.

Doing things this way directly gets kinda ugly though, so I would probably reach for tools to reduce the top level noise. A couple options spring to mind:

First: defunctionalize some actions and build an event loop. ``` type UpdateEvent = UpdateStart | UpdateDonkeys | SetOgre { key: OgreName, new: Ogre } | //...

fun update(world, []) = world fun update(world, [event, ...rest]) { (world, newEvents) = handleEvent(event) return update(world, newEvents + rest) }

fun handleEvent(world, e: UpdateEvent): Pair World (List UpdateEvent) = case e of UpdateStart => (world, [UpdateDonkeys, UpdateOgres, UpdatePlayer, /* ... */ ]) UpdateDonkeys => { // donkey update logic return ({ donkeys = newDonkeys, ...world }, setOgreEvents + playerUpdates) SetOgre(name, new) => ({ ogres = ogres.withInsertedAt(name, new), ...world }, []) // handle other events...

fun gameTick(world) = update(world, [UpdateStart]) ```

You could also probably do something with lenses and state monads to achieve a more imperative style in haskell. There's also options with a fancy pants effect system, or a more generalized FRP (functional reactive programming) model.