Data.Vector.Mutable field can not be written/set properly? : Haskell

Question

I have struggled for days to compose a data structure that has a field of mutable value of Data.Vector.Mutable

I confirmed Data.Vector.Mutable itself behaves as I expected; however once it's included into a structure, somehow stops working against my expectation.

Below is a demo-code that simply has newVal, getVal and setVal targeting the mutable field value of the structure.

newIO is the constructor of the data structure typed as newIO :: a -> A a.

module Main where
import Control.Monad.Primitive (PrimMonad (PrimState))
import qualified Data.Vector.Mutable as M 
------------------------------------ 
data A a = A
  { ioVal :: IO (M.MVector (PrimState IO) a)
  }

newIO :: a -> A a
newIO = \a -> A (newVal a)
------------------------------
newVal :: a -> IO (M.MVector (PrimState IO) a)
newVal = \a -> do
  val <- M.new 1
  M.write val 0 a
  return val

getVal :: A a -> IO a
getVal = \aA -> do
  val <- ioVal aA
  M.read val 0

setVal :: a -> A a -> IO ()
setVal = \a -> \aA -> do
  val <- ioVal aA
  M.write val 0 a
------------------------------
main :: IO ()
main = do
  let ioA = newIO (5 :: Int)
  (getVal ioA) >>= print -- 5
  setVal 10 ioA
  (getVal ioA) >>= print -- 5 ?? expected 10

So, here, to confirm the basic behavior of set/get of the structure, I try to create, read, (re)write, and (re)read the mutable value of the field; however, it does not work as expected as the set should perform.

What's wrong with the code? Please advise.

Reading about [`let` vs `<-`](https://stackoverflow.com/questions/28624408/equal-vs-left-arrow-symbols-in-haskell) could help. — chi, Feb 10 '22 at 23:25
@chi Thank you. I thought I understand the de-sugar of `do`, but obviously not entough to make the mistake as you kindly thoroughly explained. — Functor, Feb 10 '22 at 23:36

chi · Accepted Answer · 2022-02-10T23:20:36.180

A main property of Haskell is referential transparency: we can always replace defined entities with their definitions. Now consider the posted code:

main :: IO ()
main = do
  let ioA = newIO (5 :: Int)
  (getVal ioA) >>= print -- 5
  setVal 10 ioA
  (getVal ioA) >>= print -- 5 ?? expected 10

This defines ioA, so we can replace it with its own definition. We get:

main :: IO ()
main = do
  (getVal (newIO (5 :: Int))) >>= print -- 5
  setVal 10 (newIO (5 :: Int))
  (getVal (newIO (5 :: Int))) >>= print -- 5 ?? expected 10

Now we can see the problem: we create three independent vectors. The issue is that let ioA = ... defines an IO action (roughly, an imperative procedure) that we can call multiple times later on. But we don't want that: we want newIO (5 :: Int) to be executed only once.

For that, we must avoid let and use monadic bind (<-, in do blocks).

main :: IO ()
main = do
  ioA <- newIO (5 :: Int)   -- run the action, just once
  (getVal ioA) >>= print
  setVal 10 ioA
  (getVal ioA) >>= print

This will trigger a bunch of type errors, since e.g. getVal is no longer passed an IO action, but is passed the result of the IO action. This is what we want, though, so we need to fix the types accordingly.

Start by removing IO here:

data A a = A
  { ioVal :: M.MVector (PrimState IO) a
  }

Indeed, we don't want to store a procedure that makes a vector, we want to store the vector.

Consequently, we need to remove <- in favor of let in a few other points.

getVal :: A a -> IO a
getVal = \aA -> do
  let val = ioVal aA  -- no IO action to run here
  M.read val 0

Also, newIO must return an IO value.

newIO :: a -> IO (A a)
newIO = \a -> fmap A (newVal a)

I think you can figure out the rest now.

Thanks for your elaborated answer!! I understand now. In fact, I tried this pattern and worked before I ask this Questtion, and thre reason I wanted to make it `newIO :: a -> A a` is.. When I implement a functor/monad on this, with `newIO :: a -> IO (A a)` I have to write `ioA |> fmap f >>= fmap f` then I wanted to avoid the mix of the pipeline-operator and monad-operator. — Functor, Feb 10 '22 at 23:42
Now, I understand it seems I have to give up having a type of `newIO :: a -> A a` as the foundation. Your explanation does make sense. Thanks again. — Functor, Feb 10 '22 at 23:43
I really appreciate it. This answer leads me a proper deeper understanding do/IO-monad handling. — Functor, Feb 11 '22 at 00:09
I made new Quesion. https://stackoverflow.com/questions/71082667/what-would-be-the-concise-simplest-identity-monad-with-mutable-io-in-haskell — Functor, Feb 11 '22 at 15:46

Data.Vector.Mutable field can not be written/set properly? : Haskell

1 Answers1