CODEWITHSUNDEEP
haskelltypesfrpreactive-banana
user1198582
user1198582

Reputation:

Functional Reactive Banana - type confusion

Heinrich Apfelmus generously chimed in on this problem. I had considered using accumB as a solution, but thought there would be a type error. After trying his suggestion anyway, I did recieve a type error.

let bGameState :: Behavior t GameState
    bGameState = accumB initialGS $ updateGS <$ eInput

yields the error

 Couldn't match expected type `GameState'
             with actual type `PlayerCommand'
 Expected type: GameState -> GameState
   Actual type: PlayerCommand -> GameState -> GameState
 In the first argument of `(<$)', namely `updateGS'
 In the second argument of `($)', namely `updateGS <$ eInput'

So I studied (<$), and messed around with partial application. Looked at his suggested examples. The more I did this, the more I thought the above code should work, and I am baffled as to why it doesn't.

This is what I think should be happening:

since (<$) is of type (<$) :: a -> f b -> f a

and updateGS is of type updateGS :: PlayerCommand -> GameState -> GameState

and eInput is of type Event t PlayerCommand

then should not updateGS <$ eInput yield

Event t (GameState -> GameState) ?

My reasoning is flawed somewhere, could someone point out where?

Update: when I tried using (<$>) I recieved the following error

outline.hs:158:21:

Could not deduce (t ~ t1)
from the context (Frameworks t)
  bound by a type expected by the context:
             Frameworks t => Moment t ()
  at outline.hs:(153,42)-(159,93)
  `t' is a rigid type variable bound by
      a type expected by the context: Frameworks t => Moment t ()
      at outline.hs:153:42
  `t1' is a rigid type variable bound by
       the type signature for bGameState :: Behavior t1 GameState
       at outline.hs:158:8
Expected type: Behavior t1 GameState
  Actual type: Behavior t GameState
In the expression: accumB initialGS $ updateGS <$> eInput
In an equation for `bGameState':
    bGameState = accumB initialGS $ updateGS <$> eInput

for reference, here is the whole function

makeNetworkDescription :: AddHandler PlayerCommand -> IO EventNetwork
makeNetworkDescription addCommandEvent = compile $ do
   eInput <- fromAddHandler addCommandEvent
   let bCommand = stepper Null eInput
   eCommandChanged <- changes bCommand
   let bGameState :: Behavior t GameState
       bGameState = accumB initialGS $ updateGS <$> eInput
   reactimate $ (\n -> appendFile "output.txt" ("Command is " ++ show n)) <$>    
   eCommandChanged

Upvotes: 4

Views: 150

Answers (1)

hammar
hammar

Reputation: 139870

What's wrong with the code

You should be using <$>, not <$.

  • <$>, a.k.a. fmap applies a function to the value of the right hand side events, which is what you're trying to do in this case.

  • <$ replaces the value of the right hand side events with the left hand side, giving you an event which occurs at the same time as the original, but which always contains the same value.

    Note: x <$ e is the same as const x <$> e.

Why your reasoning is wrong

We're trying to determine the type of updateGS <$ eInput where the types of the subterms are:

(<$)     :: a -> f b -> f a
updateGS :: PlayerCommand -> GameState -> GameState
eInput   :: Event t PlayerCommand

Now think: what types must a, b and f be instantiated to?

  1. Since updateGS is the first argument to <$ which has type a, we must have 

    a ~ PlayerCommand -> GameState -> GameState

  2. Similarly, eInput is the second argument to <$ which has type f b, so

    f b ~ Event t PlayerCommand

    Type application associates to the left, so Event t PlayerCommand is the same as (Event t) PlayerCommand. We can therefore determine that

    f ~ Event t
b ~ PlayerCommand

  3. Putting together the type of the result, f a, we see that

    f a ~ Event t (PlayerCommand -> GameState -> GameState)

Therefore, updateGS <$ eInput :: Event t (PlayerCommand -> GameState -> GameState), which explains the type error.

Upvotes: 4

Related Questions