running formatters on some code

hindent --style chris-done

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}

module SumAll.Eureka.Types (EitherStyleListeners(..)) where

import Canteven.Listen.HTTP
       (ListenerConfig, ListenHTTPConfig(ListenHTTPConfig), otherthing,
        moyonthetnh)
import qualified Canteven.Listen.HTTP as CLH
       (ListenHTTPConfig(listeners))
import Control.Applicative ((<|>))
import Data.Aeson (FromJSON(parseJSON), (.:), withObject)
import Data.Functor ((<$>))
import GHC.Generics (Generic)

-- This is a work-around. Instead of exposing the ServerConfig datatypes in
-- Moonshine, we reparse the same Moonshine "applicationConnector" field using
-- canteven-listen-http types.
data ServerConfig =
  ServerConfig {applicationConnector :: [ListenerConfig]}
  deriving (Show,Generic)

instance FromJSON ServerConfig

newtype EitherStyleListeners =
  EitherStyleListeners {listeners :: [ListenerConfig]}
  deriving (Eq,Show)

instance FromJSON EitherStyleListeners where
  parseJSON v = 
    EitherStyleListeners <$> (parseAsListenHTTPConfig <|> parseAsMoonshine)
    where parseAsListenHTTPConfig = 
            do ListenHTTPConfig{CLH.listeners = lhcListeners} <- parseJSON v
               return lhcListeners
          parseAsMoonshine = 
            flip (withObject "ServerConfig") v $
            \obj -> 
              do ServerConfig{applicationConnector} <- obj .: "server"
                 return applicationConnector

hindent --style gibiansky

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}

module SumAll.Eureka.Types (EitherStyleListeners(..)) where

import           Canteven.Listen.HTTP (ListenerConfig,
                                       ListenHTTPConfig(ListenHTTPConfig),
                                       otherthing, moyonthetnh)
import qualified Canteven.Listen.HTTP as CLH (ListenHTTPConfig(listeners))
import           Control.Applicative ((<|>))
import           Data.Aeson (FromJSON(parseJSON), (.:), withObject)
import           Data.Functor ((<$>))
import           GHC.Generics (Generic)

-- This is a work-around. Instead of exposing the ServerConfig datatypes in
-- Moonshine, we reparse the same Moonshine "applicationConnector" field using
-- canteven-listen-http types.
data ServerConfig = ServerConfig { applicationConnector :: [ListenerConfig] }
  deriving (Show, Generic)

instance FromJSON ServerConfig

newtype EitherStyleListeners =
          EitherStyleListeners
            { listeners :: [ListenerConfig] }
  deriving (Eq, Show)

instance FromJSON EitherStyleListeners where
  parseJSON v =
    EitherStyleListeners <$> (parseAsListenHTTPConfig <|> parseAsMoonshine)
    where
      parseAsListenHTTPConfig = do
        ListenHTTPConfig { CLH.listeners = lhcListeners } <- parseJSON v
        return lhcListeners
      parseAsMoonshine =
        flip (withObject "ServerConfig") v $
          \obj -> do
            ServerConfig { applicationConnector } <- obj .: "server"
            return applicationConnector

hindent --style johann-tibell

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}

module SumAll.Eureka.Types (EitherStyleListeners(..)) where

import Canteven.Listen.HTTP
       (ListenerConfig, ListenHTTPConfig(ListenHTTPConfig), otherthing,
        moyonthetnh)
import qualified Canteven.Listen.HTTP as CLH
       (ListenHTTPConfig(listeners))
import Control.Applicative ((<|>))
import Data.Aeson (FromJSON(parseJSON), (.:), withObject)
import Data.Functor ((<$>))
import GHC.Generics (Generic)

-- This is a work-around. Instead of exposing the ServerConfig datatypes in
-- Moonshine, we reparse the same Moonshine "applicationConnector" field using
-- canteven-listen-http types.
data ServerConfig = ServerConfig
    { applicationConnector :: [ListenerConfig]
    } deriving (Show,Generic)

instance FromJSON ServerConfig

newtype EitherStyleListeners = EitherStyleListeners
    { listeners :: [ListenerConfig]
    } deriving (Eq,Show)

instance FromJSON EitherStyleListeners where
    parseJSON v = 
        EitherStyleListeners <$> (parseAsListenHTTPConfig <|> parseAsMoonshine)
      where
        parseAsListenHTTPConfig = do
            ListenHTTPConfig{CLH.listeners = lhcListeners} <- parseJSON v
            return lhcListeners
        parseAsMoonshine = 
            flip (withObject "ServerConfig") v $
            \obj -> 
                 do ServerConfig{applicationConnector} <- obj .: "server"
                    return applicationConnector

stylish-haskell

