some-dict-of: Carry evidence of constraints around

[ bsd3, constraints, library ] [ Propose Tags ] [ Report a vulnerability ]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees

Candidates

  • No Candidates
Versions [RSS] 0.1.0.0, 0.1.0.1, 0.1.0.2
Change log changelog.md
Dependencies base (>=4.10 && <5), constraints [details]
License BSD-3-Clause
Copyright Matt Parsons
Author Matt Parsons
Maintainer parsonsmatt@gmail.com
Category Constraints
Home page https://github.com/parsonsmatt/some-dict-of#readme
Bug tracker https://github.com/parsonsmatt/some-dict-of/issues
Source repo head: git clone https://github.com/parsonsmatt/some-dict-of
Uploaded by parsonsmatt at 2021-09-20T23:01:13Z
Distributions LTSHaskell:0.1.0.2, NixOS:0.1.0.2, Stackage:0.1.0.2
Reverse Dependencies 3 direct, 0 indirect [details]
Downloads 711 total (13 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs available [build log]
Last success reported on 2021-09-21 [all 1 reports]

Readme for some-dict-of-0.1.0.2

[back to package description]

some-dict-of

Have you ever needed an existential wrapper that just guaranteed class membership, but you didn't need to know the specifics of the type in question?

Well, you probably don't - it's not idiomatic Haskell for the most part. But sometimes this comes up, and I wanted a nice packaging of the technique. I wrote this mostly to support the discover-instances library.

SomeDictOf

Let's consider a type that wraps anything that can be shown, along with a value of that type. We can make one by hand like this:

data SomeShowable where
    SomeShowable :: forall a. Show a => a -> SomeShowable

showList :: [SomeShowable] -> [String]
showList = map (\(SomeShowable a) -> show a)

With SomeDictOf, we can generalize this pattern to other classes and even other containers.

someShowable :: SomeDictOf Identity Show
someShowable =
    SomeDictOf (Identity (3 :: Int))

We're carrying an Int, but the type does not reveal this. We can create a list of values like this, and we can call show on them.

showValues
    :: [SomeDictOf Identity Show]
    -> [String]
showValues =
    map (\(SomeDictOf (Identity showable)) -> show showable)

We can also carry around evidence of a type class instance, and then write generic stuff based on it. Consider the PersistEntity from the persistent database library.

tables :: [SomeDictOf Proxy PersistEntity]
tables = [ SomeDictOf (Proxy @User), SomeDictOf (Proxy @Organization) ]

Now we can iterate over these types and, say, load all the rows out of the database and verify they parse.

checkRows :: SqlPersistT [[PersistValue]]
checkRows = do
    forM tables $ \(SomeDictOf (Proxy :: Proxy table)) -> do
        results <- selectList [] [] :: SqlPersistT m [Entity table]
        pure (map toPersistValue results)

Or we can do some metaprogramming based on their EntityDefs, since PersistEntity has a method Proxy a -> EntityDef.

getDefinitions :: [EntityDef]
getDefinitions =
    map (\(SomeDictOf p) -> entityDef p) tables