Copyright	(c) David Johnson 2015
Maintainer	djohnson.m@gmail.com
Stability	experimental
Portability	POSIX
Safe Haskell	None
Language	Haskell2010

System.Envy

Contents

Classes
Functions
Generics

Description

{-# 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 }

Synopsis

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 #

Type class for objects which can be converted to a set of environment variable settings.

Minimal complete definition

toEnv

Methods

toEnv :: a -> EnvList a #

Convert an object into a list of environment variable settings.

class Typeable a => Var a where #

Class for converting to / from an environment variable

Minimal complete definition

toVar, fromVar

Methods

toVar :: a -> String #

Convert a value into an environment variable.

fromVar :: String -> Maybe a #

Parse an environment variable.

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 () #
Methods toVar :: () -> String # fromVar :: String -> Maybe () #
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 #
Var a => Var (Maybe a) #
Methods toVar :: Maybe a -> String # fromVar :: String -> Maybe (Maybe a) #

data EnvList a #

List of environment variables. Captures a "phantom type" which allows the type checker to detect the proper implementation of toEnv to use.

Instances

Show (EnvList a) #
Methods showsPrec :: Int -> EnvList a -> ShowS # show :: EnvList a -> String # showList :: [EnvList a] -> ShowS #

newtype Parser a #

Parser Monad for environment variable retrieval

Constructors

Parser
Fields runParser :: ExceptT String IO a

Instances

Monad Parser #
Methods (>>=) :: Parser a -> (a -> Parser b) -> Parser b # (>>) :: Parser a -> Parser b -> Parser b # return :: a -> Parser a # fail :: String -> Parser a #
Functor Parser #
Methods fmap :: (a -> b) -> Parser a -> Parser b # (<$) :: a -> Parser b -> Parser a #
Applicative Parser #
Methods pure :: a -> Parser a # (<>) :: Parser (a -> b) -> Parser a -> Parser b # liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c # (>) :: Parser a -> Parser b -> Parser b # (<*) :: Parser a -> Parser b -> Parser a #
MonadIO Parser #
Methods liftIO :: IO a -> Parser a #
Alternative Parser #
Methods empty :: Parser a # (<\|>) :: Parser a -> Parser a -> Parser a # some :: Parser a -> Parser [a] # many :: Parser a -> Parser [a] #
MonadPlus Parser #
Methods mzero :: Parser a # mplus :: Parser a -> Parser a -> Parser a #
MonadError String Parser #
Methods throwError :: String -> Parser a # catchError :: Parser a -> (String -> Parser a) -> Parser 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 :: EnvList a -> IO (Either String ()) #

Unset Environment from a ToEnv constrained type

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

Unset Environment using a value of class ToEnv

makeEnv :: [EnvVar] -> EnvList a #

Smart constructor, environment creation helper.

env #

Arguments

:: Var a
=> String	Key to look up.
-> Parser a	Return a value of this type or throw an error.

Environment variable getter. Fails if the variable is not set or fails to parse.

envMaybe #

Arguments

:: Var a
=> String	Key to look up.
-> Parser (Maybe a)	Return `Nothing` if variable isn't set.

Environment variable getter returning Maybe

(.=) #

Arguments

:: Var a
=> String	The variable name to set.
-> a	Object to set in the environment.
-> EnvVar	Mapping of Variable to Value.

Infix environment variable setter Smart constructor for producing types of EnvVar

(.!=) #

Arguments

:: Parser (Maybe a)	Parser that might fail.
-> a	Value to return if the parser fails.
-> Parser a	Parser that returns the default on failure.

For use with envMaybe for providing default arguments.

Generics

class DefConfig a where #

Type class for objects which have a default configuration.

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