support Int-keyed Dicts

src/Elm/Decoder.hs

@@ -61,6 +61,14 @@ instance HasDecoderRef ElmPrimitive where
   renderRef (EList datatype) = do
     dt <- renderRef datatype
     return . parens $ "list" <+> dt
+  renderRef (EMap EString value) = do
+    require "Dict"
+    d <- renderRef value
+    return . parens $ "dict" <+> d
+  renderRef (EMap EInt value) = do
+    require "Dict"
+    d <- renderRef value
+    return . parens $ "dict" <+> d <+> " |> map (Dict.toList >> List.filterMap (\\( k, v ) -> String.toInt k |> Result.toMaybe |> Maybe.map (\\i -> ( i, v ))) >> Dict.fromList)"
   renderRef (EDict EString value) = do
     require "Dict"
     d <- renderRef value

src/Elm/Encoder.hs

@@ -72,6 +72,10 @@ instance HasEncoderRef ElmPrimitive where
     dy <- renderRef y
     require "Exts.Json.Encode"
     return . parens $ "Exts.Json.Encode.tuple2" <+> dx <+> dy
+  renderRef (EMap _ v) = do
+    dv <- renderRef v
+    require "Exts.Json.Encode"
+    return . parens $ "Dict.toList >> (\\ (k,v) -> (toString k, (" <+> dv <+> ") v)) >> Json.encode.object"
   renderRef (EDict k v) = do
     dk <- renderRef k
     dv <- renderRef v

src/Elm/Record.hs

@@ -70,6 +70,11 @@ instance HasTypeRef ElmPrimitive where
   renderRef (EMaybe datatype) = do
     dt <- renderRef datatype
     return $ "Maybe" <+> parens dt
+  renderRef (EMap k v) = do
+    require "Dict"
+    dk <- renderRef k
+    dv <- renderRef v
+    return $ "Dict" <+> parens dk <+> parens dv
   renderRef (EDict k v) = do
     require "Dict"
     dk <- renderRef k

src/Elm/Type.hs

@@ -37,6 +37,8 @@ data ElmPrimitive
             ElmDatatype
   | EDict ElmPrimitive
           ElmDatatype
+  | EMap ElmPrimitive
+         ElmDatatype
   deriving (Show, Eq)
 
 data ElmConstructor
@@ -172,11 +174,15 @@ instance (ElmType a) =>
          ElmType (Proxy a) where
   toElmType _ = toElmType (undefined :: a)
 
-instance (HasElmComparable k, ElmType v) =>
+instance {-# OVERLAPS #-} (ElmType v) =>
+         ElmType (Map String v) where
+  toElmType _ = ElmPrimitive $ EDict EString (toElmType (Proxy :: Proxy v))
+
+instance {-# OVERLAPS #-} (HasElmComparable k, ElmType v) =>
          ElmType (Map k v) where
   toElmType _ =
     ElmPrimitive $
-    EDict (toElmComparable (undefined :: k)) (toElmType (Proxy :: Proxy v))
+    EMap (toElmComparable (undefined :: k)) (toElmType (Proxy :: Proxy v))
 
 instance (ElmType v) =>
          ElmType (IntMap v) where
@@ -188,6 +194,9 @@ class HasElmComparable a where
 instance HasElmComparable String where
   toElmComparable _ = EString
 
+instance HasElmComparable Int where
+  toElmComparable _ = EInt
+
 instance HasElmComparable Text where
   toElmComparable _ = EString
 

test/ExportSpec.hs

@@ -278,6 +278,9 @@ toElmDecoderSpec =
       it "toElmDecoderRef (IntMap (Maybe String))" $
         toElmDecoderRef (Proxy :: Proxy (IntMap (Maybe String))) `shouldBe`
         "(map Dict.fromList (list (map2 (,) (index 0 int) (index 1 (nullable string)))))"
+      it "toElmDecoderRef (Map Int (Maybe String))" $
+        toElmDecoderRef (Proxy :: Proxy (Map Int (Maybe String))) `shouldBe`
+        "(dict (nullable string)  |> map (Dict.toList >> List.filterMap (\\( k, v ) -> String.toInt k |> Result.toMaybe |> Maybe.map (\\i -> ( i, v ))) >> Dict.fromList))"
 
 toElmEncoderSpec :: Hspec.Spec
 toElmEncoderSpec =