{"id":401,"date":"2022-08-30T15:00:44","date_gmt":"2022-08-30T15:00:44","guid":{"rendered":"https:\/\/unknownerror.org\/index.php\/2013\/11\/09\/generate-the-list-of-ints-associated-with-an-enum-type-collection-of-common-programming-errors\/"},"modified":"2022-08-30T15:00:44","modified_gmt":"2022-08-30T15:00:44","slug":"generate-the-list-of-ints-associated-with-an-enum-type-collection-of-common-programming-errors","status":"publish","type":"post","link":"https:\/\/unknownerror.org\/index.php\/2022\/08\/30\/generate-the-list-of-ints-associated-with-an-enum-type-collection-of-common-programming-errors\/","title":{"rendered":"Generate the list of Ints associated with an Enum type-Collection of common programming errors"},"content":{"rendered":"

I have a utility function that enumerates all values of a type that is both enumerable and bounded:<\/p>\n

enumerate :: (Enum a, Bounded a) => [a]\nenumerate = [minBound .. maxBound]\n<\/code><\/pre>\n
and a data type that involves mapping enumerable types to integers:<\/p>\n
data Attribute a = Attribute { test :: a -> Int\n                             , vals :: [Int]\n                             , name :: String }\n<\/code><\/pre>\n
Where vals<\/code> is the list of integers representing all possible enumerable values. For example, if I had<\/p>\n
data Foo = Zero | One | Two deriving (Enum,Bounded)\n<\/code><\/pre>\n
then vals<\/code> would be [0,1,2]<\/code>.<\/p>\n
I want to be able to create these attributes programatically, just given a function that maps an a<\/code> to an enumerable type, and a name. Something like this:<\/p>\n
attribute :: (Enum b, Bounded b) => (a -> b) -> String -> Attribute a\nattribute f str = Attribute (fromEnum . f) vs str\n  where\n    vs = map fromEnum enumerate\n<\/code><\/pre>\n
This doesn’t typecheck, because there’s no way of connecting the call to enumerate<\/code> with the b<\/code> in the type signature. So I thought I could do this:<\/p>\n
vs = map fromEnum $ enumerate :: [b]\n<\/code><\/pre>\n
but that doesn’t compile either – the compiler renames that b<\/code> to b1<\/code>. I tried to be smarter, using the GADTs extension:<\/p>\n
attribute :: (Enum b, Bounded b, b ~ c) => {- ... -}\nvs = map fromEnum $ enumerate :: (Enum c,Bounded c) => [c]\n<\/code><\/pre>\n
but again, the c<\/code> is renamed to c1<\/code>.<\/p>\n
I don’t want to include the type of b<\/code> as a parameter in the Attribute<\/code> type (mainly because I want to store lists of attributes with potentially different values of b<\/code> – that’s why test<\/code> has type a -> Int<\/code> and vals<\/code> has type [Int]<\/code>).<\/p>\n
How can I write this code so that it does what I want it to do?<\/p>\n
    \n
  1. \n
    The problem with type variables is that they are only bound in the type signature. Any use of type variables inside definition will refer to new, fresh type variable (even though it has the exact same name as in the type signature).<\/p>\n
    There are two ways to refer to type variables from signature: ScopedTypeVariables<\/code> extension and asTypeOf<\/code>.<\/p>\n
    With ScopedTypeVariables<\/code> a type variable explicitly bound with forall<\/code> is also available in definition, thus:<\/p>\n
    attribute :: forall a b. (Enum b, Bounded b) =>\n             (a -> b) -> String -> Attribute a\nattribute f str = Attribute (fromEnum . f) vs str\n  where\n    vs = map fromEnum (enumerate :: [b])\n<\/code><\/pre>\n
    The other way involves function asTypeOf<\/code> defined as:<\/p>\n
    asTypeOf :: a -> a -> a\nasTypeOf = const\n<\/code><\/pre>\n
    If we can get an expression of type [b]<\/code> into the second parameter, unification will make sure that first parameter also has type [b]<\/code>. Because we have f :: a -> b<\/code> and f undefined :: b<\/code>, we can write:<\/p>\n
    attribute :: (Enum b, Bounded b) => (a -> b) -> String -> Attribute a\nattribute f str = Attribute (fromEnum . f) vs str\n  where\n    vs = map fromEnum (enumerate `asTypeOf` [f undefined])\n<\/code><\/pre>\n<\/li>\n<\/ol>\n
    Originally posted 2013-11-09 19:01:36. <\/small><\/p>","protected":false},"excerpt":{"rendered":"
    I have a utility function that enumerates all values of a type that is both enumerable and bounded: enumerate :: (Enum a, Bounded a) => [a] enumerate = [minBound .. maxBound] and a data type that involves mapping enumerable types to integers: data Attribute a = Attribute { test :: a -> Int , vals […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-401","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts\/401","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/comments?post=401"}],"version-history":[{"count":0,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/posts\/401\/revisions"}],"wp:attachment":[{"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/media?parent=401"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/categories?post=401"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/unknownerror.org\/index.php\/wp-json\/wp\/v2\/tags?post=401"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}