How to serialize function type to json in haskell?

Question

data Task = Task
    { id :: String
    , description :: String
    , dependsOn :: [String]
    , dependentTasks :: [String]
    } deriving (Eq, Show, Generic, ToJSON, FromJSON)

type Storage = Map String Task

s :: Storage
s = empty

addTask :: Task -> Storage -> Storage
addTask (Task id desc dep dept) = insert id (Task id desc dep dept)

removeTask :: String -> Storage -> Storage
removeTask tid = delete tid

changes = [addTask (Task "1" "Description" [] []), removeTask "1"]

main = putStrLn . show $ foldl (\s c -> c s) s changes

Suppose I have the following code. I want to store changes list in a json file. But I don't know how to do that with Aeson, aside probably from writing a custom parser and there must be a better way to do that obviously. Like maybe using language extension to derive (Generic, ToJSON, FromJSON) for addTask and removeTask etc...

EDIT. For all people that say "You can't serialize function".

Read the comments to an answer to this question.

Instance Show for function

That said, it's not possible to define Show to actually give you more ? detail about the function. – Louis Wasserman May 12 '12 at 14:51

Sure it is. It can show the type (given via Typeable); or it can show some of the inputs and outputs (as is done in QuickCheck).

EDIT2. Okay, I got that I can't have function name in serialization. But can this be done via template Haskell? I see that aeson supports serialization via template Haskell, but as newcomer to Haskell can't figure out how to do that.

Answer 1

Reading between the lines a bit, a recurring question here is, "Why can't I serialize a function (easily)?" The answer -- which several people have mentioned, but not explained clearly -- is that Haskell is dedicated to referential transparency. Referential transparency says that you can replace a definition with its defined value (and vice versa) without changing the meaning of the program.

So now, let's suppose we had a hypothetical serializeFunction, which in the presence of this code:

foo x y = x + y + 3

Would have this behavior:

> serializeFunction (foo 5)
"foo 5"

I guess you wouldn't object too strenuously if I also claimed that in the presence of

bar x y = x + y + 3

we would "want" this behavior:

> serializeFunction (bar 5)
"bar 5"

And now we have a problem, because by referential transparency

  serializeFunction (foo 5)
= { definition of foo }
  serializeFunction (\y -> 5 + y + 3)
= { definition of bar }
  serializeFunction (bar 5)

but "foo 5" does not equal "bar 5".

The obvious followup question is: why do we demand referential transparency? There are at least two good reasons: first, it allows equational reasoning like above, hence eases the burden of refactoring; and second, it reduces the amount of runtime information that's needed, hence improving performance.

Of course, if you can come up with a representation of functions that respects referential transparency, that poses no problems. Here are some ideas in that direction:

• printing the type of the function

  instance (Typeable a, Typeable b) => Show (a -> b) where
      show = show . typeOf
  -- can only write a Read instance for trivial functions
  

• printing the input-output behavior of the function (which can also be read back in)

• creating a data type that combines a function with its name, and then printing that name

  data Named a = Named String a
  instance Show (Named a) where
      show (Named n _) = n
  -- perhaps you could write an instance Read (Map String a -> Named a)
  

  (and see also cloud haskell for a more complete working of this idea)

• constructing an algebraic data type that can represent all the expressions you care about but contains only basic types that already have a Show instance and serializing that (e.g. as described in the other answer)

But printing a bare function's name is in conflict with referential transparency.

Answer 2

Make a data type for your functions and an evaluation function:

data TaskFunction = AddTask Task | RemoveTask String 
  deriving (Eq, Show, Generic, ToJSON, FromJSON)

eval :: TaskFunction -> Storage -> Storage
eval (AddTask t) = addTask t
eval (RemoveTask t) = removeTask t

changes = [AddTask (Task "1" "Description" [] []), RemoveTask "1"]

main = putStrLn . show $ foldl (\s c -> c s) s (eval <$> changes)