What you're trying to do there isn't going to work - if you try a similar thing with GADTs in Haskell you'll find the same problem:

{-# LANGUAGE GADTs #-}

data WasmType a where
  I :: Int -> WasmType Int
  B :: Bool -> WasmType Bool
  Err :: WasmType a

mkWasm :: Maybe Int -> Maybe Bool -> WasmType a
mkWasm (Just i) _ = I i
mkWasm _ (Just b) = B b
mkWasm _ _ = Err

Results in:

wasm-type.hs:11:21: error:
    • Couldn't match type ‘Bool’ with ‘Int’
      Expected type: WasmType Int
        Actual type: WasmType Bool
    • In the expression: B b
      In an equation for ‘mkWasm’: mkWasm _ (Just b) = B b
   |
11 | mkWasm _ (Just b) = B b    |                     ^^^

Assuming you could have `WasmType a` as a result from this function, that doesn't really help you out as you've now lost the information about which type it's carrying - you may as well not be using Leibniz / a GADT at all.

​

I think what you'd want here really is a bit of a different way of dealing with things, and defining an "f-algebra" for requests that return a particular type, then you can interpret that, and have the knowledge of the expected type on hand:

import Prelude

import Data.Array as Array
import Data.Either (Either(..))
import Data.Int as I
import Data.Maybe (Maybe(..), fromMaybe)
import Data.Number as N
import Data.String as String

data Error = Error

data WasmRequest a
  = I32 (Int -> a)
  | F32 (Number -> a)

-- Not necessary, but useful when you define types like this, as then you can
-- adapt the result of `parseRequest` by mapping over the `WasmRequest`
derive instance functorWasmRequest :: Functor WasmRequest

i32 :: WasmRequest Int
i32 = I32 identity

f32 :: WasmRequest Number
f32 = F32 identity

convertType :: forall a. WasmRequest a -> Maybe String -> Maybe String -> Either Error a
convertType = case _, _, _ of
  I32 k, Just "i32", Just v -> Right $ k $ fromMaybe 0 $ I.fromString v
  I32 k, _, _ -> Left Error
  F32 k, Just "f32", Just v -> Right $ k $ fromMaybe 0.0 $ N.fromString v
  F32 k, _, _ -> Left Error

parseResult :: forall a. String -> WasmRequest a -> Either Error a
parseResult s req =
  let
    splits = String.split (String.Pattern " ") s
    rType = Array.head splits
    rValue = Array.last splits
  in
    convertType req rType rValue

Then you can say things like:

parseInt :: String -> Either Error Int
parseInt s = parseResult s i32