{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE NamedFieldPuns    #-}
{-# LANGUAGE OverloadedStrings #-}

module SumAll.Eureka.Types (EitherStyleListeners(..)) where

import           Canteven.Listen.HTTP (ListenHTTPConfig (ListenHTTPConfig),
                                       ListenerConfig, moyonthetnh, otherthing)
import qualified Canteven.Listen.HTTP as CLH (ListenHTTPConfig (listeners))
import           Control.Applicative  ((<|>))
import           Data.Aeson           (FromJSON (parseJSON), withObject, (.:))
import           Data.Functor         ((<$>))
import           GHC.Generics         (Generic)

-- This is a work-around. Instead of exposing the ServerConfig datatypes in
-- Moonshine, we reparse the same Moonshine "applicationConnector" field using
-- canteven-listen-http types.
data ServerConfig =
  ServerConfig {applicationConnector :: [ListenerConfig]}
  deriving (Show,Generic)

instance FromJSON ServerConfig

newtype EitherStyleListeners =
  EitherStyleListeners {listeners :: [ListenerConfig]}
  deriving (Eq,Show)

instance FromJSON EitherStyleListeners where
  parseJSON v =
    EitherStyleListeners <$> (parseAsListenHTTPConfig <|> parseAsMoonshine)
    where parseAsListenHTTPConfig =
            do ListenHTTPConfig{CLH.listeners = lhcListeners} <- parseJSON v
               return lhcListeners
          parseAsMoonshine =
            flip (withObject "ServerConfig") v $
            \obj ->
              do ServerConfig{applicationConnector} <- obj .: "server"
                 return applicationConnector

Types.hs

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
module SumAll.Eureka.Types (
    EitherStyleListeners(..),
    ) where

import Canteven.Listen.HTTP (ListenerConfig,
    ListenHTTPConfig(ListenHTTPConfig), otherthing, moyonthetnh)
import qualified Canteven.Listen.HTTP as CLH (ListenHTTPConfig(listeners))
import Control.Applicative ((<|>))
import Data.Aeson (FromJSON(parseJSON), (.:), withObject)
import Data.Functor ((<$>))
import GHC.Generics (Generic)

-- This is a work-around. Instead of exposing the ServerConfig datatypes in
-- Moonshine, we reparse the same Moonshine "applicationConnector" field using
-- canteven-listen-http types.
data ServerConfig = ServerConfig {
    applicationConnector :: [ListenerConfig]
    } deriving (Show, Generic)

instance FromJSON ServerConfig

newtype EitherStyleListeners = EitherStyleListeners {
    listeners :: [ListenerConfig]
    } deriving (Eq, Show)

instance FromJSON EitherStyleListeners where
    parseJSON v = EitherStyleListeners <$>
                  (parseAsListenHTTPConfig <|> parseAsMoonshine)
      where
        parseAsListenHTTPConfig = do
            ListenHTTPConfig {CLH.listeners = lhcListeners} <- parseJSON v
            return lhcListeners
        parseAsMoonshine = flip (withObject "ServerConfig") v $ \obj -> do
            ServerConfig {applicationConnector} <- obj .: "server"
            return applicationConnector

with haskell-formatter

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
module SumAll.Eureka.Types (EitherStyleListeners(..)) where

import Canteven.Listen.HTTP
       (ListenHTTPConfig(ListenHTTPConfig), ListenerConfig, moyonthetnh,
        otherthing)
import qualified Canteven.Listen.HTTP as CLH (ListenHTTPConfig(listeners))
import Control.Applicative ((<|>))
import Data.Aeson ((.:), FromJSON(parseJSON), withObject)
import Data.Functor ((<$>))
import GHC.Generics (Generic)

-- This is a work-around. Instead of exposing the ServerConfig datatypes in
-- Moonshine, we reparse the same Moonshine "applicationConnector" field using
-- canteven-listen-http types.
data ServerConfig = ServerConfig{applicationConnector :: [ListenerConfig]}
                  deriving (Show, Generic)

instance FromJSON ServerConfig

newtype EitherStyleListeners = EitherStyleListeners{listeners ::
                                                    [ListenerConfig]}
                             deriving (Eq, Show)

instance FromJSON EitherStyleListeners where
    parseJSON v
      = EitherStyleListeners <$> (parseAsListenHTTPConfig <|> parseAsMoonshine)
      where
          parseAsListenHTTPConfig
            = do ListenHTTPConfig{CLH.listeners = lhcListeners} <- parseJSON v
                 return lhcListeners
          parseAsMoonshine
            = flip (withObject "ServerConfig") v $
                \ obj ->
                  do ServerConfig{applicationConnector} <- obj .: "server"
                     return applicationConnector