Should the innards of `Type` be exposed? (Haskell backend) about dhall-haskell

[Gabriella439]

I'm actually okay with exposing the innards of Type. The only reason I haven't exposed it yet was just as a precaution in case I wanted to make internal changes to Type without breaking API changes.

Before I do that, though, I just want to make sure it's necessary. There are ways to define new Interpret instances without exposing the Type internals by using the Functor instance for type instead. Do you have an example of the type that you wanted to implement Interpret for?

[newhoggy]

What do I need to do to get the instance Interpret (Map String String)?

I'm trying to load "environment variables" like this from a config file:

{ HACKAGE_PASS="xxxx"
, HACKAGE_USER="xxxx"
, ...
}

These will be used to set up environment variables, and there can be any number of them.

[Gabriella439]

@newhoggy: You can't load a Dhall record into a Haskell Map String String, even if I exposed the internals of the Type constructor. To see why, think about what the expected field of the Type would be

I would suggest that you should instead do one of the following two approaches:

• If you know what the record fields will be ahead of time then load them into a Haskell record with matching fields, using Dhall's support for GHC generics, like this:

  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE DeriveAnyClass    #-}
  {-# LANGUAGE DeriveGeneric     #-}
  
  import Dhall
  
  data Config = Config
      { hackagePass :: Text
      , hackageUser :: Text
      } deriving (Generic, Interpret, Show)
  
  main :: IO ()
  main = do
      x <- input auto "./example"
      print (x :: Config)

  ... with an input file like this:

  { hackagePass = "xxx"
  , hackageUser = "xxx"
  }

• If some fields are going to be optional then make the Haskell record fields Maybe and the corresponding Dhall fields Optional, like this:

  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE DeriveAnyClass    #-}
  {-# LANGUAGE DeriveGeneric     #-}
  
  import Dhall
  
  data Config = Config
      { hackagePass :: Maybe Text
      , hackageUser :: Text
      } deriving (Generic, Interpret, Show)
  
  main :: IO ()
  main = do
      x <- input auto "./example3"
      print (x :: Config)

  ... with an input file like this:

  { hackagePass = [] : Optional Text
  , hackageUser = "xxx"
  }

• If you don't know what the fields will be ahead of time, then do this:

  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE DeriveAnyClass    #-}
  {-# LANGUAGE DeriveGeneric     #-}
  
  import Dhall
  
  data KeyVal = KeyVal { key :: Text, val :: Text }
      deriving (Generic, Interpret, Show)
  
  main :: IO ()
  main = do
      x <- input auto "./example"
      print (x :: Vector KeyVal)

  ... with an input file like this:

  [ { key = "HACKAGE_PASS" , val = "xxx" }
  , { key = "HACKAGE_USER" , val = "xxx" }
  ]

• If you want the previous approach but you want to decode directly into a Map Text Text, then use the Functor instance for Type:

  {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE DeriveAnyClass    #-}
  {-# LANGUAGE DeriveGeneric     #-}
  {-# LANGUAGE RecordWildCards   #-}
  
  import Data.Map (Map)
  import Dhall
  
  import qualified Data.Vector
  import qualified Data.Map
  
  data KeyVal = KeyVal { key :: Text, val :: Text }
      deriving (Generic, Interpret, Show)
  
  newtype Config = Config { keyVals :: Map Text Text } deriving (Show)
  
  instance Interpret Config where
      auto = fmap adapt0 auto
        where
          adapt0 = Config . Data.Map.fromList . fmap adapt1 . Data.Vector.toList
            where
              adapt1 (KeyVal {..}) = (key, val)
  
  main :: IO ()
  main = do
      x <- input auto "./example"
      print (x :: Config)

[newhoggy]

Perfect. Thanks!

[Gabriella439]

You're welcome!

[Gabriella439]

I'll go ahead and close this issue since I believe this has been answered