Tiling is a kotlin multiplatform experiment for loading chunks of structured data from reactive sources. Tiling is achieved with a Tiler; a pure function with an API most similar to a reactive `Map` where: * The keys are queries for data * The values are dynamic sets of data returned over time as the result of the query key. The output of a Tiler is either a snapshot of the `Map` or a flattened `List` making a `Tiler` either a: * `(Flow>) -> Flow>` or * `(Flow>) -> Flow>` ### Getting your data Tilers are implemented as plain functions. Given a `Flow` of `Input`, you can either choose to get your data as: * A `Flow>` with `tiledList` * A `Flow>` with `tiledMap` In the simplest case given a `MutableStateFlow>` one can write: ```kotlin class NumberFetcher { private val requests = MutableStateFlow>>(Tile.Request.On(query = 0)) private val tiledList: (Flow>>) -> Flow>> = tiledList( order = Tile.Order.Sorted(comparator = Int::compareTo), fetcher = { page -> val start = page * 50 val numbers = start.until(start + 50) flowOf(numbers.toList()) } ) val listItems: Flow> = tiledList.invoke(requests).map { it.flatten() } fun fetchPage(page: Int) { requests.value = Tile.Request.On(page) } } ``` The above will return a full list of every item requested sorted in ascending order of the pages. Note that in the above, the list will grow indefinitely as more tiles are requested unless queries are evicted. This may be fine for small lists, but as the list size grows, some items may need to be evicted and only a small subset of items need to be presented to the UI. This sort of behavior can be achieved using the `Evict` `Request`, and the `PivotSorted` `Order` covered on the project github page: [Tiler](https://github.com/tunjid/Tiler?open-graph-scrape=true).