FromJSON instance with DataKinds

Question

Trying to do the JSON de-serialisation for a data type with TypeLits, I get stuck with the following problem:

Couldn't match type ‘n’ with ‘2’
      ‘n’ is a rigid type variable bound by
        the instance declaration at test.hs:14:10
      Expected type: aeson-0.11.2.1:Data.Aeson.Types.Internal.Parser
                       (X n)
        Actual type: aeson-0.11.2.1:Data.Aeson.Types.Internal.Parser
                       (X 2)

How would be the correct syntax to allow Nat generically in the FromJSON instance in the following example:

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE OverloadedStrings #-}

import GHC.TypeLits
import Data.Aeson
import Control.Monad (mzero)

data X (n :: Nat) where
  A :: Integer -> X 1
  B :: Integer -> X 2

instance FromJSON (X n) where
  parseJSON (Object o) = do
      v <- o .: "val"
      t <- o .: "type"
      case t of
        "a" -> return $ A v
        "b" -> return $ B v
  parseJSON _       = mzero

You probably need separate instances for FromJSON (X 1) and FromJSON (X 2), or do a typecase on n (using a singleton). The way you have the instance written says that you can read X n for any n the caller chooses. — luqui
– luqui, Commented Dec 17, 2016 at 18:58

shang · Accepted Answer · 2016-12-18 10:25:21Z

4

Since you obviously cannot know the type you are going to deserialize at compile time, the exact type needs to be hidden in an existential and then restored via pattern matching. I usually use a generic Some type to hide phantom types.

{-# LANGUAGE PolyKinds #-}

data Some (t :: k -> *) where
    Some :: t x -> Some t

Now you can write the instance as

instance FromJSON (Some X) where
    parseJSON (Object o) = do
        v <- o .: "val"
        t <- o .: "type"
        case (t :: String) of
          "a" -> return $ Some $ A v
          "b" -> return $ Some $ B v
    parseJSON _       = mzero

However, you also need to enable the FlexibleInstances extension.

answered Dec 18, 2016 at 10:25

shang

24.9k3 gold badges61 silver badges87 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

dfeuer Over a year ago

You can avoid FlexibleInstances by using a specialized data SomeX = forall n . SomeX (X n), if you like. What does the generic version win you?

shang Over a year ago

Nothing in this simple example, for sure. However, I wanted to include the more generic version since you usually have several different types in an application from which you want to temporarily hide the type parameter.

Collectives™ on Stack Overflow

FromJSON instance with DataKinds

1 Answer 1

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related