System.Envy

{-# LANGUAGE DeriveGeneric #-}

module Main ( main ) where

import System.Envy
import GHC.Generics

data PGConfig = PGConfig {
  pgHost :: String -- "PG_HOST"
, pgPort :: Int    -- "PG_PORT"
} deriving (Generic, Show)

-- Default instance used if environment variable doesn't exist
instance DefConfig PGConfig where
  defConfig = PGConfig "localhost" 5432

instance FromEnv PGConfig
-- Generically produces the following body (no implementation needed if using Generics):
-- fromEnv = PGConfig <$> envMaybe "PG_HOST" .!= "localhost"
--                    <*> envMaybe "PG_PORT" .!= 5432

main :: IO ()
main =
  print =<< do decodeEnv :: IO (Either String PGConfig)
 -- PGConfig { pgHost = "custom-pg-url", pgPort = 5432 }

Classes

class FromEnv a where

FromEnv Typeclass w/ Generic default implementation

Methods

fromEnv :: Parser a

fromEnv :: (DefConfig a, Generic a, GFromEnv (Rep a)) => Parser a

class ToEnv a where

ToEnv Typeclass

Minimal complete definition

toEnv

Methods

toEnv :: a -> EnvList a

class Var a where

Class for converting to / from an environment variable

Minimal complete definition

toVar, fromVar

Methods

toVar :: a -> String

fromVar :: String -> Maybe a

Instances

Var Bool

Methods

toVar :: Bool -> String

fromVar :: String -> Maybe Bool

Var Double

Methods

toVar :: Double -> String

fromVar :: String -> Maybe Double

Var Int

Methods

toVar :: Int -> String

fromVar :: String -> Maybe Int

Var Int8

Methods

toVar :: Int8 -> String

fromVar :: String -> Maybe Int8

Var Int16

Methods

toVar :: Int16 -> String

fromVar :: String -> Maybe Int16

Var Int32

Methods

toVar :: Int32 -> String

fromVar :: String -> Maybe Int32

Var Int64

Methods

toVar :: Int64 -> String

fromVar :: String -> Maybe Int64

Var Integer

Methods

toVar :: Integer -> String

fromVar :: String -> Maybe Integer

Var Word8

Methods

toVar :: Word8 -> String

fromVar :: String -> Maybe Word8

Var Word16

Methods

toVar :: Word16 -> String

fromVar :: String -> Maybe Word16

Var Word32

Methods

toVar :: Word32 -> String

fromVar :: String -> Maybe Word32

Var Word64

Methods

toVar :: Word64 -> String

fromVar :: String -> Maybe Word64

Var String

Methods

toVar :: String -> String

fromVar :: String -> Maybe String

Var ByteString

Methods

toVar :: ByteString -> String

fromVar :: String -> Maybe ByteString

Var ByteString

Methods

toVar :: ByteString -> String

fromVar :: String -> Maybe ByteString

Var Text

Methods

toVar :: Text -> String

fromVar :: String -> Maybe Text

Var Text

Methods

toVar :: Text -> String

fromVar :: String -> Maybe Text

Var UTCTime

Methods

toVar :: UTCTime -> String

fromVar :: String -> Maybe UTCTime

Var Day

Methods

toVar :: Day -> String

fromVar :: String -> Maybe Day

data EnvList a

EnvList type w/ phanton

Instances

Show (EnvList a)

Methods

showsPrec :: Int -> EnvList a -> ShowS

show :: EnvList a -> String

showList :: [EnvList a] -> ShowS

Functions

decodeEnv :: FromEnv a => IO (Either String a)

Environment retrieval with failure info

decode :: FromEnv a => IO (Maybe a)

Environment retrieval (with no failure info)

showEnv :: IO ()

Display all environment variables, for convenience

setEnvironment :: EnvList a -> IO (Either String ())

Set environment via a ToEnv constrained type

setEnvironment' :: ToEnv a => a -> IO (Either String ())

Set environment directly using a value of class ToEnv

unsetEnvironment :: EnvList a -> IO (Either String ())

Unset Environment from a ToEnv constrained type

makeEnv :: [EnvVar] -> EnvList a

smart constructor, Environment creation helper

env :: forall a. Var a => String -> Parser a

Environment variable getter

envMaybe :: forall a. Var a => String -> Parser (Maybe a)

Environment variable getter returning Maybe

(.=) :: Var a => String -> a -> EnvVar

Infix environment variable setter Smart constructor for producing types of EnvVar

(.!=) :: Parser (Maybe a) -> a -> Parser a

For use with (.:?) for providing default arguments

Generics

class DefConfig a where

Default Config

Minimal complete definition

defConfig

Methods

defConfig :: a

data Option

For customizing environment variable generation

Constructors

Option

Fields

• dropPrefixCount :: Int

  Applied first

• customPrefix :: String

  Converted toUpper

Instances

Show Option

Methods

showsPrec :: Int -> Option -> ShowS

show :: Option -> String

showList :: [Option] -> ShowS

runEnv :: Parser a -> IO (Either String a)

For use with Generics, no FromEnv typeclass necessary

getPgConfig :: IO (Either String ConnectInfo)
getPgConfig = runEnv $ gFromEnvCustom defOption

gFromEnvCustom :: forall a. (DefConfig a, Generic a, GFromEnv (Rep a)) => Option -> Parser a

Meant for specifying a custom Option for environment retrieval

instance FromEnv PGConfig where
  fromEnv = gFromEnvCustom Option { dropPrefixCount = 8, customPrefix = "PG" }