ramda/ramda

Hi, I'm creating a simple tic-tac-toe style game and game state is stored in a game object.

I've noticed two problems:
1- most of my functions need access to the game object so I need to repeatedly pass it down.
2- because of #1 when I try to compose with a pipeline I often need to curry some functions with the game object.

Both seem like code smells. Is this typical? Any advice to improve?

(This code uses folktale Result)

import {
  pipeWith,
  chain,
  curry,
  add,
  multiply,
  update,
  evolve,
} from "ramda";
import folktale from "folktale";
const { result: Result } = folktale;

const createGame = ({ width, height } = {}) => ({
  size: {
    width,
    height,
  },
  grid: Array(width * height), // game is a grid but stored as a flat array
  // additional game state goes here
});

//
// 1) most of my functions need access to the game object so I'm repeatedly passing it down. is this typical?
//
const gridIndex = (game, pos) => add(pos[0], multiply(pos[1], game.size.width));
const cell = (game, pos) => game.grid[gridIndex(game, pos)];
const updateCell = (game, pos, val) =>
  evolve({
    grid: (g) => update(gridIndex(game, pos), val, g),
  })(game);

// two contrived validators that don't require the game object
const validateColGte0 = (pos) =>
  pos[0] >= 0 ? Result.Ok(pos) : Result.Error(`col must be >= 0: ${pos[0]}`);
const validateRowGte0 = (pos) =>
  pos[1] >= 0 ? Result.Ok(pos) : Result.Error(`row must be >= 0: ${pos[1]}`);
// three validators that need the game object
const validateColLtWidth = curry((game, pos) =>
  pos[0] < game.size.width
    ? Result.Ok(pos)
    : Result.Error(`col must be < ${game.size.width}: ${pos[0]}`)
);
const validateRowLtHeight = curry((game, pos) =>
  pos[1] < game.size.height
    ? Result.Ok(pos)
    : Result.Error(`row must be < ${game.size.height}: ${pos[1]}`)
);
const validateCellIsEmpty = curry((game, pos) =>
  !cell(game, pos)
    ? Result.Ok(pos)
    : Result.Error(`position is not empty: ${pos}`)
);
//
// 2) To compose functions in a pipline I need to curry them with the game object
//    would it be better to make the validator signatures take a single object 
//    with all possible paramaters? e.g. { game, pos }
//
const validatePosition = (game, pos) =>
  pipeWith(chain)([
    validateColGte0,
    validateRowGte0,
    validateColLtWidth(game),
    validateRowLtHeight(game),
    validateCellIsEmpty(game),
  ])(pos);
const performMove = (game, pos, val) =>
  validatePosition(game, pos).matchWith({
    Ok: ({ value: validatedPosition }) =>
      updateCell(game, validatedPosition, val),
    Error: ({ value: error }) => {
      console.log(error);
      return game;
    },
  });

// create and run the game
let game = createGame({ width: 3, height: 3 });
console.log(game);
game = performMove(game, [1, 1], "X"); // works
console.log(game);
game = performMove(game, [1, 1], "O"); // position is not empty: 1,1
console.log(game);