!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ^Function transformers that can be used to adapt the base runtime into other useful interfaces.(c) Nike, Inc., 2018BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comstableNone/45678:@AMX_`fgh}hal!Upgrades a handler that uses the  monad with an % inside into a base runtime handler.%In the example below, we reconstruct  ! without actually using it. The  # expects a handler in the form of (event -> ReaderT LambdaContext IO result0 (ignoring constraints). By composing it with ? we get a new runtime which expects a function in the form of #LambdaContext -> event -> IO result which matches that of  myHandler. b {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (readerTRuntime) import AWS.Lambda.Combinators (withIOInterface) import Data.Aeson (FromJSON) import Data.Text (unpack) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Named -> IO (Either String String) myHandler (LambdaContext { functionName }) (Named { name }) = do greeting <- getEnv "GREETING" return $ if name == "World" then Right $ "Hello, World from " ++ unpack functionName ++ "!" else Left "Can only greet the world." main :: IO () main = (readerTRuntime . withIOInterface) myHandler hal Upgrades a handler that accepts  + and an event to return a value inside an $ inside into a base runtime handler.%In the example below, we reconstruct  " without actually using it. The  # expects a handler in the form of (event -> ReaderT LambdaContext IO result/ (ignoring constraints). By composing it with ? we get a new runtime which expects a function in the form of .LambdaContext -> event -> Either String result which matches that of  myHandler.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (readerTRuntime) import AWS.Lambda.Combinators (withFallibleInterface) import Data.Aeson (FromJSON) import Data.Text (unpack) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Named -> Either String String myHandler (LambdaContext { functionName }) (Named { name }) = if name == "World" then Right $ "Hello, World from " ++ unpack functionName ++ "!" else Left "Can only greet the world." main :: IO () main = (readerTRuntime . withFallibleInterface) myHandler hal@This combinator takes a handler that accepts both an event and  R and converts it into a handler that is compatible with the base monadic runtime.%In the example below, we reconstruct  " without actually using it. The  # expects a handler in the form of (event -> ReaderT LambdaContext IO result/ (ignoring constraints). By composing it with ? we get a new runtime which expects a function in the form of  LambdaContext -> event -> result which matches that of  myHandler.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (readerTRuntime) import AWS.Lambda.Combinators (withPureInterface) import Data.Aeson (FromJSON) import Data.Text (unpack) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Named -> String myHandler (LambdaContext { functionName }) (Named { name }) = "Hello, " ++ name ++ " from " ++ unpack functionName ++ "!" main :: IO () main = (readerTRuntime . withPureInterface) myHandler hal An alias of 0, this upgrades a handler that does not accept  0 as its first curried argument to one that does.kThis allows us to use other combinators to construct a lambda runtime that accepts a handler that ignores  .%In the example below, we reconstruct ! without actually using it. The  # expects a handler in the form of (event -> ReaderT LambdaContext IO result/ (ignoring constraints). By composing it with ? we get a new runtime which expects a function in the form of  LambdaContext -> event -> result$, And then finally we also compose  so it accepts the signature event -> result which matches that of  myHandler.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Runtime (readerTRuntime) import AWS.Lambda.Combinators (withPureInterface, withoutContext) import Data.Aeson (FromJSON) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Named -> String myHandler (Named { name }) = "Hello, " ++ name main :: IO () main = (readerTRuntime . withPureInterface . withoutContext) myHandler halThis modifies a function to accept a JSON AST (Value), instead of its JSON parsable input. It also assumes that the JSON AST passed in will ALWAYS be convertable into the original input type.This allows us to write handlers of the types we're interested in, but then map back to the "native" handler that is only guaranteed JSON (but not necessarily in a useful or restricted structure)./This is essentially the glue that converts the AWS.Lambda.Runtime.Value to (the more standard) AWS.Lambda.Runtime. While both export a p, the difference is that the Value Runtime makes no attempt to convert the JSON AST, the standard Runtime does.Rarely would this function be used directly, and you wouldn't want to use it at all, (directly or indirectly via Runtime runtimes), if you wanted to act on a failure to convert the JSON AST sent to the Lambda./AWS Lambda Context classes and related methods.(c) Nike, Inc., 2018BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comstableNone$/45678:@AMX_`fgl%halKHelper for using arbitrary monads with only the LambdaContext in its Reader!   !"#$%! !"#  $%&Data types for working with S3 events.(c) Nike, Inc., 2019BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comstableNone"/45678:@AMX_`dfgs6hal7S3 object representations based on event type received.4Currently only Put/Delete events can trigger Lambdas=hal/Event data sent by S3 when triggering a Lambda.*678<;9:=>F?@ABCDEGHIJKLMNOPSQRTUVXWYZ[\]^_*Z[\]^_HIJKLMNUVXWYOPSQRT=>F?@ABCDEG678<;9:'Data types for working with SQS events.(c) Nike, Inc., 2019BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comstableNone/45678:@AMX_`fgw~~Internal hal helper methods.(c) Nike, Inc., 2018BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comunstableNone/45678:@AMX_`fgz7NHTTP related machinery for talking to the AWS Lambda Custom Runtime interface.(c) Nike, Inc., 2018BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comstableNone/45678:@AMX_`fg~hal-Lambda runtime error that we pass back to AWS\Runtime methods useful when constructing Haskell handlers for the AWS Lambda Custom Runtime.(c) Nike, Inc., 2018BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comstableNone/45678:>@AMX_`fgXhalFor any monad that supports IOcatchReader LambdaContext.Use this if you need caching behavours or are comfortable manipulating monad transformers and want full control over your monadic interface.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..), runReaderTLambdaContext) import AWS.Lambda.Runtime (mRuntimeWithContext) import Control.Monad.Reader (ReaderT, ask) import Control.Monad.State.Lazy (StateT, evalStateT, get, put) import Control.Monad.Trans (liftIO) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import Data.Text (unpack) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Value -> StateT Int (ReaderT LambdaContext IO) String myHandler jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> return $ "My name is HAL, what's yours?" Just Named { name } -> do LambdaContext { functionName } <- ask greeting <- liftIO $ getEnv "GREETING" greetingCount <- get put $ greetingCount + 1 return $ greeting ++ name ++ " (" ++ show greetingCount ++ ") from " ++ unpack functionName ++ "!" main :: IO () main = runReaderTLambdaContext (evalStateT (mRuntimeWithContext myHandler) 0) halPFor functions that can read the lambda context and use IO within the same monad.Use this for handlers that need any form of side-effect such as reading environment variables or making network requests, and prefer to access the AWS Lambda Context in the same monad. However, do not use this runtime if you need stateful (caching) behaviors.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (readerTRuntime) import Control.Monad.Reader (ReaderT, ask) import Control.Monad.Trans (liftIO) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import Data.Text (unpack) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Value -> ReaderT LambdaContext IO String myHandler jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> return $ "My name is HAL, what's yours?" Just Named { name } -> do LambdaContext { functionName } <- ask greeting <- liftIO $ getEnv "GREETING" return $ greeting ++ name ++ " from " ++ unpack functionName ++ "!" main :: IO () main = readerTRuntime myHandler halAFor functions with IO that can fail in a pure way (or via throw).Use this for handlers that need any form of side-effect such as reading environment variables or making network requests, and also need the AWS Lambda Context as input. However, do not use this runtime if you need stateful (caching) behaviors.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (ioRuntimeWithContext) import Control.Monad.Trans (liftIO) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import Data.Text (unpack) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Value -> IO (Either String String) myHandler (LambdaContext { functionName }) jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> return $ pure "My name is HAL, what's yours?" Just Named { name } -> do greeting <- liftIO $ getEnv "GREETING" return $ pure $ greeting ++ name ++ " from " ++ unpack functionName ++ "!" main :: IO () main = ioRuntimeWithContext myHandler halAFor functions with IO that can fail in a pure way (or via throw).Use this for handlers that need any form of side-effect such as reading environment variables or making network requests. However, do not use this runtime if you need stateful (caching) behaviors.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Runtime (ioRuntime) import Control.Monad.Trans (liftIO) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Value -> IO (Either String String) myHandler jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> return $ pure "My name is HAL, what's yours?" Just Named { name } -> do greeting <- liftIO $ getEnv "GREETING" return $ pure $ greeting ++ name main :: IO () main = ioRuntime myHandler hal'For pure functions that can still fail.Use this for simple handlers that just translate input to output without side-effects, but can fail and need the AWS Lambda Context as input.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (fallibleRuntimeWithContext) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import Data.Text (unpack) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Value -> Either String String myHandler (LambdaContext { functionName }) jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> Right "My name is HAL, what's yours?" Just Named { name } -> if name == "World" then Right $ "Hello, World from " ++ unpack functionName ++ "!" else Left "Can only greet the world." main :: IO () main = fallibleRuntimeWithContext myHandler hal'For pure functions that can still fail.eUse this for simple handlers that just translate input to output without side-effects, but can fail.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Runtime (fallibleRuntime) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Value -> Either String String myHandler jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> Right "My name is HAL, what's yours?" Just Named { name } -> if name == "World" then Right "Hello, World!" else Left "Can only greet the world." main :: IO () main = fallibleRuntime myHandler halLFor pure functions that can never fail that also need access to the context.Use this for simple handlers that just translate input to output without side-effects, but that need the AWS Lambda Context as input. < {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (pureRuntimeWithContext) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import Data.Text (unpack) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Value -> Either String String myHandler (LambdaContext { functionName }) jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> Right "My name is HAL, what's yours?" Just Named { name } -> Right $ "Hello, " ++ name ++ " from " ++ unpack functionName ++ "!" main :: IO () main = pureRuntimeWithContext myHandler hal'For pure functions that can never fail.VUse this for simple handlers that just translate input to output without side-effects. e {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Runtime (pureRuntime) import Data.Aeson (Value, FromJSON, parseJSON) import Data.Aeson.Types (parseMaybe) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Value -> String myHandler jsonAst = case parseMaybe parseJSON jsonAst of Nothing -> "My name is HAL, what's yours?" Just Named { name } -> "Hello, " ++ name ++ "!" main :: IO () main = pureRuntime myHandler \Runtime methods useful when constructing Haskell handlers for the AWS Lambda Custom Runtime.(c) Nike, Inc., 2018BSD33nathan.fairhurst@nike.com, fernando.freire@nike.comstableNone/45678:>@AMX_`fghalFor any monad that supports IOcatchReader LambdaContext.Use this if you need caching behavours or are comfortable manipulating monad transformers and want full control over your monadic interface.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..), runReaderTLambdaContext) import AWS.Lambda.Runtime (mRuntimeWithContext) import Control.Monad.Reader (ReaderT, ask) import Control.Monad.State.Lazy (StateT, evalStateT, get, put) import Control.Monad.Trans (liftIO) import Data.Aeson (FromJSON) import Data.Text (unpack) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Named -> StateT Int (ReaderT LambdaContext IO) String myHandler Named { name } = do LambdaContext { functionName } <- ask greeting <- liftIO $ getEnv "GREETING" greetingCount <- get put $ greetingCount + 1 return $ greeting ++ name ++ " (" ++ show greetingCount ++ ") from " ++ unpack functionName ++ "!" main :: IO () main = runReaderTLambdaContext (evalStateT (mRuntimeWithContext myHandler) 0) halPFor functions that can read the lambda context and use IO within the same monad.Use this for handlers that need any form of side-effect such as reading environment variables or making network requests, and prefer to access the AWS Lambda Context in the same monad. However, do not use this runtime if you need stateful (caching) behaviors. $ {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (readerTRuntime) import Control.Monad.Reader (ReaderT, ask) import Control.Monad.Trans (liftIO) import Data.Aeson (FromJSON) import Data.Text (unpack) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Named -> ReaderT LambdaContext IO String myHandler Named { name } = do LambdaContext { functionName } <- ask greeting <- liftIO $ getEnv "GREETING" return $ greeting ++ name ++ " from " ++ unpack functionName ++ "!" main :: IO () main = readerTRuntime myHandler halAFor functions with IO that can fail in a pure way (or via throw).Use this for handlers that need any form of side-effect such as reading environment variables or making network requests, and also need the AWS Lambda Context as input. However, do not use this runtime if you need stateful (caching) behaviors.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (ioRuntimeWithContext) import Data.Aeson (FromJSON) import Data.Text (unpack) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Named -> IO (Either String String) myHandler (LambdaContext { functionName }) (Named { name }) = do greeting <- getEnv "GREETING" return $ pure $ greeting ++ name ++ " from " ++ unpack functionName ++ "!" main :: IO () main = ioRuntimeWithContext myHandler halAFor functions with IO that can fail in a pure way (or via throw).Use this for handlers that need any form of side-effect such as reading environment variables or making network requests. However, do not use this runtime if you need stateful (caching) behaviors.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Runtime (ioRuntime) import Data.Aeson (FromJSON) import System.Environment (getEnv) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Named -> IO (Either String String) myHandler (Named { name }) = do greeting <- getEnv "GREETING" return $ pure $ greeting ++ name main :: IO () main = ioRuntime myHandler hal'For pure functions that can still fail.Use this for simple handlers that just translate input to output without side-effects, but can fail and need the AWS Lambda Context as input.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (fallibleRuntimeWithContext) import Data.Aeson (FromJSON) import Data.Text (unpack) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Named -> Either String String myHandler (LambdaContext { functionName }) (Named { name }) = if name == "World" then Right $ "Hello, World from " ++ unpack functionName ++ "!" else Left "Can only greet the world." main :: IO () main = fallibleRuntimeWithContext myHandler hal'For pure functions that can still fail.eUse this for simple handlers that just translate input to output without side-effects, but can fail.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Runtime (fallibleRuntime) import Data.Aeson (FromJSON) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Named -> Either String String myHandler (Named { name }) = if name == "World" then Right "Hello, World!" else Left "Can only greet the world." main :: IO () main = fallibleRuntime myHandler halLFor pure functions that can never fail that also need access to the context.Use this for simple handlers that just translate input to output without side-effects, but that need the AWS Lambda Context as input. m {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Context (LambdaContext(..)) import AWS.Lambda.Runtime (pureRuntimeWithContext) import Data.Aeson (FromJSON) import Data.Text (unpack) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: LambdaContext -> Named -> String myHandler (LambdaContext { functionName }) (Named { name }) = "Hello, " ++ name ++ " from " ++ unpack functionName ++ "!" main :: IO () main = pureRuntimeWithContext myHandler hal'For pure functions that can never fail.VUse this for simple handlers that just translate input to output without side-effects.  {-# LANGUAGE NamedFieldPuns, DeriveGeneric #-} module Main where import AWS.Lambda.Runtime (pureRuntime) import Data.Aeson (FromJSON) import GHC.Generics (Generic) data Named = Named { name :: String } deriving Generic instance FromJSON Named myHandler :: Named -> String myHandler Named { name } = "Hello, " ++ name ++ "!" main :: IO () main = pureRuntime myHandler None/45678:@AMX_`fg   !"#$%&&'())*+,--./0123456789:;<=>?@ABCDEFGHIJKKLMNOPQRSTUUVWWXYZZ[\]^__`abccdeefghijklmnopqrstuvwxyz{|}~een !"#$%         hal-0.4.3-DDNuSZHJusbHAkemvkH4AEAWS.Lambda.ContextAWS.Lambda.CombinatorsAWS.Lambda.Events.S3AWS.Lambda.Events.SQSAWS.Lambda.InternalAWS.Lambda.RuntimeClientAWS.Lambda.Runtime.ValueAWS.Lambda.RuntimeioRuntimeWithContextreaderTRuntime LambdaContextfallibleRuntimeWithContextpureRuntimeWithContext pureRuntimemRuntimeWithContext Paths_hal#envy-1.5.1.0-GMMVq6zDLtyHxAxq0LHiJy System.Envy defConfigwithIOInterfacewithFallibleInterfacewithPureInterfacewithoutContextwithInfallibleParseHasLambdaContext withContext functionNamefunctionVersionfunctionMemorySize logGroupName logStreamName awsRequestIdinvokedFunctionArn xRayTraceIddeadline clientContextidentityCognitoIdentity identityIdidentityPoolId ClientContextclientcustom environmentClientApplicationappTitleappVersionNameappVersionCodeappPackageNamegetRemainingTimerunReaderTLambdaContext$fFromJSONClientApplication$fToJSONClientApplication$fFromJSONClientContext$fToJSONClientContext$fFromJSONCognitoIdentity$fToJSONCognitoIdentity$fDefConfigLambdaContext$fHasLambdaContextLambdaContext$fShowClientApplication$fGenericClientApplication$fShowClientContext$fGenericClientContext$fShowCognitoIdentity$fGenericCognitoIdentity$fShowLambdaContext$fGenericLambdaContextS3Object PutObject DeleteObject$sel:eTag:PutObject$sel:sequencer:PutObject$sel:key:PutObject$sel:size:PutObjectS3Event$sel:awsRegion:S3Event$sel:eventName:S3Event$sel:eventSource:S3Event$sel:eventTime:S3Event$sel:eventVersion:S3Event$sel:requestParameters:S3Event$sel:responseElements:S3Event$sel:s3:S3Event$sel:userIdentity:S3EventRequestParameters&$sel:sourceIPAddress:RequestParametersResponseElements$sel:amazonId:ResponseElements%$sel:amazonRequestId:ResponseElementsS3Config$sel:bucket:S3Config$sel:configurationId:S3Config$sel:object:S3Config$sel:s3SchemaVersion:S3ConfigS3Bucket$sel:arn:S3Bucket$sel:name:S3Bucket$sel:ownerIdentity:S3BucketPrincipalIdentity"$sel:principalId:PrincipalIdentityRecords$sel:records:Records$fFromJSONPrincipalIdentity$fFromJSONS3Bucket$fFromJSONResponseElements$fFromJSONRequestParameters$fFromJSONS3Object$fFromJSONS3Config$fFromJSONS3Event$fFromJSONRecords$fShowPrincipalIdentity$fEqPrincipalIdentity$fGenericPrincipalIdentity$fShowS3Bucket $fEqS3Bucket$fGenericS3Bucket$fShowResponseElements$fEqResponseElements$fShowRequestParameters$fEqRequestParameters$fGenericRequestParameters$fShowS3Object $fEqS3Object$fGenericS3Object$fShowS3Config $fEqS3Config$fGenericS3Config $fShowS3Event $fEqS3Event$fGenericS3Event $fShowRecords $fEqRecordsSQSEvent messageId receiptHandlebody attributesmessageAttributes md5OfBody eventSourceeventSourceARN awsRegion AttributesapproximateReceiveCount sentTimestampsenderId approximateFirstReceiveTimestamprecords$fFromJSONAttributes$fFromJSONSQSEvent$fShowAttributes$fEqAttributes$fShowSQSEvent $fEqSQSEvent$fGenericSQSEventDynamicContext StaticContext mkContext$fFromEnvStaticContext$fDefConfigStaticContext$fShowStaticContext$fGenericStaticContext$fShowDynamicContextgetBaseRuntimeRequest getNextEventsendEventSuccesssendEventError sendInitError$fToJSONLambdaError$fShowLambdaError$fGenericLambdaError ioRuntimefallibleRuntimeghc-prim GHC.TypesIObase Data.EitherEitherGHC.Baseconst LambdaErrorversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName