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

Minimal complete definition

Nothing

Methods

fromEnv :: Parser a

class ToEnv a where

ToEnv Typeclass

Methods

toEnv :: a -> EnvList a

class Var a where

Class for converting to / from an environment variable

Methods

toVar :: a -> String

fromVar :: String -> Maybe a

Instances

Var Bool

Var Double

Var Int

Var Int8

Var Int16

Var Int32

Var Int64

Var Integer

Var Word8

Var Word16

Var Word32

Var Word64

Var String

Var ByteString

Var ByteString

Var Text

Var Text

Var UTCTime

Var Day

data EnvList a

EnvList type w/ phanton

Instances

Show (EnvList a)

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 :: ToEnv a => EnvList a -> IO (Either String ())

Unset Environment from a ToEnv constrained type

makeEnv :: ToEnv a => [EnvVar] -> EnvList a

smart constructor, Environment creation helper

env :: forall a. (Typeable a, Var a) => String -> Parser a

Environment variable getter

envMaybe :: forall a. (Typeable 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

(.!=) :: forall a. (Typeable a, Var a) => Parser (Maybe a) -> a -> Parser a

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

Generics

class DefConfig a where

Default Config

Methods

defConfig :: a

data Option

For customizing environment variable generation

Constructors

Option

Fields

dropPrefixCount :: Int

Applied first

customPrefix :: String

Converted toUpper

Instances

Show Option

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" }