feat(grid/transducers): add tap()

examples/a-star-path-finding/aStar.ts

@@ -1,4 +1,4 @@
-import { assertCubeCoordinates, AxialCoordinates, equals, Grid, Hex, HexCoordinates, ring } from 'honeycomb-grid'
+import { assertCubeCoordinates, AxialCoordinates, equals, Grid, Hex, HexCoordinates, ring, tap } from 'honeycomb-grid'
 import { filter, remove } from 'transducist'
 import { TARGET_COORDINATES } from './index'
 import { AStarOptions, PathData } from './types'
@@ -30,15 +30,12 @@ export function aStar<T extends Hex>({
     targetFound = equals(current.coordinates, TARGET_COORDINATES)
     if (targetFound) return backtrack(closed, grid)
 
-    grid
-      .traverse(ring({ center: current.coordinates, radius: 1 }), [
-        filter(isPassable),
-        remove((hex) => isInList(closed, hex)),
-        // todo: this isn't allowed, because a transducer must always return T, but is that reasonable?
-        // map(tile => createPathData(tile))
-      ])
-      // todo: use forEach() transducer once it exists
-      .forEach((neighbor) => {
+    grid.traverse(ring({ center: current.coordinates, radius: 1 }), [
+      filter(isPassable),
+      remove((hex) => isInList(closed, hex)),
+      // todo: this isn't allowed, because a transducer must always return T, but is that reasonable?
+      // map(tile => createPathData(tile))
+      tap((neighbor) => {
         if (!isInList(open, neighbor)) {
           const neighborPathData = createPathData(neighbor)
           const nextG = current.g + neighborPathData.g
@@ -48,7 +45,8 @@ export function aStar<T extends Hex>({
           }
           open.push(neighborPathData)
         }
-      })
+      }),
+    ])
   }
 
   // no path found

examples/a-star-path-finding/index.ts

@@ -1,6 +1,6 @@
 import { Color, Polygon } from '@svgdotjs/svg.js'
-import { createHexPrototype, Grid, rectangle } from 'honeycomb-grid'
-import { map, mapIndexed, remove } from 'transducist'
+import { createHexPrototype, Grid, rectangle, tap } from 'honeycomb-grid'
+import { mapIndexed, remove } from 'transducist'
 import { aStar } from './aStar'
 import { getTileFill, render } from './render'
 import { Tile } from './types'
@@ -20,18 +20,16 @@ const hexPrototype = createHexPrototype<Tile>({
   },
 })
 const grid = new Grid(hexPrototype, rectangle({ width: 24, height: 12 })).update([
-  map((tile) => {
+  tap((tile) => {
     if (tile.equals(START_COORDINATES) || tile.equals(TARGET_COORDINATES)) {
       tile.cost = 1
-      return tile
+      return
     }
 
     tile.cost = Math.random() > IMPASSABLE_CHANCE ? Math.floor(Math.random() * MAX_COST) : IMPASSABLE_COST
-    return tile
   }),
-  map((tile) => {
+  tap((tile) => {
     tile.svg = render(tile)
-    return tile
   }),
 ])
 const shortestPath = aStar<Tile>({

examples/line-of-sight/index.ts

@@ -12,11 +12,12 @@ import {
   PartialCubeCoordinates,
   repeatWith,
   ring,
+  tap,
   transduce,
   Traverser,
   TupleCoordinates,
 } from 'honeycomb-grid'
-import { filter, map, takeWhile, toArray } from 'transducist'
+import { filter, takeWhile, toArray } from 'transducist'
 import { initialGameState, onUpdate, updateGameState } from './gameState'
 import { renderMap, renderPlayer } from './render'
 import { TILES } from './tiles'
@@ -53,22 +54,19 @@ updateGameState(initialGameState)
 function updateDiscoveredHexes(grid: Grid<Tile>) {
   grid.update([
     filter((tile) => tile.visibility === 'visible'),
-    // todo: create each() transducer for these things?
-    map((tile) => {
+    tap((tile) => {
       tile.element.first().addClass('discovered')
-      return tile
     }),
   ])
 }
 
 function updateFieldOfView(grid: Grid<Tile>, start: HexCoordinates) {
   grid.update(
     [
-      map((tile) => {
+      tap((tile) => {
         tile.visibility = 'visible'
         tile.element.first().removeClass('discovered')
         tile.element.first().removeClass('undiscovered')
-        return tile
       }),
     ],
     fieldOfView(start),
@@ -96,9 +94,8 @@ function lineOfSight(start: HexCoordinates): Traverser<Tile> {
       // todo: instead of keeping state like this, try making a reduce() transducer?
       [
         takeWhile(() => !foundOpaqueTerrain),
-        map((tile) => {
+        tap((tile) => {
           foundOpaqueTerrain = tile.terrain.opaque
-          return tile
         }),
       ],
       toArray(),

examples/line-of-sight/render.ts

@@ -1,14 +1,11 @@
 import { Svg } from '@svgdotjs/svg.js'
-import { Grid } from 'honeycomb-grid'
-import { map } from 'transducist'
+import { Grid, tap } from 'honeycomb-grid'
 import { Tile } from './types'
 
 export function renderMap(draw: Svg, grid: Grid<Tile>) {
   grid.update(
-    // todo: expose map() via honeycomb
-    map((tile) => {
+    tap((tile) => {
       tile.element = renderTile(draw, tile)
-      return tile
     }),
   )
 }

src/grid/index.ts

@@ -1,5 +1,6 @@
 export * from './functions'
 export * from './grid'
 export * from './transduce'
+export * from './transducers'
 export * from './traversers'
 export * from './types'

src/grid/transducers/index.ts

@@ -1 +1,2 @@
 export * from './inGrid'
+export * from './tap'

src/grid/transducers/tap.ts

@@ -0,0 +1,14 @@
+import { Transducer } from 'transducist'
+import { Hex } from '../../hex'
+import { INIT, RESULT, STEP } from '../constants'
+
+export const tap =
+  <T extends Hex>(fn: (hex: T) => void): Transducer<T, T> =>
+  (xf) => ({
+    [INIT]: () => xf[INIT](),
+    [RESULT]: (result) => xf[RESULT](result),
+    [STEP]: (result, hex) => {
+      fn(hex)
+      return xf[STEP](result, hex)
+    },
+  })