The type variable r has escaped its scope - purescript

Question

I have a type synonym for a puzzle defined as shown here:
type Cell = Int
type Board = Array Cell
type Puzzle = forall r.
{ board::Board
, meta::
{ metaData :: {|r}
, metaBoard :: (Array {|r})
}
}
I have also included the idea that a strategy takes a Puzzle and returns it wrapped in one of three states
type Strategy = Puzzle -> (Stateful Puzzle)
data Stateful a =
Advancing a
| Stable a
| Finished a
Finally, I have a function that brings us back in line (a bit) with how Either works. The idea being that eventually I can start composing strategies until the finished state is reached.
advanceOrFinish :: (Stateful Puzzle) -> (Stateful Puzzle)
advanceOrFinish (Advancing puzzle)
| isSolvedOrInvalid puzzle.board = Finished puzzle
| otherwise = Advancing puzzle
advanceOrFinish (Stable puzzle)
| isSolvedOrInvalid puzzle.board = Finished puzzle
| otherwise = Advancing puzzle
advanceOrFinish (Finished puzzle) = Finished puzzle
The problem is that I'm getting this error:
The type variable r, bound at
src/SC.purs:23:15 - 29:4 (line 23, column 15 - line 29, column 4)
has escaped its scope, appearing in the type
{ board :: Array Int
, meta :: { metaBoard :: Array (Record r7)
, metaData :: Record r7
}
}
The same function without Stateful (while useless) doesn't have this issue. So this is fine:
advanceOrFinish :: Puzzle -> Puzzle
advanceOrFinish puzzle
| isSolvedOrInvalid puzzle.board = puzzle
| otherwise = puzzle
What is this error trying to tell me?

Answer 1

type Puzzle = forall r. ... doesn't mean what you think it means.
If you have a variable:
p :: Puzzle
And then you want to do something with that variable, like:
b = p.board
At that moment, when you're referring to p by name, you get to choose a type r, and then the variable p must somehow "become" of that type, meaning that p.meta.metaData :: {|r}.
And this happens every time you access the variable p. Each time you choose some type r (and these could be different types every time), and each time the field p.meta.metaData would have to be of that type.
Quite obviously, this could not reasonably work. Quite obviously, this is not what you meant.
forall means "I will work for all types" - that's literally in the name. The consumer chooses which type, not the implementer.
What you probably meant was to have a Puzzle with a type parameter, so that whoever creates an instance of Puzzle can choose the type at that moment, and then the instance of Puzzle will go on with that type.
The syntax for doing that is this:
type Puzzle r =
{ board::Board
, meta::
{ metaData :: {|r}
, metaBoard :: (Array {|r})
}
}
Here r is called "type parameter" of Puzzle.
Then, whenever you refer to Puzzle, you have to say what r is in that case, for example:
foo :: Puzzle (a :: Int) -> Int
foo p = p.meta.metaData.a
bar :: Puzzle (x :: String) -> Unit
bar _ = unit
And if you don't care what it is, it can be generic too:
advanceOrFinish :: forall r. Puzzle r -> Puzzle r
advanceOrFinish puzzle
| isSolvedOrInvalid puzzle.board = puzzle
| otherwise = puzzle