The model package

[Tags:bsd3, library, test]

See the online tutorial.


[Skip to Readme]

Properties

Versions 0.2, 0.2.1, 0.2.4, 0.3
Change log CHANGELOG
Dependencies base (>=4.8 && <5), containers (>=0.5.6.2), deepseq (>=1.4), ListLike (>=4.2.1), pretty (>=1.1.2.0), transformers (>=0.4) [details]
License BSD3
Copyright Copyright: (c) 2016 Pasqualino `Titto` Assini
Author Pasqualino `Titto` Assini
Maintainer tittoassini@gmail.com
Category Data, Reflection, Generics
Home page http://github.com/tittoassini/model
Source repository head: git clone https://github.com/tittoassini/model
Uploaded Tue May 16 12:20:27 UTC 2017 by PasqualinoAssini
Distributions NixOS:0.3, Stackage:0.3
Downloads 174 total (11 in the last 30 days)
Votes
0 []
Status Docs available [build log]
Last success reported on 2017-05-16 [all 1 reports]
Hackage Matrix CI

Modules

[Index]

Downloads

Maintainer's Corner

For package maintainers and hackage trustees

Readme for model

Readme for model-0.3

Build Status Hackage version

With model you can easily derive models of Haskell data types.

Let's see some code.

We need a couple of GHC extensions:

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

Import the library:

import Data.Model

To derive a model of a data type we need to make it an instance of the Generic and Model classes.

For data types without parameters, we can do it directly in the deriving clause of the definition:

data Direction = North | South | Center | East | West deriving (Show,Generic,Model)

For data types with parameters we currently need a separate instance declaration for Model:

data Couple a b = Couple a b deriving (Show,Generic)
instance (Model a,Model b) => Model (Couple a b)

Instances for a few common types (Bool,Maybe,Either..) are already predefined.

We use typeModel to get the model for the given type plus its full environment, that's to say the models of all the data types referred to, directly or indirectly by the data type.

We pass the type using a Proxy.

typeModel (Proxy:: Proxy (Couple Direction Bool))
-> TypeModel
->   { typeName =
->       TypeApp
->         (TypeApp
->            (TypeCon
->               QualName
->                 { pkgName = "main" , mdlName = "Main" , locName = "Couple" })
->            (TypeCon
->               QualName
->                 { pkgName = "main" , mdlName = "Main" , locName = "Direction" }))
->         (TypeCon
->            QualName
->              { pkgName = "ghc-prim"
->              , mdlName = "GHC.Types"
->              , locName = "Bool"
->              })
->   , typeEnv =
->       fromList
->         [ ( QualName
->               { pkgName = "ghc-prim" , mdlName = "GHC.Types" , locName = "Bool" }
->           , ADT
->               { declName = "Bool"
->               , declNumParameters = 0
->               , declCons =
->                   Just
->                     (ConTree
->                        Con { constrName = "False" , constrFields = Left [] }
->                        Con { constrName = "True" , constrFields = Left [] })
->               }
->           )
->         , ( QualName
->               { pkgName = "main" , mdlName = "Main" , locName = "Couple" }
->           , ADT
->               { declName = "Couple"
->               , declNumParameters = 2
->               , declCons =
->                   Just
->                     Con
->                       { constrName = "Couple"
->                       , constrFields = Left [ TypeCon (TypVar 0) , TypeCon (TypVar 1) ]
->                       }
->               }
->           )
->         , ( QualName
->               { pkgName = "main" , mdlName = "Main" , locName = "Direction" }
->           , ADT
->               { declName = "Direction"
->               , declNumParameters = 0
->               , declCons =
->                   Just
->                     (ConTree
->                        (ConTree
->                           Con { constrName = "North" , constrFields = Left [] }
->                           Con { constrName = "South" , constrFields = Left [] })
->                        (ConTree
->                           Con { constrName = "Center" , constrFields = Left [] }
->                           (ConTree
->                              Con { constrName = "East" , constrFields = Left [] }
->                              Con { constrName = "West" , constrFields = Left [] })))
->               }
->           )
->         ]
->   }

That's a lot of information, let's show it in a prettier and more compact way:

pPrint $ typeModel (Proxy:: Proxy (Couple Direction Bool))
-> Type:
-> main.Main.Couple main.Main.Direction
->                  ghc-prim.GHC.Types.Bool -> Couple Direction Bool
-> Environment:
-> ghc-prim.GHC.Types.Bool ->  Bool ≡   False
->         | True
-> main.Main.Couple ->  Couple a b ≡ Couple a b
-> main.Main.Direction ->  Direction ≡   North
->              | South
->              | Center
->              | East
->              | West

Data types with symbolic names are also supported:

instance (Model a) => Model [a]
pPrint $ typeModel (Proxy:: Proxy [Bool])
-> Type:
-> ghc-prim.GHC.Types.[] ghc-prim.GHC.Types.Bool -> [] Bool
-> Environment:
-> ghc-prim.GHC.Types.Bool ->  Bool ≡   False
->         | True
-> ghc-prim.GHC.Types.[] ->  [] a ≡   []
->         | : a (ghc-prim.GHC.Types.[] a)

Installation

Get the latest stable version from hackage.

Compatibility

Tested with ghc 7.10.3 and 8.0.2.

Known Bugs and Infelicities

  • No support for variables of higher kind.

    For example, we cannot define a Model instance for Higher:

    data Higher f a = Higher (f a) deriving Generic

    as f has kind *->*:

  • Parametric data types cannot derive Model in the deriving clause and need to define an instance separately

    For example:

    data Couple a b = Couple a b Bool deriving (Generic,Model)

    won't work, we need a separate instance:

    instance (Model a,Model b) => Model (Couple a b)

  • Works incorrectly with data types with more than 9 type variables.