hasklepias-main-0.30.3: Tools for constructing epidemiological cohorts
Copyright(c) Target RWE 2023
LicenseBSD3
Maintainerbbrown@targetrwe.com ljackman@targetrwe.com dpritchard@targetrwe.com
Safe HaskellSafe-Inferred
LanguageHaskell2010

Hasklepias

Description

 
Synopsis

Overview

Hasklepias provides an API for constructing a command-line program to produce analysis-ready datasets for epidemiological studies, referred to as cohorts in this documentation. It also provides some domain-aware types and utilities to help Haskell programmers write custom logic for cohort construction, to feed the application.

Users provide custom logic, written in Haskell, to transform subject-level input data into output data with computed variables and classifications of elements into one or more cohorts.

The following diagram describes the primary workflow Hasklepias supports, at a high level.

                                         +---------------------------------+
    +--------------------------+         |Configure cohort construction    |
    |Write cohort-building code|-------->| via CohortSpecMap type          |
    | computing subject-level  |         +---------------------------------+
    | * index times            |            |
    | * inclusion criteria     |            |
    | * output variables       |            |
    +--------------------------+            |
                                            |
                +---------------------------|--------+
                |Create an executable Cabal |        |
                | package component that    |        |
                | runs the transformation   |        |
                |                           v        |
                |  +------------------------------+  |
                |  |provide CohortSpecMap value as|  |
input data ---> |  | input to cohortMain to create|  | ---> output cohorts
                |  | the data processing          |  |
                |  | tranformation                |  |
                |  + -----------------------------+  |
                |                                    |
                +------------------------------------+

Terminology

Subject refers to the unit of input data, which internally is assigned a subject id for processing. Internally, it has type Subject t m a.

Subject-level data refers to [Event t m a], a list of events associated with a subject.

Index time is a special temporal interval serving as reference for inclusion and exclusion criteria as well as computed output variables. A subject might have zero or more index times, as computed by a user-supplied function.

Cohort refers to the output produced by applying the functions in a single CohortSpec to a list of subjects. Internally, it has type Cohort a.

Observational unit refers to the unit element of a given cohort. There is one observational unit for each subject and index time. Each observational unit has an identifier marking which subject and index time it is asssociated with.

Attrition information refers to the counts of: number of subjects processed, number of observational units processed, and number of units in each inclusion / exclusion category.

Cohort construction

The CohortSpec type is the only way a user can influence how input data are processed into output data as cohorts. It is parameterized as CohortSpec t m a, where the parameters match those of the subject-level data inputs in a non-empty list of Event t m a.

One CohortSpec t m a is provided for each cohort to be built, denoted by Text labels in Map Text (CohortSpec t m a), with alias CohortSpecMap t m a. The map is passed directly to cohortMain.

Specifically, a user must construct a CohortSpec with the functions shown in the type definition:

data CohortSpec t m a
  = MkCohortSpec
      { runIndices   :: NonEmpty (Event t m a) -> IndexSet a
      , runCriteria  :: NonEmpty (Event t m a) -> Interval a -> Criteria
      , runVariables :: NonEmpty (Event t m a) -> Interval a -> VariableRow
      }

Each of those functions processes input data in a NonEmpty list of Event t m a associated with a single subject. Subject input data is processed one at a time, cohort-by-cohort. Subjects without any data cannot be processed in a well-defined manner, and using the nonempty list type prevents such cases.

runIndices constructs the set of index times for a given subject, which are given as Interval a, the same type as the underlying temporal element of an Event t m a.

runCriteria constructs a non-empty list of inclusion / exclusion criteria for a single subject, relative to a particular index time.

runVariables defines the output data of VariableRow type, for each subject and index time. This will produce one set of variables per input subject per index time.

Using Variable

This module defines the return type of runVariables along with the type system for the supported output targets.

Currently the only target type system that is supported by asclepias is a subset of the R type system.

The VariableRow type is a list of Variables. The intention is that the list of Variables that is returned by runVariables after being applied to a single observational unit's Events represents one row of data in a data frame, with one row per observational unit and one columns per study variable.

The Variable type wraps an underlying R type along with some metadata. The type is not designed to be convenient to work with once it has been created, so it is recommended to only produce Variable values when assembling the return value from runVariables. Instead, for intermediate values the recommended approach is to use one of the types used to represent R values, such as RTypeRep, Factor, or Stype.

All of the types used to represent R types in this module are either directly or indirectly based upon the RTypeRep type. The R types that are supported by RTypeRep are the atomic R vectors types as well as generic vectors (i.e. lists). These vectors are modeled as arrays of Maybe (SEXPElem s)s and where Nothings represent NA* values in the case of atomic vectors (see the type documentation for more detail for a Nothing value for the list case).

The elements of the RTypeRep vector representations are modeled using the SEXPElem type family. The types in this type family for the atomic types correpond to the underlying element "type" that the various R atomic vectors are based upon. Type is in quotations because R's SEXPTYPE does not provide a separate type for the elements of an atomic vector: All singletons are single-length vectors. For example, the SEXPElem 'INTSXP type is a synonym for Int32, which is the same type that R INTSXP values (i.e. R integer vectors) are based upon.

The SEXPElem 'VECSXP type is used to represent R VECSXP values (i.e. R generic vectors); see the type documentation for details.

module Variable

Using the CLI

Your project's Haskell program will include some Main.hs module which should look like this

module Main where

import MyProj
import Hasklepias (cohortMain)

main :: IO ()
main = cohortMain specs

Here specs is your project-specific CohortSpecMap, which in this case is defined in some other module MyProj.

Then, you can cabal run to build and execute the program.

To view the available command-line options, for a target named myproj, do

cabal run -v0 myproj -- --help

Your project's Haskell program will include some Main.hs module which should look like this

module Main where

import MyProj
import Hasklepias (cohortMain)

main :: IO ()
main = cohortMain specs

Here specs is your project-specific CohortSpecMap, which in this case is defined in some other module MyProj.

Then, you can cabal run to build and execute the program.

To view the available command-line options, for a target named myproj, do

cabal run -v0 myproj -- --help

cohortMain guarantees

cohortMain provides a controlled means to run the user-provided logic in a CohortSpec to subject-level data. A programmer creating an executable with cohortMain cannot inject arbitrary logic into the application.

In exchange for that lack of flexibility, the application runner cohortMain seeks to provide a set of guarantees about how a cohort will be built from the user specification.

  • Only the user-defined code in CohortSpec t m a will ever manipulate, perform operations on or otherwise interact with the subject-level input data in a NonEmpty (Event t m a).
  • Functions in each CohortSpec are run only on input event data only for a single subject at a time. Input events from one subject do not influence results of another.
  • runIndices produces exactly one IndexSet a containing Interval a values, the same type of value as the temporal component of the subject's input events.
  • If a subject's IndexSet is empty, the subject is dropped from the cohort data output, has no variables computed, and is counted only in the subjectsProcessed field of the output attrition information. At present, there is no means to mark or otherwise inspect the values or even the number of subjects with no index value. That will change soon, and a subject without index will be treated as an unexpected error.
  • Each Interval a in an IndexSet a appears exactly once. Uniqueness is determined by the begin and end of the interval.
  • The user-supplied runCriteria function must produce a non-empty list of value type Criterion. That is enforced at compile time in the user's code, when a CohortSpec value is created.
  • Each observational unit is associated with exactly one subject and one index time. The Interval a index time to which an observational unit is associated is part of the identifier for an observational unit, along with the subject identifier.
  • Each observational unit has a list of Criteria, as defined by runCriteria.
  • Observational units whose Criteria contain at least one Exclude status value are dropped from the cohort data output, and runVariables is not computed. In the output attrition information, excluded units contribute +1 to the unitsProcessed element of the attrition information. The unit also contributes +1 to the count of units excluded with a given label.
  • An excluded observational unit is considered to be excluded by the first Criterion, in order of the list of Criteria. The statusLabel supplied for that Criterion determines how the unit is counted in the output attrition information.
  • Observational units whose Criteria contain only Include status values are maintained in the cohort data output, and runVariables is computed on the unit's associated input data and index time. For the output attrition information, included units contribute +1 to the unitsProcessed and +1 to the count of Included units.
  • Whether excluded or included in the cohort, units common to a single subject together contribute +1 to the number of subjectsProcessed.

Input data format

The input data, regardless of source, must be in the event lines format, which is a JSON Lines format. Lines of input failing to parse into the appropriate format will be logged. See Logs produced.

Input data must also:

  • contain all relevant events for a given subject, and
  • have UTF-8 encoding.

Two flags allow the user to configure how intervals in input data will be parsed.

  • --fix-end will convert intervals with null end fields into moment-length intervals.
  • --add-moment will add a moment to the end time of intervals for which the end is not null and the end >= begin. Intervals with missing end or for which end is less than begin will still fail to parse.

These flags can be used together to specify both modifications should be applied. The default behavior is not to modify input intervals at all, so that for example any event whose interval has a null end will fail to parse.

Output data format

An application created with cohortMain will produce JSON output of a consistent format. Only the VariableRow JSON output differs in shape based on the variables produced in runVariables. See documentation for that type for details.

The following example demonstrates the JSON shape produced. Here, "main" refers to a single cohort called "main". The output object can include one or more elements, all of which have the shape of "main" below.

{
  "main": {
    "attritionJSON": {
      "attritionByStatus": [
        [
          {
            "tag": Included
          },
          2
        ],
        [
          {
            "contents": "continuousEnrollment",
            "tag": ExcludedBy
          },
          1
        ]
      ],
      "subjectsProcessed": 4,
      "unitsProcessed": 3
    },
    "cohortJSON": [
      {
        "obsIdJSON": {
          "fromSubjId": "3",
          "indexTime": [
            "2015-01-02",
            "2015-01-03"
          ]
        },
        "variableRowJSON": [
          {
            "attrs": {
              "varName": "ageAtIndex",
              "varType": INTSXP
            },
            "subAttrs": {
              "long_label": "Age at day of index, computed from January 7 of smallest provided birth year.",
              "short_label": "Age at day of index",
              "special_attrs": [
                "51"
              ],
              "study_role": null,
              "stypeType": "v_nominal"
            },
            "vals": [
              51
            ],
            "varTarget": StypeVector
          },
          {
            "attrs": {
              "varName": "primaryOutcome",
              "varType": INTSXP
            },
            "subAttrs": [],
            "vals": [
              null
            ],
            "varTarget": RVector
          }
        ]
      }
    ]
  }
}
  • "main" provides the top-level field for data on a given cohort, in this case called "main".
  • "attritionJSON" is an object providing a summary of attrition information for the cohort.
  • "cohortJSON" is an array of the output data produced for the cohort. It can be thought of as an array of rows, with one row per observational unit of the cohort. Specifically, each element is an object with two fields: "obsIdJSON" and "variableRowJSON".
  • "obsIdJSON" is an object providing the subject id and index time pair uniquely identifying the observational unit.
  • "variableRowJSON" provides an array of all output Variable values for that observational unit. See VariableRow for details on the shape of elements in this array.

At the moment, failure modes are not configurable. Logging is configurable via environment variables, as described in the top-level Blammo configuration documentation.

An application created with cohortMain will fail at runtime if

  • The command-line options parser, [execParser](https:/hackage.haskell.orgpackageoptparse-applicative-0.17.0.0docs/Options-Applicative-Extra.html#v:execParser) fails.
  • File reads / writes fail.
  • AWS and network errors, if input or output location is S3Input.
  • None of the input data event lines was parsed correctly, including cases in which there were no lines of input at all.

Logs produced at the info level:

  • The location from which data are read, as passed to the application from command-line options.
  • The names of cohorts to be built, meaning the labels passed to cohortMain in user-defined code via keys of Map Text (CohortSpec t m a).
  • The request http status and S3 object ETag hash, when S3 is the input source or output destination.

Note the application squashes AWS logs themselves, as produced in the amazonka package functions. These could be added if needed but are not included as yet because they are verbose.

Logs produced at the error level:

  • Event line parsing errors, with a reference to the line of input that failed. Note the application continues to process correctly parsed lines, if able.
  • A message stating no subject-level data parsed correctly, when applicable. The application then exits.

Event Data

Events depend heavily on the interval-algebra library. See that pacakge's documentation for information about the types and functions for working with intervals.

Working with Features

Feature present an interface for leveraging the type system to ensure the inputs and outputs of functions you write are indeed what you intended, with your intentions checked at compile time. At present, using Feature s is necessary for building an application with Hasklepias via cohortMain. However, that requirement will be relaxed, and Feature s will be provided as an experimental API for building cohorts, which could be integrated more tightly with the rest of Hasklepias at some point.

A Feature is a type parametrized by two types: name and d. The type d here stands for data, which then parametrizes the FeatureData type which is the singular value which a Feature contains. The d here can be almost anything and need not be a scalar, for example, all the following are valid types for d:

The name type a bit special: it does not appear on the right-hand side of the `=`. In type-theory parlance, name is a phantom type. We'll see in a bit how this can be useful. For now, think of the name as the name of a variable as you would in most programming languages. To summarize, a Feature 's type constructor takes two arguments (name and d), but its *value* constructor (MkFeature) takes a single value of type FeatureData d.

Values of the FeatureData type contain the data we're ultimately interested in analyzing or passing along to downstream applications. However, a FeatureData value does not simply contain data of type d. The type allows for the possibility of missingness, failures, or errors by using the Either type. A value of a FeatureData, then, is either a Left FeatureProblemFlag or a Right d.

The use of Either has important implications when defining Features, as we will see. Now that we know the internals of a Feature, how do we create Feature s? There are two ways to create features: (1) purely lifting data into a Feature or (2) writing a Definition: a function that defines a Feature based on other Features.

The first method is a way to get data directly into a Feature. Fhe following function takes a list of Events and makes a Feature of them:

allEvents :: [Event Day] -> Feature "allEvents" [Event Day]
allEvents = pure

The pure lifting is generally used to lift a subject's input data into a Feature, so that other features can be defined from a subject's data. Feature s are derived from other Features by the Definition type. Specifically, Definition is a type which contains a function which maps Feature inputs to a Feature output, for example:

myDef :: Definition (Feature "a" Int -> Feature "b" Bool)
myDef = define (x -> if x > 0 then True else False)

A Definition is created by the define (or defineA) function. One may ask why define is necessary, and we don't directly define the function (Feature "a" Int -> Feature "b" Bool) directly. What may not be obvious in the above, is that x is type Int not Feature "a" Int and the return type is Bool not Feature "b" Bool. The define function and Definition type do the magic of lifting these types to the Feature level. To see this, in the following, myDef2 is equivalent to myDef:

intToBool :: Int -> Bool
intToBool x = if x > 0 then True else False)

myDef2 :: Definition (Feature "a" Int -> Feature "b" Bool)
myDef2 = define intToBoo

The define function, then, let's us focus on the *logic* of our Features without needing to worry handling the error cases. If we were to write a function with signature Feature "a" Int -> Feature "b" Bool directly, it would look something like:

myFeat :: Feature "a" Int -> Feature "b" Bool
myFeat (MkFeature (MkFeatureData (Left r))) = MkFeature (MkFeatureData (Left r))
myFeat (MkFeature (MkFeatureData (Right x))) = MkFeature (MkFeatureData (Right $ intToBool x))

One would need to pattern match all the possible types of inputs, which gets more complicated as the number of inputs increases. As an aside, since Features are [Functors]( https://hackage.haskell.org/package/base-4.15.0.0/docs/Data-Functor.html), one could instead write:

myFeat :: Feature "a" Int -> Feature "b" Bool
myFeat = fmap intToBool

This would require understanding how Functors and similar structures are used. The define and defineA functions provide a common interface to these structures without needing to understand the details.

Evaluating Definitions

To evaluate a Definition, we use the eval function. Consider the following example. The input data is a list of Ints if the list is empty (null), this is considered an error in feat1. If the list has more than 3 elements, then in feat2, the sum is computed; otherwise 0 is returned.

featInts :: [Int] -> Feature "someInts" [Int]
featInts = pure

feat1 :: Definition (Feature "someInts" [Int] -> Feature "hasMoreThan3" Bool)
feat1 = defineA
  (ints -> if null ints then makeFeature (missingBecause $ CustomFlag "no data")
           else makeFeature $ featureDataR (length ints > 3))

feat2 :: Definition (
      Feature "hasMoreThan3" Bool
  -> Feature "someInts" [Int]
  -> Feature "sum" Int)
feat2 = define (b ints -> if b then sum ints else 0)

ex0 = featInts []
ex0a = eval feat1 ex0 -- MkFeature (MkFeatureData (Left (CustomFlag "no data")))
ex0b = eval feat2 (ex0a, ex0) -- MkFeature (MkFeatureData (Left (CustomFlag "no data")))

ex1 = featInts [3, 8]
ex1a = eval feat1 ex1 -- MkFeature (MkFeatureData (Right False))
ex1b = eval feat2 (ex1a, ex1) -- MkFeature (MkFeatureData (Right 0))

ex2 = featInts [1..4]
ex2a = eval feat1 ex2 -- MkFeature (MkFeatureData (Right True))
ex2b = eval feat2 (ex2a, ex2) -- MkFeature (MkFeatureData (Right 10))

Note the value of ex0b. It is a Left because the value of ex0a is a Left; in other words, errors propogate along Features. If a given Feature's dependency is a Left then that Feature will also be Left. A Feature's internal Either structure has important implications for designing Features and performance. Capturing an error in a Left is a way to prevent downstream dependencies from needing to be computed.

Type Safety of Features

In describing the Feature type, the utility of having the name as a type may not have been clear. To clarify, consider the following example:

x :: Feature "someInt" Natural
x = pure 39

y :: Feature "age" Natural
y = pure 43

f :: Definition (Feature "age" Natural -> Feature "isOld" Bool)
f = define (>= 39)

fail = eval f x
pass = eval f y

In the example, fail does not compile because "someInt" is not "age", even though both the data type are Natural.

Further reading

Feature s are an example of providing tight type-level control over a library API using phantom types, the name of a Feature, in the same spirit as the Noonan's Ghost of Departed Proofs.

module Features

Intervals based on an index

The assessment intervals provided are:

  • Baseline: an interval which either meets or precedes index. Covariates are typically assessed during baseline intervals. A cohort's specification may include multiple baseline intervals, as different features may require different baseline intervals. For example, one feature may use a baseline interval of 365 days prior to index, while another uses a baseline interval of 90 days before index up to 30 days before index.
  • Followup: an interval which is startedBy, metBy, or after an index. Outcomes are typically assessed during followup intervals. Similar to Baseline, a cohort's specification may include multiple followup intervals, as different features may require different followup intervals.

In future versions, one subject may have multiple values for an index corresponding to unique ObsUnit. That is, there is a 1-to-1 map between index values and observational units, but there may be a 1-to-many map from subjects to indices.

While users are protected from forming invalid assessment intervals, they still need to carefully consider how to filter events based on the assessment interval. Consider the following data:

               _      <- Index    (15, 16)
     ----------       <- Baseline (5, 15)
 ---                  <- A (1, 4)
  ---                 <- B (2, 5)
    ---               <- C (4, 7)
      ---             <- D (5, 8)
         ---          <- E (8, 11)
            ---       <- F (12, 15)
              ---     <- G (14, 17)
                 ___  <- H (17, 20)
|----|----|----|----|
0         10        20

We have index, baseline, and 8 events (A-H). If Baseline is our assessment interval, then the events concuring (i.e. not disjoint) with Baseline are C-G. While C-F probably make sense to use in deriving some covariate, what about G? The event G begins during baseline but ends after index. If you want, for example, to know how many events started during baseline, then you’d want to include G in your filter (using concur). But if you wanted to know the durations of events enclosed by baseline, then you wouldn’t want to filter using concur and instead perhaps use enclosedBy.

data BaselineInterval a Source #

A type to contain baseline intervals. See the Baseline typeclass for methods to create values of this type.

Instances

Instances details
Intervallic BaselineInterval Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Methods

getInterval :: BaselineInterval a -> Interval a

setInterval :: BaselineInterval a -> Interval b -> BaselineInterval b

Generic (BaselineInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Associated Types

type Rep (BaselineInterval a) :: Type -> Type #

(Show a, Ord a) => Show (BaselineInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Eq a => Eq (BaselineInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

type Rep (BaselineInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

type Rep (BaselineInterval a) = D1 ('MetaData "BaselineInterval" "Hasklepias.AssessmentIntervals" "hasklepias-main-0.30.3-inplace" 'True) (C1 ('MetaCons "MkBaselineInterval" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Interval a))))

class Intervallic i => Baseline i where Source #

Provides functions for creating a BaselineInterval from an index. The baselineMeets function should satify:

Meets
relate (baselineMeets d i) i = Meets

The baselineBefore function should satisfy:

Before
relate (baselineBefore s d i) i = Before

The baselineFinishedBy function should satisfy:

FinishedBy
relate (baselineFinishedBy s d i) i = FinishedBy
>>> x = (beginerval 1 10)
>>> b =baselineMeets 10 x
>>> b
MkBaselineInterval (0, 10)
>>> relate b x
Meets
>>> x = (beginerval 1 10)
>>> b = baselineBefore 2 4 x
>>> b
MkBaselineInterval (4, 8)
>>> relate b x
Before

Minimal complete definition

Nothing

Methods

baselineMeets Source #

Arguments

:: SizedIv (Interval a) 
=> Moment (Interval a)

duration of baseline

-> i a

the index event

-> BaselineInterval a 

Creates a BaselineInterval of the given duration that Meets the index interval.

baselineBefore Source #

Arguments

:: SizedIv (Interval a) 
=> Moment (Interval a)

duration to shift back

-> Moment (Interval a)

duration of baseline

-> i a

the index event

-> BaselineInterval a 

Creates a BaselineInterval of the given duration that precedes the index interval.

baselineFinishedBy Source #

Arguments

:: (SizedIv (Interval a), Ord a) 
=> Moment (Interval a)

duration of baseline - not including the duration of index

-> i a

the index event

-> BaselineInterval a 

Creates a BaselineInterval of the given duration that FinishedBy the index interval.

Instances

Instances details
Baseline Interval Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Methods

baselineMeets :: SizedIv (Interval a) => Moment (Interval a) -> Interval a -> BaselineInterval a Source #

baselineBefore :: SizedIv (Interval a) => Moment (Interval a) -> Moment (Interval a) -> Interval a -> BaselineInterval a Source #

baselineFinishedBy :: (SizedIv (Interval a), Ord a) => Moment (Interval a) -> Interval a -> BaselineInterval a Source #

data FollowupInterval a Source #

A type to contain followup intervals. See the Followup typeclass for methods to create values of this type.

Instances

Instances details
Intervallic FollowupInterval Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Methods

getInterval :: FollowupInterval a -> Interval a

setInterval :: FollowupInterval a -> Interval b -> FollowupInterval b

Generic (FollowupInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Associated Types

type Rep (FollowupInterval a) :: Type -> Type #

(Show a, Ord a) => Show (FollowupInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Eq a => Eq (FollowupInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

type Rep (FollowupInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

type Rep (FollowupInterval a) = D1 ('MetaData "FollowupInterval" "Hasklepias.AssessmentIntervals" "hasklepias-main-0.30.3-inplace" 'True) (C1 ('MetaCons "MkFollowupInterval" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Interval a))))

class Intervallic i => Followup i a where Source #

Provides functions for creating a FollowupInterval from an index. The followup function should satify:

StartedBy
relate (followup d i) i = StartedBy

The followupMetBy function should satisfy:

MetBy
relate (followupMetBy d i) i = MetBy

The followupAfter function should satisfy:

After
relate (followupAfter s d i) i = After
>>> x = (beginerval 1 10)
>>> f = followup 10 x
>>> f
MkFollowupInterval (10, 20)
>>> relate f x
StartedBy

Note the consequence of providing a duration less than or equal to the duration of the index: a 'IntervalAlgebra.moment is added to the duration, so that the end of the FollowupInterval is greater than the end of the index.

>>> x = (beginerval 1 10)
>>> f = followup 1 x
>>> f
MkFollowupInterval (10, 12)
>>> relate f x
StartedBy
>>> x = (beginerval 1 10)
>>> f = followupMetBy 9 x
>>> f
MkFollowupInterval (11, 20)
>>> relate f x
MetBy
>>> x = (beginerval 1 10)
>>> f = followupAfter 1 9 x
>>> f
MkFollowupInterval (12, 21)
>>> relate f x
After

Minimal complete definition

Nothing

Methods

followup Source #

Arguments

:: (SizedIv (Interval a), Ord (Moment (Interval a)), Num (Moment (Interval a)), Intervallic i) 
=> Moment (Interval a)

duration of followup

-> i a

the index event

-> FollowupInterval a 

followupMetBy Source #

Arguments

:: (SizedIv (Interval a), Intervallic i) 
=> Moment (Interval a)

duration of followup

-> i a

the index event

-> FollowupInterval a 

followupAfter Source #

Arguments

:: (SizedIv (Interval a), Intervallic i) 
=> Moment (Interval a)

duration add between the end of index and begin of followup

-> Moment (Interval a)

duration of followup

-> i a

the index event

-> FollowupInterval a 

Instances

Instances details
Followup Interval a Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Methods

followup :: Moment (Interval a) -> Interval a -> FollowupInterval a Source #

followupMetBy :: Moment (Interval a) -> Interval a -> FollowupInterval a Source #

followupAfter :: Moment (Interval a) -> Moment (Interval a) -> Interval a -> FollowupInterval a Source #

data AssessmentInterval a Source #

A data type that contains variants of intervals during which assessment may occur.

Instances

Instances details
Intervallic AssessmentInterval Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Methods

getInterval :: AssessmentInterval a -> Interval a

setInterval :: AssessmentInterval a -> Interval b -> AssessmentInterval b

Generic (AssessmentInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Associated Types

type Rep (AssessmentInterval a) :: Type -> Type #

(Show a, Ord a) => Show (AssessmentInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

Eq a => Eq (AssessmentInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

type Rep (AssessmentInterval a) Source # 
Instance details

Defined in Hasklepias.AssessmentIntervals

type Rep (AssessmentInterval a) = D1 ('MetaData "AssessmentInterval" "Hasklepias.AssessmentIntervals" "hasklepias-main-0.30.3-inplace" 'False) (C1 ('MetaCons "Bl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (BaselineInterval a))) :+: C1 ('MetaCons "Fl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (FollowupInterval a))))

makeBaselineMeetsIndex :: (Baseline i, SizedIv (Interval a)) => Moment (Interval a) -> i a -> AssessmentInterval a Source #

Creates an AssessmentInterval using the baseline function.

>>> x = beginerval 1 10
>>> makeBaselineMeetsIndex 10 x
Bl (MkBaselineInterval (0, 10))

makeBaselineBeforeIndex :: (Baseline i, SizedIv (Interval a)) => Moment (Interval a) -> Moment (Interval a) -> i a -> AssessmentInterval a Source #

Creates an AssessmentInterval using the baselineBefore function.

>>> x = beginerval 1 10
>>> makeBaselineBeforeIndex 2 10 x
Bl (MkBaselineInterval (-2, 8))

makeBaselineFinishedByIndex :: (Baseline i, SizedIv (Interval a), Ord a) => Moment (Interval a) -> i a -> AssessmentInterval a Source #

Creates an AssessmentInterval using the baselineFinishedBy function.

>>> x = beginerval 1 10
>>> makeBaselineFinishedByIndex 10 x
Bl (MkBaselineInterval (0, 11))

makeFollowupStartedByIndex :: (Followup i a, SizedIv (Interval a), Ord (Moment (Interval a)), Num (Moment (Interval a))) => Moment (Interval a) -> i a -> AssessmentInterval a Source #

Creates an AssessmentInterval using the followup function.

>>> x = beginerval 1 10
>>> makeFollowupStartedByIndex 10 x
Fl (MkFollowupInterval (10, 20))

makeFollowupMetByIndex :: (Followup i a, SizedIv (Interval a)) => Moment (Interval a) -> i a -> AssessmentInterval a Source #

Creates an AssessmentInterval using the followupMetBy function.

>>> x = beginerval 1 10
>>> makeFollowupMetByIndex 10 x
Fl (MkFollowupInterval (11, 21))

makeFollowupAfterIndex :: (Followup i a, SizedIv (Interval a)) => Moment (Interval a) -> Moment (Interval a) -> i a -> AssessmentInterval a Source #

Creates an AssessmentInterval using the followupAfter function.

>>> x = beginerval 1 10
>>> makeFollowupAfterIndex 10 10 x
Fl (MkFollowupInterval (21, 31))

Specifying and building cohorts

fromList :: IsList l => [Item l] -> l #

The fromList function constructs the structure l from the given list of Item l

toList :: IsList l => l -> [Item l] #

The toList function extracts a list of Item l from the structure l. It should satisfy fromList . toList = id.

data CohortSpec t m a #

A container for all logic needed to construct a cohort. The provided functions will be run on subject-level data, subject-by-subject. Logic will be executed as part of a CohortApp pipeline. The type CohortApp itself is not exported, but the user will create such a pipeline via the exported cohortMain.

Note runVariables must construct *all* output variables. For a more detailed explanation of the cohort-building pipeline, see the Hasklepias module documentation from `hasklepias-main`.

Constructors

MkCohortSpec 

Fields

  • runIndices :: NonEmpty (Event t m a) -> IndexSet a

    Constructs the set of index times, of type Interval a, for a given subject based on the full list of subject data in the NonEmpty input list of Event t m a.

  • runCriteria :: NonEmpty (Event t m a) -> Interval a -> Criteria

    Constructs a non-empty list of inclusion / exclusion criteria for a single subject, relative to a particular index time. There will be one Criteria value for each subject and element of IndexSet a.

  • runVariables :: NonEmpty (Event t m a) -> Interval a -> VariableRow

    Construct all output variables for the provided subject data, with respect to a particular index time.

type CohortSpecMap t m a = Map Text (CohortSpec t m a) #

Container for CohortSpec for different cohorts, as given by the Text keys.

data IndexSet b #

A type containing a Data.Set.Set of type Interval b, values of which serve as index times when defining cohorts. In cohort terminology, indices are the points in time at which an observational unit can be assessed whether it meets the criteria for inclusion in the cohort. For example, when i is Interval Day, then index events are days.

A reason for using a set as the underlying type is that indices must be unique within a subject. A subject cannot have multiple observational units for a given index.

Construct an IndexSet using toList.

Instances

Instances details
Ord b => IsList (IndexSet b) 
Instance details

Defined in Cohort.IndexSet

Associated Types

type Item (IndexSet b) #

Methods

fromList :: [Item (IndexSet b)] -> IndexSet b #

fromListN :: Int -> [Item (IndexSet b)] -> IndexSet b #

toList :: IndexSet b -> [Item (IndexSet b)] #

(Show b, Ord b) => Show (IndexSet b) 
Instance details

Defined in Cohort.IndexSet

Methods

showsPrec :: Int -> IndexSet b -> ShowS #

show :: IndexSet b -> String #

showList :: [IndexSet b] -> ShowS #

Eq b => Eq (IndexSet b) 
Instance details

Defined in Cohort.IndexSet

Methods

(==) :: IndexSet b -> IndexSet b -> Bool #

(/=) :: IndexSet b -> IndexSet b -> Bool #

type Item (IndexSet b) 
Instance details

Defined in Cohort.IndexSet

type Item (IndexSet b) = Interval b

excludeIf :: Bool -> Status #

Helpers to convert a Bool to a Status.

>>> includeIf True
>>> includeIf False
Include
Exclude

includeIf :: Bool -> Status #

Helpers to convert a Bool to a Status.

>>> includeIf True
>>> includeIf False
Include
Exclude

data Status #

Indication of whether a given subject should be included or excluded from the cohort.

Constructors

Include 
Exclude 

Instances

Instances details
Show Status 
Instance details

Defined in Cohort.Criteria

Eq Status 
Instance details

Defined in Cohort.Criteria

Methods

(==) :: Status -> Status -> Bool #

(/=) :: Status -> Status -> Bool #

data Criterion #

A Status paired with some descriptive label.

Constructors

MkCriterion 

Fields

Instances

Instances details
Show Criterion 
Instance details

Defined in Cohort.Criteria

Eq Criterion 
Instance details

Defined in Cohort.Criteria

Create a cohort application

cohortMain :: CohortConstraints t m a b => Map Text (CohortSpec t m a) -> IO () Source #

Create a command-line application for processing event-line data into cohorts, using the logic provided in each CohortSpec. See the top-level Hasklepias module documentation for details.

Create an application for filtering subjects

makeLineFilterApp Source #

Arguments

:: (Eq a, Eq i, Show i, MonadLogger m, MonadIO m) 
=> String

name of the app (e.g. a project's id)

-> (ByteString -> Maybe i)

parser for line identifier

-> (ByteString -> Maybe a)

parser

-> (a -> Bool)

predicate

-> m () 

Creates a application that filters (groups of) lines based on:

  • a function which constructs an identifier from a line indicating which group the line belongs to
  • a function which parses a line into some type a
  • a predicate function: a -> Bool

All groups of lines where at least one line satisfies the predicate are output. The rest are dropped.

makeFilterEventLineApp Source #

Arguments

:: (Eventable t m a, EventLineAble t m a b, FromJSONEvent t m a, MonadLogger f, MonadIO f) 
=> String

name of the app (e.g. a project's id)

-> (Event t m a -> Bool)

predicate to evaluate for each event

-> TaggerConfig t c m

List of tagging functions producing t tags, with signature M.Map Text c -> m -> t, along with the path to a dhall file with which to create M.Map Text c. Note c must be FromDhall, which is enforced in the constructor.

-> f () 

Create a application that filters event data with two arguments:

  • a string for the name of the application (e.g. the project ID)
  • a predicate function of type Event c m a -> Bool.

The application takes event data formatted as ndjson (i.e. one event per line). The application returns the event data filtered to all those subjects who have at least one event satisfying the given predicate. Each subject's data must be grouped in contiguous chunks of lines; otherwise, the application may not behave as expected and will not warn or raise an error. Lines that fail to parse as an Event do not satisfy the predicate, but are not dropped from the output. In other words, all of a subject's data is returned in the same order as the input, provided that at least one line successfully parses into an Event and satisfies the predicate.

runLineFilterAppSimple Source #

Arguments

:: (Eq a, Eq i, Show i) 
=> String

name of the app (e.g. a project's id)

-> (ByteString -> Maybe i)

parser for line identifier

-> (ByteString -> Maybe a)

parser

-> (a -> Bool)

predicate

-> IO () 

Creates an IO action from makeLineFilterApp

runFilterEventLineAppSimple Source #

Arguments

:: (Eventable t m a, EventLineAble t m a b, FromJSONEvent t m a) 
=> String

name of the app (e.g. a project's id)

-> (Event t m a -> Bool)

predicate to evaluate for each event

-> IO () 

Creates an IO action from makeFilterEventLineApp.

data TaggerConfig t c m where Source #

Entrypoint for specifying taggers in the asclepias line filter app. Configuration required to read in a dhall file, tagMapFile, as a M.Map Text c for use in each of the Tagger t c m functions. t is the tag type returned, and m is the type with which values in the M.Map Text c argument of the tagger will be compared to produce the tag. When TaggerConfig t c m is used in the asclepias line fitltering app, t, m will correspond to Event t m a.

c will almost invariably be a Codelist type, as exported by the non-public `fact-models` package, and similarly the m will be a model type from that package. Nonetheless they are left generic because the Codelist and model types are not and will not be imported into `hasklepias-main`. Note that c is required to be FromDhall. The dhall shape from which M.Map Text c is marshaled is of the form `toMap { key1 = val1, key2 = val2, ... }`, where `val1, val2` are values that marshal to the Haskell type c.

The path tagMapFile should be relative to where the line filter app will execute.

This example (not run in doctests) assumes you have a P0000Model in the `fact-models` package that has a simple Diagnosis variant, which holds a Code fact in its code field.

import Models.P0000Model import qualified Data.Map.Strict as M isCancer :: M.Map Text Codelist -> P0000Model -> Maybe Text isCancer cls (Diagnosis cd) = makeTag =lookInCl cd.code . (cl - cl.sets) $ SM.lookup "cancer" cls where lookInCl cd' csets' = any (cs -> cd'.codebook == cs.codebook && (cd'.code elem Prelude.map (x -> x.code) cs.codes)) csets' makeTag b = if b then Just "is_cancer" else Nothing

tc :: TaggerConfig Text Codelist P0000Model tc = MkTaggerConfig [isCancer] "plans/codelists.dhall"

Constructors

MkTaggerConfig 

Fields

inputTagMap :: TaggerConfig t c m -> IO (Map Text c) Source #

Construct the M.Map Text c by parsing the tagMapFile.

Rexported Functions and modules

Re-exports

findWithDefault :: Ord k => a -> k -> Map k a -> a #

O(log n). The expression (findWithDefault def k map) returns the value at key k or returns default value def when the key is not in the map.

findWithDefault 'x' 1 (fromList [(5,'a'), (3,'b')]) == 'x'
findWithDefault 'x' 5 (fromList [(5,'a'), (3,'b')]) == 'a'

data Map k a #

A Map from keys k to values a.

The Semigroup operation for Map is union, which prefers values from the left operand. If m1 maps a key k to a value a1, and m2 maps the same key to a different value a2, then their union m1 <> m2 maps k to a1.

Instances

Instances details
Bifoldable Map

Since: containers-0.6.3.1

Instance details

Defined in Data.Map.Internal

Methods

bifold :: Monoid m => Map m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Map a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Map a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Map a b -> c #

Eq2 Map

Since: containers-0.5.9

Instance details

Defined in Data.Map.Internal

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Map a c -> Map b d -> Bool #

Ord2 Map

Since: containers-0.5.9

Instance details

Defined in Data.Map.Internal

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Map a c -> Map b d -> Ordering #

Show2 Map

Since: containers-0.5.9

Instance details

Defined in Data.Map.Internal

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Map a b -> ShowS #

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Map a b] -> ShowS #

Hashable2 Map 
Instance details

Defined in Data.Hashable.Class

Methods

liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Map a b -> Int

FilterableWithIndex k (Map k) 
Instance details

Defined in Witherable

Methods

imapMaybe :: (k -> a -> Maybe b) -> Map k a -> Map k b

ifilter :: (k -> a -> Bool) -> Map k a -> Map k a

WitherableWithIndex k (Map k) 
Instance details

Defined in Witherable

Methods

iwither :: Applicative f => (k -> a -> f (Maybe b)) -> Map k a -> f (Map k b)

iwitherM :: Monad m => (k -> a -> m (Maybe b)) -> Map k a -> m (Map k b)

ifilterA :: Applicative f => (k -> a -> f Bool) -> Map k a -> f (Map k a)

(Ord k, Arbitrary k) => Arbitrary1 (Map k) 
Instance details

Defined in Test.QuickCheck.Arbitrary

Methods

liftArbitrary :: Gen a -> Gen (Map k a)

liftShrink :: (a -> [a]) -> Map k a -> [Map k a]

(FromJSONKey k, Ord k) => FromJSON1 (Map k) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Map k a)

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Map k a]

ToJSONKey k => ToJSON1 (Map k) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Map k a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Map k a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Map k a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Map k a] -> Encoding

Foldable (Map k)

Folds in order of increasing key.

Instance details

Defined in Data.Map.Internal

Methods

fold :: Monoid m => Map k m -> m #

foldMap :: Monoid m => (a -> m) -> Map k a -> m #

foldMap' :: Monoid m => (a -> m) -> Map k a -> m #

foldr :: (a -> b -> b) -> b -> Map k a -> b #

foldr' :: (a -> b -> b) -> b -> Map k a -> b #

foldl :: (b -> a -> b) -> b -> Map k a -> b #

foldl' :: (b -> a -> b) -> b -> Map k a -> b #

foldr1 :: (a -> a -> a) -> Map k a -> a #

foldl1 :: (a -> a -> a) -> Map k a -> a #

toList :: Map k a -> [a] #

null :: Map k a -> Bool #

length :: Map k a -> Int #

elem :: Eq a => a -> Map k a -> Bool #

maximum :: Ord a => Map k a -> a #

minimum :: Ord a => Map k a -> a #

sum :: Num a => Map k a -> a #

product :: Num a => Map k a -> a #

Eq k => Eq1 (Map k)

Since: containers-0.5.9

Instance details

Defined in Data.Map.Internal

Methods

liftEq :: (a -> b -> Bool) -> Map k a -> Map k b -> Bool #

Ord k => Ord1 (Map k)

Since: containers-0.5.9

Instance details

Defined in Data.Map.Internal

Methods

liftCompare :: (a -> b -> Ordering) -> Map k a -> Map k b -> Ordering #

(Ord k, Read k) => Read1 (Map k)

Since: containers-0.5.9

Instance details

Defined in Data.Map.Internal

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Map k a) #

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Map k a] #

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Map k a) #

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Map k a] #

Show k => Show1 (Map k)

Since: containers-0.5.9

Instance details

Defined in Data.Map.Internal

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Map k a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Map k a] -> ShowS #

Traversable (Map k)

Traverses in order of increasing key.

Instance details

Defined in Data.Map.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) #

sequenceA :: Applicative f => Map k (f a) -> f (Map k a) #

mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) #

sequence :: Monad m => Map k (m a) -> m (Map k a) #

Functor (Map k) 
Instance details

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> Map k a -> Map k b #

(<$) :: a -> Map k b -> Map k a #

Hashable k => Hashable1 (Map k) 
Instance details

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Map k a -> Int

Filterable (Map k) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b

catMaybes :: Map k (Maybe a) -> Map k a

filter :: (a -> Bool) -> Map k a -> Map k a #

Witherable (Map k) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Map k a -> f (Map k b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Map k a -> m (Map k b) #

filterA :: Applicative f => (a -> f Bool) -> Map k a -> f (Map k a) #

witherMap :: Applicative m => (Map k b -> r) -> (a -> m (Maybe b)) -> Map k a -> m r #

(Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map k v) 
Instance details

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Map k v)

shrink :: Map k v -> [Map k v]

(CoArbitrary k, CoArbitrary v) => CoArbitrary (Map k v) 
Instance details

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Map k v -> Gen b -> Gen b

(Ord a, Function a, Function b) => Function (Map a b) 
Instance details

Defined in Test.QuickCheck.Function

Methods

function :: (Map a b -> b0) -> Map a b :-> b0

(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Map k v) #

parseJSONList :: Value -> Parser [Map k v] #

(ToJSON v, ToJSONKey k) => ToJSON (Map k v) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Map k v -> Value #

toEncoding :: Map k v -> Encoding #

toJSONList :: [Map k v] -> Value #

toEncodingList :: [Map k v] -> Encoding #

(Data k, Data a, Ord k) => Data (Map k a) 
Instance details

Defined in Data.Map.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) #

toConstr :: Map k a -> Constr #

dataTypeOf :: Map k a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) #

gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

Ord k => Monoid (Map k v) 
Instance details

Defined in Data.Map.Internal

Methods

mempty :: Map k v #

mappend :: Map k v -> Map k v -> Map k v #

mconcat :: [Map k v] -> Map k v #

Ord k => Semigroup (Map k v) 
Instance details

Defined in Data.Map.Internal

Methods

(<>) :: Map k v -> Map k v -> Map k v #

sconcat :: NonEmpty (Map k v) -> Map k v #

stimes :: Integral b => b -> Map k v -> Map k v #

Ord k => IsList (Map k v)

Since: containers-0.5.6.2

Instance details

Defined in Data.Map.Internal

Associated Types

type Item (Map k v) #

Methods

fromList :: [Item (Map k v)] -> Map k v #

fromListN :: Int -> [Item (Map k v)] -> Map k v #

toList :: Map k v -> [Item (Map k v)] #

(Ord k, Read k, Read e) => Read (Map k e) 
Instance details

Defined in Data.Map.Internal

Methods

readsPrec :: Int -> ReadS (Map k e) #

readList :: ReadS [Map k e] #

readPrec :: ReadPrec (Map k e) #

readListPrec :: ReadPrec [Map k e] #

(Show k, Show a) => Show (Map k a) 
Instance details

Defined in Data.Map.Internal

Methods

showsPrec :: Int -> Map k a -> ShowS #

show :: Map k a -> String #

showList :: [Map k a] -> ShowS #

(NFData k, NFData a) => NFData (Map k a) 
Instance details

Defined in Data.Map.Internal

Methods

rnf :: Map k a -> () #

(Ord k, FromDhall k, FromDhall v) => FromDhall (Map k v) 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Map k v)

(ToDhall k, ToDhall v) => ToDhall (Map k v) 
Instance details

Defined in Dhall.Marshal.Encode

Methods

injectWith :: InputNormalizer -> Encoder (Map k v)

(Eq k, Eq a) => Eq (Map k a) 
Instance details

Defined in Data.Map.Internal

Methods

(==) :: Map k a -> Map k a -> Bool #

(/=) :: Map k a -> Map k a -> Bool #

(Ord k, Ord v) => Ord (Map k v) 
Instance details

Defined in Data.Map.Internal

Methods

compare :: Map k v -> Map k v -> Ordering #

(<) :: Map k v -> Map k v -> Bool #

(<=) :: Map k v -> Map k v -> Bool #

(>) :: Map k v -> Map k v -> Bool #

(>=) :: Map k v -> Map k v -> Bool #

max :: Map k v -> Map k v -> Map k v #

min :: Map k v -> Map k v -> Map k v #

(Hashable k, Hashable v) => Hashable (Map k v) 
Instance details

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Map k v -> Int

hash :: Map k v -> Int

Ord k => At (Map k a) 
Instance details

Defined in Control.Lens.At

Methods

at :: Index (Map k a) -> Lens' (Map k a) (Maybe (IxValue (Map k a)))

Ord k => Ixed (Map k a) 
Instance details

Defined in Control.Lens.At

Methods

ix :: Index (Map k a) -> Traversal' (Map k a) (IxValue (Map k a))

Ord k => Wrapped (Map k a) 
Instance details

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped (Map k a)

Methods

_Wrapped' :: Iso' (Map k a) (Unwrapped (Map k a))

Ord k => GrowingAppend (Map k v) 
Instance details

Defined in Data.MonoTraversable

MonoFoldable (Map k v) 
Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Map k v) -> m) -> Map k v -> m

ofoldr :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b

ofoldl' :: (a -> Element (Map k v) -> a) -> a -> Map k v -> a

otoList :: Map k v -> [Element (Map k v)]

oall :: (Element (Map k v) -> Bool) -> Map k v -> Bool

oany :: (Element (Map k v) -> Bool) -> Map k v -> Bool

onull :: Map k v -> Bool

olength :: Map k v -> Int

olength64 :: Map k v -> Int64

ocompareLength :: Integral i => Map k v -> i -> Ordering

otraverse_ :: Applicative f => (Element (Map k v) -> f b) -> Map k v -> f ()

ofor_ :: Applicative f => Map k v -> (Element (Map k v) -> f b) -> f ()

omapM_ :: Applicative m => (Element (Map k v) -> m ()) -> Map k v -> m ()

oforM_ :: Applicative m => Map k v -> (Element (Map k v) -> m ()) -> m ()

ofoldlM :: Monad m => (a -> Element (Map k v) -> m a) -> a -> Map k v -> m a

ofoldMap1Ex :: Semigroup m => (Element (Map k v) -> m) -> Map k v -> m

ofoldr1Ex :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Element (Map k v)

ofoldl1Ex' :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Element (Map k v)

headEx :: Map k v -> Element (Map k v)

lastEx :: Map k v -> Element (Map k v)

unsafeHead :: Map k v -> Element (Map k v)

unsafeLast :: Map k v -> Element (Map k v)

maximumByEx :: (Element (Map k v) -> Element (Map k v) -> Ordering) -> Map k v -> Element (Map k v)

minimumByEx :: (Element (Map k v) -> Element (Map k v) -> Ordering) -> Map k v -> Element (Map k v)

oelem :: Element (Map k v) -> Map k v -> Bool

onotElem :: Element (Map k v) -> Map k v -> Bool

MonoFunctor (Map k v) 
Instance details

Defined in Data.MonoTraversable

Methods

omap :: (Element (Map k v) -> Element (Map k v)) -> Map k v -> Map k v

MonoTraversable (Map k v) 
Instance details

Defined in Data.MonoTraversable

Methods

otraverse :: Applicative f => (Element (Map k v) -> f (Element (Map k v))) -> Map k v -> f (Map k v)

omapM :: Applicative m => (Element (Map k v) -> m (Element (Map k v))) -> Map k v -> m (Map k v)

(t ~ Map k' a', Ord k) => Rewrapped (Map k a) t 
Instance details

Defined in Control.Lens.Wrapped

type Item (Map k v) 
Instance details

Defined in Data.Map.Internal

type Item (Map k v) = (k, v)
type Index (Map k a) 
Instance details

Defined in Control.Lens.At

type Index (Map k a) = k
type IxValue (Map k a) 
Instance details

Defined in Control.Lens.At

type IxValue (Map k a) = a
type Unwrapped (Map k a) 
Instance details

Defined in Control.Lens.Wrapped

type Unwrapped (Map k a) = [(k, a)]
type Element (Map k v) 
Instance details

Defined in Data.MonoTraversable

type Element (Map k v) = v

lookup :: Ord k => k -> Map k a -> Maybe a #

O(log n). Lookup the value at a key in the map.

The function will return the corresponding value as (Just value), or Nothing if the key isn't in the map.

An example of using lookup:

import Prelude hiding (lookup)
import Data.Map

employeeDept = fromList([("John","Sales"), ("Bob","IT")])
deptCountry = fromList([("IT","USA"), ("Sales","France")])
countryCurrency = fromList([("USA", "Dollar"), ("France", "Euro")])

employeeCurrency :: String -> Maybe String
employeeCurrency name = do
    dept <- lookup name employeeDept
    country <- lookup dept deptCountry
    lookup country countryCurrency

main = do
    putStrLn $ "John's currency: " ++ (show (employeeCurrency "John"))
    putStrLn $ "Pete's currency: " ++ (show (employeeCurrency "Pete"))

The output of this program:

  John's currency: Just "Euro"
  Pete's currency: Nothing

(!?) :: Ord k => Map k a -> k -> Maybe a infixl 9 #

O(log n). Find the value at a key. Returns Nothing when the element can not be found.

fromList [(5, 'a'), (3, 'b')] !? 1 == Nothing
fromList [(5, 'a'), (3, 'b')] !? 5 == Just 'a'

Since: containers-0.5.9

data Set a #

A set of values a.

Instances

Instances details
ToJSON1 Set 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Set a -> Value

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Set a] -> Value

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Set a -> Encoding

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Set a] -> Encoding

Foldable Set

Folds in order of increasing key.

Instance details

Defined in Data.Set.Internal

Methods

fold :: Monoid m => Set m -> m #

foldMap :: Monoid m => (a -> m) -> Set a -> m #

foldMap' :: Monoid m => (a -> m) -> Set a -> m #

foldr :: (a -> b -> b) -> b -> Set a -> b #

foldr' :: (a -> b -> b) -> b -> Set a -> b #

foldl :: (b -> a -> b) -> b -> Set a -> b #

foldl' :: (b -> a -> b) -> b -> Set a -> b #

foldr1 :: (a -> a -> a) -> Set a -> a #

foldl1 :: (a -> a -> a) -> Set a -> a #

toList :: Set a -> [a] #

null :: Set a -> Bool #

length :: Set a -> Int #

elem :: Eq a => a -> Set a -> Bool #

maximum :: Ord a => Set a -> a #

minimum :: Ord a => Set a -> a #

sum :: Num a => Set a -> a #

product :: Num a => Set a -> a #

Eq1 Set

Since: containers-0.5.9

Instance details

Defined in Data.Set.Internal

Methods

liftEq :: (a -> b -> Bool) -> Set a -> Set b -> Bool #

Ord1 Set

Since: containers-0.5.9

Instance details

Defined in Data.Set.Internal

Methods

liftCompare :: (a -> b -> Ordering) -> Set a -> Set b -> Ordering #

Show1 Set

Since: containers-0.5.9

Instance details

Defined in Data.Set.Internal

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Set a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Set a] -> ShowS #

Hashable1 Set 
Instance details

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Set a -> Int

(Ord a, Arbitrary a) => Arbitrary (Set a) 
Instance details

Defined in Test.QuickCheck.Arbitrary

Methods

arbitrary :: Gen (Set a)

shrink :: Set a -> [Set a]

CoArbitrary a => CoArbitrary (Set a) 
Instance details

Defined in Test.QuickCheck.Arbitrary

Methods

coarbitrary :: Set a -> Gen b -> Gen b

(Ord a, Function a) => Function (Set a) 
Instance details

Defined in Test.QuickCheck.Function

Methods

function :: (Set a -> b) -> Set a :-> b

(Ord a, FromJSON a) => FromJSON (Set a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Set a) #

parseJSONList :: Value -> Parser [Set a] #

ToJSON a => ToJSON (Set a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Set a -> Value #

toEncoding :: Set a -> Encoding #

toJSONList :: [Set a] -> Value #

toEncodingList :: [Set a] -> Encoding #

(Data a, Ord a) => Data (Set a) 
Instance details

Defined in Data.Set.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Set a -> c (Set a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Set a) #

toConstr :: Set a -> Constr #

dataTypeOf :: Set a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Set a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Set a)) #

gmapT :: (forall b. Data b => b -> b) -> Set a -> Set a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Set a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Set a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

Ord a => Monoid (Set a) 
Instance details

Defined in Data.Set.Internal

Methods

mempty :: Set a #

mappend :: Set a -> Set a -> Set a #

mconcat :: [Set a] -> Set a #

Ord a => Semigroup (Set a)

Since: containers-0.5.7

Instance details

Defined in Data.Set.Internal

Methods

(<>) :: Set a -> Set a -> Set a #

sconcat :: NonEmpty (Set a) -> Set a #

stimes :: Integral b => b -> Set a -> Set a #

Ord a => IsList (Set a)

Since: containers-0.5.6.2

Instance details

Defined in Data.Set.Internal

Associated Types

type Item (Set a) #

Methods

fromList :: [Item (Set a)] -> Set a #

fromListN :: Int -> [Item (Set a)] -> Set a #

toList :: Set a -> [Item (Set a)] #

(Read a, Ord a) => Read (Set a) 
Instance details

Defined in Data.Set.Internal

Show a => Show (Set a) 
Instance details

Defined in Data.Set.Internal

Methods

showsPrec :: Int -> Set a -> ShowS #

show :: Set a -> String #

showList :: [Set a] -> ShowS #

NFData a => NFData (Set a) 
Instance details

Defined in Data.Set.Internal

Methods

rnf :: Set a -> () #

(FromDhall a, Ord a, Show a) => FromDhall (Set a) 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder (Set a)

ToDhall a => ToDhall (Set a) 
Instance details

Defined in Dhall.Marshal.Encode

Methods

injectWith :: InputNormalizer -> Encoder (Set a)

Eq a => Eq (Set a) 
Instance details

Defined in Data.Set.Internal

Methods

(==) :: Set a -> Set a -> Bool #

(/=) :: Set a -> Set a -> Bool #

Ord a => Ord (Set a) 
Instance details

Defined in Data.Set.Internal

Methods

compare :: Set a -> Set a -> Ordering #

(<) :: Set a -> Set a -> Bool #

(<=) :: Set a -> Set a -> Bool #

(>) :: Set a -> Set a -> Bool #

(>=) :: Set a -> Set a -> Bool #

max :: Set a -> Set a -> Set a #

min :: Set a -> Set a -> Set a #

Hashable v => Hashable (Set v) 
Instance details

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Set v -> Int

hash :: Set v -> Int

Ord k => At (Set k) 
Instance details

Defined in Control.Lens.At

Methods

at :: Index (Set k) -> Lens' (Set k) (Maybe (IxValue (Set k)))

Ord a => Contains (Set a) 
Instance details

Defined in Control.Lens.At

Methods

contains :: Index (Set a) -> Lens' (Set a) Bool

Ord k => Ixed (Set k) 
Instance details

Defined in Control.Lens.At

Methods

ix :: Index (Set k) -> Traversal' (Set k) (IxValue (Set k))

Ord a => Wrapped (Set a) 
Instance details

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped (Set a)

Methods

_Wrapped' :: Iso' (Set a) (Unwrapped (Set a))

Ord v => GrowingAppend (Set v) 
Instance details

Defined in Data.MonoTraversable

Ord e => MonoFoldable (Set e) 
Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Set e) -> m) -> Set e -> m

ofoldr :: (Element (Set e) -> b -> b) -> b -> Set e -> b

ofoldl' :: (a -> Element (Set e) -> a) -> a -> Set e -> a

otoList :: Set e -> [Element (Set e)]

oall :: (Element (Set e) -> Bool) -> Set e -> Bool

oany :: (Element (Set e) -> Bool) -> Set e -> Bool

onull :: Set e -> Bool

olength :: Set e -> Int

olength64 :: Set e -> Int64

ocompareLength :: Integral i => Set e -> i -> Ordering

otraverse_ :: Applicative f => (Element (Set e) -> f b) -> Set e -> f ()

ofor_ :: Applicative f => Set e -> (Element (Set e) -> f b) -> f ()

omapM_ :: Applicative m => (Element (Set e) -> m ()) -> Set e -> m ()

oforM_ :: Applicative m => Set e -> (Element (Set e) -> m ()) -> m ()

ofoldlM :: Monad m => (a -> Element (Set e) -> m a) -> a -> Set e -> m a

ofoldMap1Ex :: Semigroup m => (Element (Set e) -> m) -> Set e -> m

ofoldr1Ex :: (Element (Set e) -> Element (Set e) -> Element (Set e)) -> Set e -> Element (Set e)

ofoldl1Ex' :: (Element (Set e) -> Element (Set e) -> Element (Set e)) -> Set e -> Element (Set e)

headEx :: Set e -> Element (Set e)

lastEx :: Set e -> Element (Set e)

unsafeHead :: Set e -> Element (Set e)

unsafeLast :: Set e -> Element (Set e)

maximumByEx :: (Element (Set e) -> Element (Set e) -> Ordering) -> Set e -> Element (Set e)

minimumByEx :: (Element (Set e) -> Element (Set e) -> Ordering) -> Set e -> Element (Set e)

oelem :: Element (Set e) -> Set e -> Bool

onotElem :: Element (Set e) -> Set e -> Bool

MonoPointed (Set a) 
Instance details

Defined in Data.MonoTraversable

Methods

opoint :: Element (Set a) -> Set a

(t ~ Set a', Ord a) => Rewrapped (Set a) t 
Instance details

Defined in Control.Lens.Wrapped

Ord t => From (Set (Tag t)) (TagSet t) 
Instance details

Defined in EventDataTheory.Core

Methods

from :: Set (Tag t) -> TagSet t

Ord t => From (Set (Tag t)) [t] 
Instance details

Defined in EventDataTheory.Core

Methods

from :: Set (Tag t) -> [t]

Ord t => From (TagSet t) (Set (Tag t)) 
Instance details

Defined in EventDataTheory.Core

Methods

from :: TagSet t -> Set (Tag t)

Ord t => From [t] (Set (Tag t)) 
Instance details

Defined in EventDataTheory.Core

Methods

from :: [t] -> Set (Tag t)

type Item (Set a) 
Instance details

Defined in Data.Set.Internal

type Item (Set a) = a
type Index (Set a) 
Instance details

Defined in Control.Lens.At

type Index (Set a) = a
type IxValue (Set k) 
Instance details

Defined in Control.Lens.At

type IxValue (Set k) = ()
type Unwrapped (Set a) 
Instance details

Defined in Control.Lens.Wrapped

type Unwrapped (Set a) = [a]
type Element (Set e) 
Instance details

Defined in Data.MonoTraversable

type Element (Set e) = e

member :: Ord a => a -> Set a -> Bool #

O(log n). Is the element in the set?

empty :: Set a #

O(1). The empty set.

data DayOfWeek #

Instances

Instances details
FromJSON DayOfWeek 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser DayOfWeek #

parseJSONList :: Value -> Parser [DayOfWeek] #

FromJSONKey DayOfWeek 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

fromJSONKey :: FromJSONKeyFunction DayOfWeek

fromJSONKeyList :: FromJSONKeyFunction [DayOfWeek]

ToJSON DayOfWeek 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: DayOfWeek -> Value #

toEncoding :: DayOfWeek -> Encoding #

toJSONList :: [DayOfWeek] -> Value #

toEncodingList :: [DayOfWeek] -> Encoding #

ToJSONKey DayOfWeek 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSONKey :: ToJSONKeyFunction DayOfWeek

toJSONKeyList :: ToJSONKeyFunction [DayOfWeek]

Data DayOfWeek 
Instance details

Defined in Data.Time.Calendar.Week

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DayOfWeek -> c DayOfWeek #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DayOfWeek #

toConstr :: DayOfWeek -> Constr #

dataTypeOf :: DayOfWeek -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DayOfWeek) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DayOfWeek) #

gmapT :: (forall b. Data b => b -> b) -> DayOfWeek -> DayOfWeek #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DayOfWeek -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DayOfWeek -> r #

gmapQ :: (forall d. Data d => d -> u) -> DayOfWeek -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DayOfWeek -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DayOfWeek -> m DayOfWeek #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DayOfWeek -> m DayOfWeek #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DayOfWeek -> m DayOfWeek #

Enum DayOfWeek

"Circular", so for example [Tuesday ..] gives an endless sequence. Also: fromEnum gives [1 .. 7] for [Monday .. Sunday], and toEnum performs mod 7 to give a cycle of days.

Instance details

Defined in Data.Time.Calendar.Week

Ix DayOfWeek 
Instance details

Defined in Data.Time.Calendar.Week

Read DayOfWeek 
Instance details

Defined in Data.Time.Calendar.Week

Show DayOfWeek 
Instance details

Defined in Data.Time.Calendar.Week

NFData DayOfWeek 
Instance details

Defined in Data.Time.Calendar.Week

Methods

rnf :: DayOfWeek -> () #

FromDhall DayOfWeek 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder DayOfWeek

ToDhall DayOfWeek 
Instance details

Defined in Dhall.Marshal.Encode

Methods

injectWith :: InputNormalizer -> Encoder DayOfWeek

Eq DayOfWeek 
Instance details

Defined in Data.Time.Calendar.Week

Ord DayOfWeek 
Instance details

Defined in Data.Time.Calendar.Week

toGregorian :: Day -> (Year, MonthOfYear, DayOfMonth) #

Convert to proleptic Gregorian calendar.

gregorianMonthLength :: Year -> MonthOfYear -> DayOfMonth #

The number of days in a given month according to the proleptic Gregorian calendar.

fromGregorian :: Year -> MonthOfYear -> DayOfMonth -> Day #

Convert from proleptic Gregorian calendar. Invalid values will be clipped to the correct range, month first, then day.

addGregorianDurationClip :: CalendarDiffDays -> Day -> Day #

Add months (clipped to last day), then add days

type Year = Integer #

Year of Common Era.

type MonthOfYear = Int #

Month of year, in range 1 (January) to 12 (December).

type DayOfMonth = Int #

Day of month, in range 1 to 31.

data Day #

The Modified Julian Day is a standard count of days, with zero being the day 1858-11-17.

Instances

Instances details
FromJSON Day 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Day #

parseJSONList :: Value -> Parser [Day] #

FromJSONKey Day 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

fromJSONKey :: FromJSONKeyFunction Day

fromJSONKeyList :: FromJSONKeyFunction [Day]

ToJSON Day 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Day -> Value #

toEncoding :: Day -> Encoding #

toJSONList :: [Day] -> Value #

toEncodingList :: [Day] -> Encoding #

ToJSONKey Day 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSONKey :: ToJSONKeyFunction Day

toJSONKeyList :: ToJSONKeyFunction [Day]

Data Day 
Instance details

Defined in Data.Time.Calendar.Days

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Day -> c Day #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Day #

toConstr :: Day -> Constr #

dataTypeOf :: Day -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Day) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Day) #

gmapT :: (forall b. Data b => b -> b) -> Day -> Day #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Day -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Day -> r #

gmapQ :: (forall d. Data d => d -> u) -> Day -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Day -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Day -> m Day #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Day -> m Day #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Day -> m Day #

Enum Day 
Instance details

Defined in Data.Time.Calendar.Days

Methods

succ :: Day -> Day #

pred :: Day -> Day #

toEnum :: Int -> Day #

fromEnum :: Day -> Int #

enumFrom :: Day -> [Day] #

enumFromThen :: Day -> Day -> [Day] #

enumFromTo :: Day -> Day -> [Day] #

enumFromThenTo :: Day -> Day -> Day -> [Day] #

Ix Day 
Instance details

Defined in Data.Time.Calendar.Days

Methods

range :: (Day, Day) -> [Day] #

index :: (Day, Day) -> Day -> Int #

unsafeIndex :: (Day, Day) -> Day -> Int #

inRange :: (Day, Day) -> Day -> Bool #

rangeSize :: (Day, Day) -> Int #

unsafeRangeSize :: (Day, Day) -> Int #

NFData Day 
Instance details

Defined in Data.Time.Calendar.Days

Methods

rnf :: Day -> () #

FromDhall Day 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder Day

ToDhall Day 
Instance details

Defined in Dhall.Marshal.Encode

Methods

injectWith :: InputNormalizer -> Encoder Day

Buildable Day 
Instance details

Defined in Formatting.Buildable

Methods

build :: Day -> Builder

Eq Day 
Instance details

Defined in Data.Time.Calendar.Days

Methods

(==) :: Day -> Day -> Bool #

(/=) :: Day -> Day -> Bool #

Ord Day 
Instance details

Defined in Data.Time.Calendar.Days

Methods

compare :: Day -> Day -> Ordering #

(<) :: Day -> Day -> Bool #

(<=) :: Day -> Day -> Bool #

(>) :: Day -> Day -> Bool #

(>=) :: Day -> Day -> Bool #

max :: Day -> Day -> Day #

min :: Day -> Day -> Day #

AsRTypeRep 'STRSXP Day 
Instance details

Defined in Variable.R.SEXP

AsRTypeRep 'STRSXP (Vector Day) 
Instance details

Defined in Variable.R.SEXP

Methods

as_rtyperep :: Vector Day -> RTypeRep 'STRSXP #

AsRTypeRep 'STRSXP (Vector (Maybe Day)) 
Instance details

Defined in Variable.R.SEXP

Methods

as_rtyperep :: Vector (Maybe Day) -> RTypeRep 'STRSXP #

AsRTypeRep 'STRSXP (Maybe Day) 
Instance details

Defined in Variable.R.SEXP

AsRTypeRep 'STRSXP [Day] 
Instance details

Defined in Variable.R.SEXP

Methods

as_rtyperep :: [Day] -> RTypeRep 'STRSXP #

AsRTypeRep 'STRSXP [Maybe Day] 
Instance details

Defined in Variable.R.SEXP

SizedIv (Interval Day) 
Instance details

Defined in IntervalAlgebra.Core

Associated Types

type Moment (Interval Day)

Methods

moment :: Moment (Interval Day)

duration :: Interval Day -> Moment (Interval Day)

ivExpandr :: Moment (Interval Day) -> Interval Day -> Interval Day

ivExpandl :: Moment (Interval Day) -> Interval Day -> Interval Day

type Moment (Interval Day) 
Instance details

Defined in IntervalAlgebra.Core

type Moment (Interval Day) = Integer

data CalendarDiffDays #

Constructors

CalendarDiffDays 

Instances

Instances details
FromJSON CalendarDiffDays 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser CalendarDiffDays #

parseJSONList :: Value -> Parser [CalendarDiffDays] #

ToJSON CalendarDiffDays 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: CalendarDiffDays -> Value #

toEncoding :: CalendarDiffDays -> Encoding #

toJSONList :: [CalendarDiffDays] -> Value #

toEncodingList :: [CalendarDiffDays] -> Encoding #

Data CalendarDiffDays

Since: time-1.9.2

Instance details

Defined in Data.Time.Calendar.CalendarDiffDays

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CalendarDiffDays -> c CalendarDiffDays #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CalendarDiffDays #

toConstr :: CalendarDiffDays -> Constr #

dataTypeOf :: CalendarDiffDays -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CalendarDiffDays) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CalendarDiffDays) #

gmapT :: (forall b. Data b => b -> b) -> CalendarDiffDays -> CalendarDiffDays #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CalendarDiffDays -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CalendarDiffDays -> r #

gmapQ :: (forall d. Data d => d -> u) -> CalendarDiffDays -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CalendarDiffDays -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CalendarDiffDays -> m CalendarDiffDays #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CalendarDiffDays -> m CalendarDiffDays #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CalendarDiffDays -> m CalendarDiffDays #

Monoid CalendarDiffDays

Additive

Instance details

Defined in Data.Time.Calendar.CalendarDiffDays

Semigroup CalendarDiffDays

Additive

Instance details

Defined in Data.Time.Calendar.CalendarDiffDays

Show CalendarDiffDays 
Instance details

Defined in Data.Time.Calendar.CalendarDiffDays

NFData CalendarDiffDays 
Instance details

Defined in Data.Time.Calendar.CalendarDiffDays

Methods

rnf :: CalendarDiffDays -> () #

Eq CalendarDiffDays 
Instance details

Defined in Data.Time.Calendar.CalendarDiffDays

data Text #

A space efficient, packed, unboxed Unicode text type.

Instances

Instances details
FromJSON Text 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Text #

parseJSONList :: Value -> Parser [Text] #

FromJSONKey Text 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

fromJSONKey :: FromJSONKeyFunction Text

fromJSONKeyList :: FromJSONKeyFunction [Text]

ToJSON Text 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Text -> Value #

toEncoding :: Text -> Encoding #

toJSONList :: [Text] -> Value #

toEncodingList :: [Text] -> Encoding #

ToJSONKey Text 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSONKey :: ToJSONKeyFunction Text

toJSONKeyList :: ToJSONKeyFunction [Text]

ToBody Text 
Instance details

Defined in Amazonka.Data.Body

Methods

toBody :: Text -> RequestBody

ToHashedBody Text 
Instance details

Defined in Amazonka.Data.Body

Methods

toHashed :: Text -> HashedBody

ToPath Text 
Instance details

Defined in Amazonka.Data.Path

Methods

toPath :: Text -> ByteString

ToQuery Text 
Instance details

Defined in Amazonka.Data.Query

Methods

toQuery :: Text -> QueryString

Chunk Text 
Instance details

Defined in Data.Attoparsec.Internal.Types

Associated Types

type ChunkElem Text

Methods

nullChunk :: Text -> Bool

pappendChunk :: State Text -> Text -> State Text

atBufferEnd :: Text -> State Text -> Pos

bufferElemAt :: Text -> Pos -> State Text -> Maybe (ChunkElem Text, Int)

chunkElemToChar :: Text -> ChunkElem Text -> Char

FromDhall Text 
Instance details

Defined in Dhall.Marshal.Decode

Methods

autoWith :: InputNormalizer -> Decoder Text

ToDhall Text 
Instance details

Defined in Dhall.Marshal.Encode

Methods

injectWith :: InputNormalizer -> Encoder Text

ToLogStr Text 
Instance details

Defined in System.Log.FastLogger.LogStr

Methods

toLogStr :: Text -> LogStr

Buildable Text 
Instance details

Defined in Formatting.Buildable

Methods

build :: Text -> Builder

Hashable Text 
Instance details

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Text -> Int

hash :: Text -> Int

Ixed Text 
Instance details

Defined in Control.Lens.At

Methods

ix :: Index Text -> Traversal' Text (IxValue Text)

Stream Text 
Instance details

Defined in Text.Megaparsec.Stream

Associated Types

type Token Text

type Tokens Text

Methods

tokenToChunk :: Proxy Text -> Token Text -> Tokens Text

tokensToChunk :: Proxy Text -> [Token Text] -> Tokens Text

chunkToTokens :: Proxy Text -> Tokens Text -> [Token Text]

chunkLength :: Proxy Text -> Tokens Text -> Int

chunkEmpty :: Proxy Text -> Tokens Text -> Bool

take1_ :: Text -> Maybe (Token Text, Text)

takeN_ :: Int -> Text -> Maybe (Tokens Text, Text)

takeWhile_ :: (Token Text -> Bool) -> Text -> (Tokens Text, Text)

TraversableStream Text 
Instance details

Defined in Text.Megaparsec.Stream

Methods

reachOffset :: Int -> PosState Text -> (Maybe String, PosState Text)

reachOffsetNoLine :: Int -> PosState Text -> PosState Text

VisualStream Text 
Instance details

Defined in Text.Megaparsec.Stream

Methods

showTokens :: Proxy Text -> NonEmpty (Token Text) -> String

tokensLength :: Proxy Text -> NonEmpty (Token Text) -> Int

GrowingAppend Text 
Instance details

Defined in Data.MonoTraversable

MonoFoldable Text 
Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element Text -> m) -> Text -> m

ofoldr :: (Element Text -> b -> b) -> b -> Text -> b

ofoldl' :: (a -> Element Text -> a) -> a -> Text -> a

otoList :: Text -> [Element Text]

oall :: (Element Text -> Bool) -> Text -> Bool

oany :: (Element Text -> Bool) -> Text -> Bool

onull :: Text -> Bool

olength :: Text -> Int

olength64 :: Text -> Int64

ocompareLength :: Integral i => Text -> i -> Ordering

otraverse_ :: Applicative f => (Element Text -> f b) -> Text -> f ()

ofor_ :: Applicative f => Text -> (Element Text -> f b) -> f ()

omapM_ :: Applicative m => (Element Text -> m ()) -> Text -> m ()

oforM_ :: Applicative m => Text -> (Element Text -> m ()) -> m ()

ofoldlM :: Monad m => (a -> Element Text -> m a) -> a -> Text -> m a

ofoldMap1Ex :: Semigroup m => (Element Text -> m) -> Text -> m

ofoldr1Ex :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text

ofoldl1Ex' :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text

headEx :: Text -> Element Text

lastEx :: Text -> Element Text

unsafeHead :: Text -> Element Text

unsafeLast :: Text -> Element Text

maximumByEx :: (Element Text -> Element Text -> Ordering) -> Text -> Element Text

minimumByEx :: (Element Text -> Element Text -> Ordering) -> Text -> Element Text

oelem :: Element Text -> Text -> Bool

onotElem :: Element Text -> Text -> Bool

MonoFunctor Text 
Instance details

Defined in Data.MonoTraversable

Methods

omap :: (Element Text -> Element Text) -> Text -> Text

MonoPointed Text 
Instance details

Defined in Data.MonoTraversable

Methods

opoint :: Element Text -> Text

MonoTraversable Text 
Instance details

Defined in Data.MonoTraversable

Methods

otraverse :: Applicative f => (Element Text -> f (Element Text)) -> Text -> f Text

omapM :: Applicative m => (Element Text -> m (Element Text)) -> Text -> m Text

IsSequence Text 
Instance details

Defined in Data.Sequences

Methods

fromList :: [Element Text] -> Text

lengthIndex :: Text -> Index Text

break :: (Element Text -> Bool) -> Text -> (Text, Text)

span :: (Element Text -> Bool) -> Text -> (Text, Text)

dropWhile :: (Element Text -> Bool) -> Text -> Text

takeWhile :: (Element Text -> Bool) -> Text -> Text

splitAt :: Index Text -> Text -> (Text, Text)

unsafeSplitAt :: Index Text -> Text -> (Text, Text)

take :: Index Text -> Text -> Text

unsafeTake :: Index Text -> Text -> Text

drop :: Index Text -> Text -> Text

unsafeDrop :: Index Text -> Text -> Text

dropEnd :: Index Text -> Text -> Text

partition :: (Element Text -> Bool) -> Text -> (Text, Text)

uncons :: Text -> Maybe (Element Text, Text)

unsnoc :: Text -> Maybe (Text, Element Text)

filter :: (Element Text -> Bool) -> Text -> Text

filterM :: Monad m => (Element Text -> m Bool) -> Text -> m Text

replicate :: Index Text -> Element Text -> Text

replicateM :: Monad m => Index Text -> m (Element Text) -> m Text

groupBy :: (Element Text -> Element Text -> Bool) -> Text -> [Text]

groupAllOn :: Eq b => (Element Text -> b) -> Text -> [Text]

subsequences :: Text -> [Text]

permutations :: Text -> [Text]

tailEx :: Text -> Text

tailMay :: Text -> Maybe Text

initEx :: Text -> Text

initMay :: Text -> Maybe Text

unsafeTail :: Text -> Text

unsafeInit :: Text -> Text

index :: Text -> Index Text -> Maybe (Element Text)

indexEx :: Text -> Index Text -> Element Text

unsafeIndex :: Text -> Index Text -> Element Text

splitWhen :: (Element Text -> Bool) -> Text -> [Text]

SemiSequence Text 
Instance details

Defined in Data.Sequences

Associated Types

type Index Text

Methods

intersperse :: Element Text -> Text -> Text

reverse :: Text -> Text

find :: (Element Text -> Bool) -> Text -> Maybe (Element Text)

sortBy :: (Element Text -> Element Text -> Ordering) -> Text -> Text

cons :: Element Text -> Text -> Text

snoc :: Text -> Element Text -> Text

Textual Text 
Instance details

Defined in Data.Sequences

Methods

words :: Text -> [Text]

unwords :: (Element seq ~ Text, MonoFoldable seq) => seq -> Text

lines :: Text -> [Text]

unlines :: (Element seq ~ Text, MonoFoldable seq) => seq -> Text

toLower :: Text -> Text

toUpper :: Text -> Text

toCaseFold :: Text -> Text

breakWord :: Text -> (Text, Text)

breakLine :: Text -> (Text, Text)

Pretty Text 
Instance details

Defined in Prettyprinter.Internal

Methods

pretty :: Text -> Doc ann

prettyList :: [Text] -> Doc ann

AsRTypeRep 'STRSXP Text 
Instance details

Defined in Variable.R.SEXP

LazySequence Text Text 
Instance details

Defined in Data.Sequences

Utf8 Text ByteString 
Instance details

Defined in Data.Sequences

AsRTypeRep 'STRSXP (Vector Text) 
Instance details

Defined in Variable.R.SEXP

Methods

as_rtyperep :: Vector Text -> RTypeRep 'STRSXP #

AsRTypeRep 'STRSXP (Vector (Maybe Text)) 
Instance details

Defined in Variable.R.SEXP

Methods

as_rtyperep :: Vector (Maybe Text) -> RTypeRep 'STRSXP #

AsRTypeRep 'STRSXP (Maybe Text) 
Instance details

Defined in Variable.R.SEXP

AsRTypeRep 'STRSXP [Text] 
Instance details

Defined in Variable.R.SEXP

Methods

as_rtyperep :: [Text] -> RTypeRep 'STRSXP #

AsRTypeRep 'STRSXP [Maybe Text] 
Instance details

Defined in Variable.R.SEXP

Stream (NoShareInput Text) 
Instance details

Defined in Text.Megaparsec.Stream

Associated Types

type Token (NoShareInput Text)

type Tokens (NoShareInput Text)

Methods

tokenToChunk :: Proxy (NoShareInput Text) -> Token (NoShareInput Text) -> Tokens (NoShareInput Text)

tokensToChunk :: Proxy (NoShareInput Text) -> [Token (NoShareInput Text)] -> Tokens (NoShareInput Text)

chunkToTokens :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> [Token (NoShareInput Text)]

chunkLength :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> Int

chunkEmpty :: Proxy (NoShareInput Text) -> Tokens (NoShareInput Text) -> Bool

take1_ :: NoShareInput Text -> Maybe (Token (NoShareInput Text), NoShareInput Text)

takeN_ :: Int -> NoShareInput Text -> Maybe (Tokens (NoShareInput Text), NoShareInput Text)

takeWhile_ :: (Token (NoShareInput Text) -> Bool) -> NoShareInput Text -> (Tokens (NoShareInput Text), NoShareInput Text)

Stream (ShareInput Text) 
Instance details

Defined in Text.Megaparsec.Stream

Associated Types

type Token (ShareInput Text)

type Tokens (ShareInput Text)

Methods

tokenToChunk :: Proxy (ShareInput Text) -> Token (ShareInput Text) -> Tokens (ShareInput Text)

tokensToChunk :: Proxy (ShareInput Text) -> [Token (ShareInput Text)] -> Tokens (ShareInput Text)

chunkToTokens :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> [Token (ShareInput Text)]

chunkLength :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> Int

chunkEmpty :: Proxy (ShareInput Text) -> Tokens (ShareInput Text) -> Bool

take1_ :: ShareInput Text -> Maybe (Token (ShareInput Text), ShareInput Text)

takeN_ :: Int -> ShareInput Text -> Maybe (Tokens (ShareInput Text), ShareInput Text)

takeWhile_ :: (Token (ShareInput Text) -> Bool) -> ShareInput Text -> (Tokens (ShareInput Text), ShareInput Text)

type ChunkElem Text 
Instance details

Defined in Data.Attoparsec.Internal.Types

type ChunkElem Text = Char
type State Text 
Instance details

Defined in Data.Attoparsec.Internal.Types

type State Text = Buffer
type Item Text 
Instance details

Defined in Data.Text

type Item Text = Char
type Index Text 
Instance details

Defined in Control.Lens.At

type Index Text = Int
type IxValue Text 
Instance details

Defined in Control.Lens.At

type IxValue Text = Char
type Token Text 
Instance details

Defined in Text.Megaparsec.Stream

type Token Text = Token (ShareInput Text)
type Tokens Text 
Instance details

Defined in Text.Megaparsec.Stream

type Tokens Text = Tokens (ShareInput Text)
type Element Text 
Instance details

Defined in Data.MonoTraversable

type Element Text = Char
type Index Text 
Instance details

Defined in Data.Sequences

type Index Text = Int
type Builder 'True Text 
Instance details

Defined in Data.String.Interpolate.Conversion.TextSink

type Builder 'True Text = Text
type Token (NoShareInput Text) 
Instance details

Defined in Text.Megaparsec.Stream

type Token (NoShareInput Text) = Char
type Token (ShareInput Text) 
Instance details

Defined in Text.Megaparsec.Stream

type Token (ShareInput Text) = Char
type Tokens (NoShareInput Text) 
Instance details

Defined in Text.Megaparsec.Stream

type Tokens (NoShareInput Text) = Text
type Tokens (ShareInput Text) 
Instance details

Defined in Text.Megaparsec.Stream

type Tokens (ShareInput Text) = Text

pack :: String -> Text #

O(n) Convert a String into a Text. Subject to fusion. Performs replacement on invalid scalar values.

(^?) :: s -> Getting (First a) s a -> Maybe a #

headMay :: [a] -> Maybe a #

initMay :: [a] -> Maybe [a] #

lastMay :: [a] -> Maybe a #

maximumMay :: Ord a => [a] -> Maybe a #

minimumMay :: Ord a => [a] -> Maybe a #

tailMay :: [a] -> Maybe [a] #

(!>) :: a -> (a -> b) -> b #

(.>) :: (a -> b) -> (b -> c) -> a -> c #

(<!) :: (a -> b) -> a -> b #

(<.) :: (b -> c) -> (a -> b) -> a -> c #

(<|) :: (a -> b) -> a -> b #

(|>) :: a -> (a -> b) -> b #

class Functor f => Filterable (f :: Type -> Type) where #

Minimal complete definition

mapMaybe | catMaybes

Methods

filter :: (a -> Bool) -> f a -> f a #

Instances

Instances details
Filterable KeyMap 
Instance details

Defined in Data.Aeson.KeyMap

Methods

mapMaybe :: (a -> Maybe b) -> KeyMap a -> KeyMap b

catMaybes :: KeyMap (Maybe a) -> KeyMap a

filter :: (a -> Bool) -> KeyMap a -> KeyMap a #

Filterable ZipList 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> ZipList a -> ZipList b

catMaybes :: ZipList (Maybe a) -> ZipList a

filter :: (a -> Bool) -> ZipList a -> ZipList a #

Filterable IntMap 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b

catMaybes :: IntMap (Maybe a) -> IntMap a

filter :: (a -> Bool) -> IntMap a -> IntMap a #

Filterable Seq 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Seq a -> Seq b

catMaybes :: Seq (Maybe a) -> Seq a

filter :: (a -> Bool) -> Seq a -> Seq a #

Filterable Vector 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Vector a -> Vector b

catMaybes :: Vector (Maybe a) -> Vector a

filter :: (a -> Bool) -> Vector a -> Vector a #

Filterable Maybe 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Maybe a -> Maybe b

catMaybes :: Maybe (Maybe a) -> Maybe a

filter :: (a -> Bool) -> Maybe a -> Maybe a #

Filterable [] 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> [a] -> [b]

catMaybes :: [Maybe a] -> [a]

filter :: (a -> Bool) -> [a] -> [a] #

Monoid e => Filterable (Either e) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Either e a -> Either e b

catMaybes :: Either e (Maybe a) -> Either e a

filter :: (a -> Bool) -> Either e a -> Either e a #

Filterable (Proxy :: Type -> Type) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Proxy a -> Proxy b

catMaybes :: Proxy (Maybe a) -> Proxy a

filter :: (a -> Bool) -> Proxy a -> Proxy a #

Filterable (U1 :: Type -> Type) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> U1 a -> U1 b

catMaybes :: U1 (Maybe a) -> U1 a

filter :: (a -> Bool) -> U1 a -> U1 a #

Filterable (V1 :: Type -> Type) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> V1 a -> V1 b

catMaybes :: V1 (Maybe a) -> V1 a

filter :: (a -> Bool) -> V1 a -> V1 a #

Filterable (Map k) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b

catMaybes :: Map k (Maybe a) -> Map k a

filter :: (a -> Bool) -> Map k a -> Map k a #

Functor f => Filterable (MaybeT f) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> MaybeT f a -> MaybeT f b

catMaybes :: MaybeT f (Maybe a) -> MaybeT f a

filter :: (a -> Bool) -> MaybeT f a -> MaybeT f a #

(Eq k, Hashable k) => Filterable (HashMap k) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> HashMap k a -> HashMap k b

catMaybes :: HashMap k (Maybe a) -> HashMap k a

filter :: (a -> Bool) -> HashMap k a -> HashMap k a #

(Foldable f, Alternative f) => Filterable (WrappedFoldable f) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> WrappedFoldable f a -> WrappedFoldable f b

catMaybes :: WrappedFoldable f (Maybe a) -> WrappedFoldable f a

filter :: (a -> Bool) -> WrappedFoldable f a -> WrappedFoldable f a #

Filterable (Const r :: Type -> Type) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Const r a -> Const r b

catMaybes :: Const r (Maybe a) -> Const r a

filter :: (a -> Bool) -> Const r a -> Const r a #

Filterable f => Filterable (Rec1 f) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Rec1 f a -> Rec1 f b

catMaybes :: Rec1 f (Maybe a) -> Rec1 f a

filter :: (a -> Bool) -> Rec1 f a -> Rec1 f a #

Filterable t => Filterable (Backwards t) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Backwards t a -> Backwards t b

catMaybes :: Backwards t (Maybe a) -> Backwards t a

filter :: (a -> Bool) -> Backwards t a -> Backwards t a #

Filterable f => Filterable (IdentityT f) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> IdentityT f a -> IdentityT f b

catMaybes :: IdentityT f (Maybe a) -> IdentityT f a

filter :: (a -> Bool) -> IdentityT f a -> IdentityT f a #

Filterable t => Filterable (Reverse t) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Reverse t a -> Reverse t b

catMaybes :: Reverse t (Maybe a) -> Reverse t a

filter :: (a -> Bool) -> Reverse t a -> Reverse t a #

(Filterable f, Filterable g) => Filterable (Product f g) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Product f g a -> Product f g b

catMaybes :: Product f g (Maybe a) -> Product f g a

filter :: (a -> Bool) -> Product f g a -> Product f g a #

(Filterable f, Filterable g) => Filterable (Sum f g) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Sum f g a -> Sum f g b

catMaybes :: Sum f g (Maybe a) -> Sum f g a

filter :: (a -> Bool) -> Sum f g a -> Sum f g a #

(Filterable f, Filterable g) => Filterable (f :*: g) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> (f :*: g) a -> (f :*: g) b

catMaybes :: (f :*: g) (Maybe a) -> (f :*: g) a

filter :: (a -> Bool) -> (f :*: g) a -> (f :*: g) a #

(Filterable f, Filterable g) => Filterable (f :+: g) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> (f :+: g) a -> (f :+: g) b

catMaybes :: (f :+: g) (Maybe a) -> (f :+: g) a

filter :: (a -> Bool) -> (f :+: g) a -> (f :+: g) a #

Filterable (K1 i c :: Type -> Type) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> K1 i c a -> K1 i c b

catMaybes :: K1 i c (Maybe a) -> K1 i c a

filter :: (a -> Bool) -> K1 i c a -> K1 i c a #

(Functor f, Filterable g) => Filterable (Compose f g) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> Compose f g a -> Compose f g b

catMaybes :: Compose f g (Maybe a) -> Compose f g a

filter :: (a -> Bool) -> Compose f g a -> Compose f g a #

(Functor f, Filterable g) => Filterable (f :.: g) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> (f :.: g) a -> (f :.: g) b

catMaybes :: (f :.: g) (Maybe a) -> (f :.: g) a

filter :: (a -> Bool) -> (f :.: g) a -> (f :.: g) a #

Filterable f => Filterable (M1 i c f) 
Instance details

Defined in Witherable

Methods

mapMaybe :: (a -> Maybe b) -> M1 i c f a -> M1 i c f b

catMaybes :: M1 i c f (Maybe a) -> M1 i c f a

filter :: (a -> Bool) -> M1 i c f a -> M1 i c f a #

class (Traversable t, Filterable t) => Witherable (t :: Type -> Type) where #

Minimal complete definition

Nothing

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> t a -> f (t b) #

witherM :: Monad m => (a -> m (Maybe b)) -> t a -> m (t b) #

filterA :: Applicative f => (a -> f Bool) -> t a -> f (t a) #

witherMap :: Applicative m => (t b -> r) -> (a -> m (Maybe b)) -> t a -> m r #

Instances

Instances details
Witherable KeyMap 
Instance details

Defined in Data.Aeson.KeyMap

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> KeyMap a -> f (KeyMap b) #

witherM :: Monad m => (a -> m (Maybe b)) -> KeyMap a -> m (KeyMap b) #

filterA :: Applicative f => (a -> f Bool) -> KeyMap a -> f (KeyMap a) #

witherMap :: Applicative m => (KeyMap b -> r) -> (a -> m (Maybe b)) -> KeyMap a -> m r #

Witherable ZipList 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> ZipList a -> f (ZipList b) #

witherM :: Monad m => (a -> m (Maybe b)) -> ZipList a -> m (ZipList b) #

filterA :: Applicative f => (a -> f Bool) -> ZipList a -> f (ZipList a) #

witherMap :: Applicative m => (ZipList b -> r) -> (a -> m (Maybe b)) -> ZipList a -> m r #

Witherable IntMap 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> IntMap a -> f (IntMap b) #

witherM :: Monad m => (a -> m (Maybe b)) -> IntMap a -> m (IntMap b) #

filterA :: Applicative f => (a -> f Bool) -> IntMap a -> f (IntMap a) #

witherMap :: Applicative m => (IntMap b -> r) -> (a -> m (Maybe b)) -> IntMap a -> m r #

Witherable Seq 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Seq a -> f (Seq b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Seq a -> m (Seq b) #

filterA :: Applicative f => (a -> f Bool) -> Seq a -> f (Seq a) #

witherMap :: Applicative m => (Seq b -> r) -> (a -> m (Maybe b)) -> Seq a -> m r #

Witherable Vector 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Vector a -> f (Vector b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Vector a -> m (Vector b) #

filterA :: Applicative f => (a -> f Bool) -> Vector a -> f (Vector a) #

witherMap :: Applicative m => (Vector b -> r) -> (a -> m (Maybe b)) -> Vector a -> m r #

Witherable Maybe 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Maybe a -> f (Maybe b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Maybe a -> m (Maybe b) #

filterA :: Applicative f => (a -> f Bool) -> Maybe a -> f (Maybe a) #

witherMap :: Applicative m => (Maybe b -> r) -> (a -> m (Maybe b)) -> Maybe a -> m r #

Witherable [] 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> [a] -> f [b] #

witherM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] #

filterA :: Applicative f => (a -> f Bool) -> [a] -> f [a] #

witherMap :: Applicative m => ([b] -> r) -> (a -> m (Maybe b)) -> [a] -> m r #

Monoid e => Witherable (Either e) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Either e a -> f (Either e b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Either e a -> m (Either e b) #

filterA :: Applicative f => (a -> f Bool) -> Either e a -> f (Either e a) #

witherMap :: Applicative m => (Either e b -> r) -> (a -> m (Maybe b)) -> Either e a -> m r #

Witherable (Proxy :: Type -> Type) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Proxy a -> f (Proxy b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Proxy a -> m (Proxy b) #

filterA :: Applicative f => (a -> f Bool) -> Proxy a -> f (Proxy a) #

witherMap :: Applicative m => (Proxy b -> r) -> (a -> m (Maybe b)) -> Proxy a -> m r #

Witherable (U1 :: Type -> Type) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> U1 a -> f (U1 b) #

witherM :: Monad m => (a -> m (Maybe b)) -> U1 a -> m (U1 b) #

filterA :: Applicative f => (a -> f Bool) -> U1 a -> f (U1 a) #

witherMap :: Applicative m => (U1 b -> r) -> (a -> m (Maybe b)) -> U1 a -> m r #

Witherable (V1 :: Type -> Type) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> V1 a -> f (V1 b) #

witherM :: Monad m => (a -> m (Maybe b)) -> V1 a -> m (V1 b) #

filterA :: Applicative f => (a -> f Bool) -> V1 a -> f (V1 a) #

witherMap :: Applicative m => (V1 b -> r) -> (a -> m (Maybe b)) -> V1 a -> m r #

Witherable (Map k) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Map k a -> f (Map k b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Map k a -> m (Map k b) #

filterA :: Applicative f => (a -> f Bool) -> Map k a -> f (Map k a) #

witherMap :: Applicative m => (Map k b -> r) -> (a -> m (Maybe b)) -> Map k a -> m r #

Traversable t => Witherable (MaybeT t) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> MaybeT t a -> f (MaybeT t b) #

witherM :: Monad m => (a -> m (Maybe b)) -> MaybeT t a -> m (MaybeT t b) #

filterA :: Applicative f => (a -> f Bool) -> MaybeT t a -> f (MaybeT t a) #

witherMap :: Applicative m => (MaybeT t b -> r) -> (a -> m (Maybe b)) -> MaybeT t a -> m r #

(Eq k, Hashable k) => Witherable (HashMap k) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> HashMap k a -> f (HashMap k b) #

witherM :: Monad m => (a -> m (Maybe b)) -> HashMap k a -> m (HashMap k b) #

filterA :: Applicative f => (a -> f Bool) -> HashMap k a -> f (HashMap k a) #

witherMap :: Applicative m => (HashMap k b -> r) -> (a -> m (Maybe b)) -> HashMap k a -> m r #

(Alternative f, Traversable f) => Witherable (WrappedFoldable f) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> WrappedFoldable f a -> f0 (WrappedFoldable f b) #

witherM :: Monad m => (a -> m (Maybe b)) -> WrappedFoldable f a -> m (WrappedFoldable f b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> WrappedFoldable f a -> f0 (WrappedFoldable f a) #

witherMap :: Applicative m => (WrappedFoldable f b -> r) -> (a -> m (Maybe b)) -> WrappedFoldable f a -> m r #

Witherable (Const r :: Type -> Type) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Const r a -> f (Const r b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Const r a -> m (Const r b) #

filterA :: Applicative f => (a -> f Bool) -> Const r a -> f (Const r a) #

witherMap :: Applicative m => (Const r b -> r0) -> (a -> m (Maybe b)) -> Const r a -> m r0 #

Witherable f => Witherable (Rec1 f) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Rec1 f a -> f0 (Rec1 f b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Rec1 f a -> m (Rec1 f b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> Rec1 f a -> f0 (Rec1 f a) #

witherMap :: Applicative m => (Rec1 f b -> r) -> (a -> m (Maybe b)) -> Rec1 f a -> m r #

Witherable t => Witherable (Backwards t) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Backwards t a -> f (Backwards t b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Backwards t a -> m (Backwards t b) #

filterA :: Applicative f => (a -> f Bool) -> Backwards t a -> f (Backwards t a) #

witherMap :: Applicative m => (Backwards t b -> r) -> (a -> m (Maybe b)) -> Backwards t a -> m r #

Witherable f => Witherable (IdentityT f) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> IdentityT f a -> f0 (IdentityT f b) #

witherM :: Monad m => (a -> m (Maybe b)) -> IdentityT f a -> m (IdentityT f b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> IdentityT f a -> f0 (IdentityT f a) #

witherMap :: Applicative m => (IdentityT f b -> r) -> (a -> m (Maybe b)) -> IdentityT f a -> m r #

Witherable t => Witherable (Reverse t) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> Reverse t a -> f (Reverse t b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Reverse t a -> m (Reverse t b) #

filterA :: Applicative f => (a -> f Bool) -> Reverse t a -> f (Reverse t a) #

witherMap :: Applicative m => (Reverse t b -> r) -> (a -> m (Maybe b)) -> Reverse t a -> m r #

(Witherable f, Witherable g) => Witherable (Product f g) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Product f g a -> f0 (Product f g b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Product f g a -> m (Product f g b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> Product f g a -> f0 (Product f g a) #

witherMap :: Applicative m => (Product f g b -> r) -> (a -> m (Maybe b)) -> Product f g a -> m r #

(Witherable f, Witherable g) => Witherable (Sum f g) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Sum f g a -> f0 (Sum f g b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Sum f g a -> m (Sum f g b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> Sum f g a -> f0 (Sum f g a) #

witherMap :: Applicative m => (Sum f g b -> r) -> (a -> m (Maybe b)) -> Sum f g a -> m r #

(Witherable f, Witherable g) => Witherable (f :*: g) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> (f :*: g) a -> f0 ((f :*: g) b) #

witherM :: Monad m => (a -> m (Maybe b)) -> (f :*: g) a -> m ((f :*: g) b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> (f :*: g) a -> f0 ((f :*: g) a) #

witherMap :: Applicative m => ((f :*: g) b -> r) -> (a -> m (Maybe b)) -> (f :*: g) a -> m r #

(Witherable f, Witherable g) => Witherable (f :+: g) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> (f :+: g) a -> f0 ((f :+: g) b) #

witherM :: Monad m => (a -> m (Maybe b)) -> (f :+: g) a -> m ((f :+: g) b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> (f :+: g) a -> f0 ((f :+: g) a) #

witherMap :: Applicative m => ((f :+: g) b -> r) -> (a -> m (Maybe b)) -> (f :+: g) a -> m r #

Witherable (K1 i c :: Type -> Type) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f => (a -> f (Maybe b)) -> K1 i c a -> f (K1 i c b) #

witherM :: Monad m => (a -> m (Maybe b)) -> K1 i c a -> m (K1 i c b) #

filterA :: Applicative f => (a -> f Bool) -> K1 i c a -> f (K1 i c a) #

witherMap :: Applicative m => (K1 i c b -> r) -> (a -> m (Maybe b)) -> K1 i c a -> m r #

(Traversable f, Witherable g) => Witherable (Compose f g) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> Compose f g a -> f0 (Compose f g b) #

witherM :: Monad m => (a -> m (Maybe b)) -> Compose f g a -> m (Compose f g b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> Compose f g a -> f0 (Compose f g a) #

witherMap :: Applicative m => (Compose f g b -> r) -> (a -> m (Maybe b)) -> Compose f g a -> m r #

(Traversable f, Witherable g) => Witherable (f :.: g) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> (f :.: g) a -> f0 ((f :.: g) b) #

witherM :: Monad m => (a -> m (Maybe b)) -> (f :.: g) a -> m ((f :.: g) b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> (f :.: g) a -> f0 ((f :.: g) a) #

witherMap :: Applicative m => ((f :.: g) b -> r) -> (a -> m (Maybe b)) -> (f :.: g) a -> m r #

Witherable f => Witherable (M1 i c f) 
Instance details

Defined in Witherable

Methods

wither :: Applicative f0 => (a -> f0 (Maybe b)) -> M1 i c f a -> f0 (M1 i c f b) #

witherM :: Monad m => (a -> m (Maybe b)) -> M1 i c f a -> m (M1 i c f b) #

filterA :: Applicative f0 => (a -> f0 Bool) -> M1 i c f a -> f0 (M1 i c f a) #

witherMap :: Applicative m => (M1 i c f b -> r) -> (a -> m (Maybe b)) -> M1 i c f a -> m r #

Re-exports of (potentially) unsafe functions

class FromJSON a where #

Minimal complete definition

Nothing

Methods

parseJSON :: Value -> Parser a #

parseJSONList :: Value -> Parser [a] #

Instances

Instances details
FromJSON Key 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Key #

parseJSONList :: Value -> Parser [Key] #

FromJSON DotNetTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser DotNetTime #

parseJSONList :: Value -> Parser [DotNetTime] #

FromJSON Value 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Value #

parseJSONList :: Value -> Parser [Value] #

FromJSON CachedAccessToken 
Instance details

Defined in Amazonka.Auth.SSO

Methods

parseJSON :: Value -> Parser CachedAccessToken #

parseJSONList :: Value -> Parser [CachedAccessToken] #

FromJSON IdentityDocument 
Instance details

Defined in Amazonka.EC2.Metadata

Methods

parseJSON :: Value -> Parser IdentityDocument #

parseJSONList :: Value -> Parser [IdentityDocument] #

FromJSON Base64 
Instance details

Defined in Amazonka.Data.Base64

Methods

parseJSON :: Value -> Parser Base64 #

parseJSONList :: Value -> Parser [Base64] #

FromJSON AWSTime 
Instance details

Defined in Amazonka.Data.Time

Methods

parseJSON :: Value -> Parser AWSTime #

parseJSONList :: Value -> Parser [AWSTime] #

FromJSON BasicTime 
Instance details

Defined in Amazonka.Data.Time

Methods

parseJSON :: Value -> Parser BasicTime #

parseJSONList :: Value -> Parser [BasicTime] #

FromJSON ISO8601 
Instance details

Defined in Amazonka.Data.Time

Methods

parseJSON :: Value -> Parser ISO8601 #

parseJSONList :: Value -> Parser [ISO8601] #

FromJSON POSIX 
Instance details

Defined in Amazonka.Data.Time

Methods

parseJSON :: Value -> Parser POSIX #

parseJSONList :: Value -> Parser [POSIX] #

FromJSON RFC822 
Instance details

Defined in Amazonka.Data.Time

Methods

parseJSON :: Value -> Parser RFC822 #

parseJSONList :: Value -> Parser [RFC822] #

FromJSON Abbrev 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser Abbrev #

parseJSONList :: Value -> Parser [Abbrev] #

FromJSON AccessKey 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser AccessKey #

parseJSONList :: Value -> Parser [AccessKey] #

FromJSON AuthEnv 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser AuthEnv #

parseJSONList :: Value -> Parser [AuthEnv] #

FromJSON ErrorCode 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser ErrorCode #

parseJSONList :: Value -> Parser [ErrorCode] #

FromJSON ErrorMessage 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser ErrorMessage #

parseJSONList :: Value -> Parser [ErrorMessage] #

FromJSON Region 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser Region #

parseJSONList :: Value -> Parser [Region] #

FromJSON RequestId 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser RequestId #

parseJSONList :: Value -> Parser [RequestId] #

FromJSON SecretKey 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser SecretKey #

parseJSONList :: Value -> Parser [SecretKey] #

FromJSON SessionToken 
Instance details

Defined in Amazonka.Types

Methods

parseJSON :: Value -> Parser SessionToken #

parseJSONList :: Value -> Parser [SessionToken] #

FromJSON BucketName 
Instance details

Defined in Amazonka.S3.Internal

Methods

parseJSON :: Value -> Parser BucketName #

parseJSONList :: Value -> Parser [BucketName] #

FromJSON AnalyticsS3ExportFileFormat 
Instance details

Defined in Amazonka.S3.Types.AnalyticsS3ExportFileFormat

Methods

parseJSON :: Value -> Parser AnalyticsS3ExportFileFormat #

parseJSONList :: Value -> Parser [AnalyticsS3ExportFileFormat] #

FromJSON ArchiveStatus 
Instance details

Defined in Amazonka.S3.Types.ArchiveStatus

Methods

parseJSON :: Value -> Parser ArchiveStatus #

parseJSONList :: Value -> Parser [ArchiveStatus] #

FromJSON BucketAccelerateStatus 
Instance details

Defined in Amazonka.S3.Types.BucketAccelerateStatus

Methods

parseJSON :: Value -> Parser BucketAccelerateStatus #

parseJSONList :: Value -> Parser [BucketAccelerateStatus] #

FromJSON BucketCannedACL 
Instance details

Defined in Amazonka.S3.Types.BucketCannedACL

Methods

parseJSON :: Value -> Parser BucketCannedACL #

parseJSONList :: Value -> Parser [BucketCannedACL] #

FromJSON BucketLogsPermission 
Instance details

Defined in Amazonka.S3.Types.BucketLogsPermission

Methods

parseJSON :: Value -> Parser BucketLogsPermission #

parseJSONList :: Value -> Parser [BucketLogsPermission] #

FromJSON BucketVersioningStatus 
Instance details

Defined in Amazonka.S3.Types.BucketVersioningStatus

Methods

parseJSON :: Value -> Parser BucketVersioningStatus #

parseJSONList :: Value -> Parser [BucketVersioningStatus] #

FromJSON CompressionType 
Instance details

Defined in Amazonka.S3.Types.CompressionType

Methods

parseJSON :: Value -> Parser CompressionType #

parseJSONList :: Value -> Parser [CompressionType] #

FromJSON DeleteMarkerReplicationStatus 
Instance details

Defined in Amazonka.S3.Types.DeleteMarkerReplicationStatus

Methods

parseJSON :: Value -> Parser DeleteMarkerReplicationStatus #

parseJSONList :: Value -> Parser [DeleteMarkerReplicationStatus] #

FromJSON EncodingType 
Instance details

Defined in Amazonka.S3.Types.EncodingType

Methods

parseJSON :: Value -> Parser EncodingType #

parseJSONList :: Value -> Parser [EncodingType] #

FromJSON Event 
Instance details

Defined in Amazonka.S3.Types.Event

Methods

parseJSON :: Value -> Parser Event #

parseJSONList :: Value -> Parser [Event] #

FromJSON ExistingObjectReplicationStatus 
Instance details

Defined in Amazonka.S3.Types.ExistingObjectReplicationStatus

Methods

parseJSON :: Value -> Parser ExistingObjectReplicationStatus #

parseJSONList :: Value -> Parser [ExistingObjectReplicationStatus] #

FromJSON ExpirationStatus 
Instance details

Defined in Amazonka.S3.Types.ExpirationStatus

Methods

parseJSON :: Value -> Parser ExpirationStatus #

parseJSONList :: Value -> Parser [ExpirationStatus] #

FromJSON ExpressionType 
Instance details

Defined in Amazonka.S3.Types.ExpressionType

Methods

parseJSON :: Value -> Parser ExpressionType #

parseJSONList :: Value -> Parser [ExpressionType] #

FromJSON FileHeaderInfo 
Instance details

Defined in Amazonka.S3.Types.FileHeaderInfo

Methods

parseJSON :: Value -> Parser FileHeaderInfo #

parseJSONList :: Value -> Parser [FileHeaderInfo] #

FromJSON FilterRuleName 
Instance details

Defined in Amazonka.S3.Types.FilterRuleName

Methods

parseJSON :: Value -> Parser FilterRuleName #

parseJSONList :: Value -> Parser [FilterRuleName] #

FromJSON IntelligentTieringAccessTier 
Instance details

Defined in Amazonka.S3.Types.IntelligentTieringAccessTier

Methods

parseJSON :: Value -> Parser IntelligentTieringAccessTier #

parseJSONList :: Value -> Parser [IntelligentTieringAccessTier] #

FromJSON IntelligentTieringStatus 
Instance details

Defined in Amazonka.S3.Types.IntelligentTieringStatus

Methods

parseJSON :: Value -> Parser IntelligentTieringStatus #

parseJSONList :: Value -> Parser [IntelligentTieringStatus] #

FromJSON InventoryFormat 
Instance details

Defined in Amazonka.S3.Types.InventoryFormat

Methods

parseJSON :: Value -> Parser InventoryFormat #

parseJSONList :: Value -> Parser [InventoryFormat] #

FromJSON InventoryFrequency 
Instance details

Defined in Amazonka.S3.Types.InventoryFrequency

Methods

parseJSON :: Value -> Parser InventoryFrequency #

parseJSONList :: Value -> Parser [InventoryFrequency] #

FromJSON InventoryIncludedObjectVersions 
Instance details

Defined in Amazonka.S3.Types.InventoryIncludedObjectVersions

Methods

parseJSON :: Value -> Parser InventoryIncludedObjectVersions #

parseJSONList :: Value -> Parser [InventoryIncludedObjectVersions] #

FromJSON InventoryOptionalField 
Instance details

Defined in Amazonka.S3.Types.InventoryOptionalField

Methods

parseJSON :: Value -> Parser InventoryOptionalField #

parseJSONList :: Value -> Parser [InventoryOptionalField] #

FromJSON JSONType 
Instance details

Defined in Amazonka.S3.Types.JSONType

Methods

parseJSON :: Value -> Parser JSONType #

parseJSONList :: Value -> Parser [JSONType] #

FromJSON MFADelete 
Instance details

Defined in Amazonka.S3.Types.MFADelete

Methods

parseJSON :: Value -> Parser MFADelete #

parseJSONList :: Value -> Parser [MFADelete] #

FromJSON MFADeleteStatus 
Instance details

Defined in Amazonka.S3.Types.MFADeleteStatus

Methods

parseJSON :: Value -> Parser MFADeleteStatus #

parseJSONList :: Value -> Parser [MFADeleteStatus] #

FromJSON MetadataDirective 
Instance details

Defined in Amazonka.S3.Types.MetadataDirective

Methods

parseJSON :: Value -> Parser MetadataDirective #

parseJSONList :: Value -> Parser [MetadataDirective] #

FromJSON MetricsStatus 
Instance details

Defined in Amazonka.S3.Types.MetricsStatus

Methods

parseJSON :: Value -> Parser MetricsStatus #

parseJSONList :: Value -> Parser [MetricsStatus] #

FromJSON ObjectCannedACL 
Instance details

Defined in Amazonka.S3.Types.ObjectCannedACL

Methods

parseJSON :: Value -> Parser ObjectCannedACL #

parseJSONList :: Value -> Parser [ObjectCannedACL] #

FromJSON ObjectLockEnabled 
Instance details

Defined in Amazonka.S3.Types.ObjectLockEnabled

Methods

parseJSON :: Value -> Parser ObjectLockEnabled #

parseJSONList :: Value -> Parser [ObjectLockEnabled] #

FromJSON ObjectLockLegalHoldStatus 
Instance details

Defined in Amazonka.S3.Types.ObjectLockLegalHoldStatus

Methods

parseJSON :: Value -> Parser ObjectLockLegalHoldStatus #

parseJSONList :: Value -> Parser [ObjectLockLegalHoldStatus] #

FromJSON ObjectLockMode 
Instance details

Defined in Amazonka.S3.Types.ObjectLockMode

Methods

parseJSON :: Value -> Parser ObjectLockMode #

parseJSONList :: Value -> Parser [ObjectLockMode] #

FromJSON ObjectLockRetentionMode 
Instance details

Defined in Amazonka.S3.Types.ObjectLockRetentionMode

Methods

parseJSON :: Value -> Parser ObjectLockRetentionMode #

parseJSONList :: Value -> Parser [ObjectLockRetentionMode] #

FromJSON ObjectOwnership 
Instance details

Defined in Amazonka.S3.Types.ObjectOwnership

Methods

parseJSON :: Value -> Parser ObjectOwnership #

parseJSONList :: Value -> Parser [ObjectOwnership] #

FromJSON ObjectStorageClass 
Instance details

Defined in Amazonka.S3.Types.ObjectStorageClass

Methods

parseJSON :: Value -> Parser ObjectStorageClass #

parseJSONList :: Value -> Parser [ObjectStorageClass] #

FromJSON ObjectVersionStorageClass 
Instance details

Defined in Amazonka.S3.Types.ObjectVersionStorageClass

Methods

parseJSON :: Value -> Parser ObjectVersionStorageClass #

parseJSONList :: Value -> Parser [ObjectVersionStorageClass] #

FromJSON OwnerOverride 
Instance details

Defined in Amazonka.S3.Types.OwnerOverride

Methods

parseJSON :: Value -> Parser OwnerOverride #

parseJSONList :: Value -> Parser [OwnerOverride] #

FromJSON Payer 
Instance details

Defined in Amazonka.S3.Types.Payer

Methods

parseJSON :: Value -> Parser Payer #

parseJSONList :: Value -> Parser [Payer] #

FromJSON Permission 
Instance details

Defined in Amazonka.S3.Types.Permission

Methods

parseJSON :: Value -> Parser Permission #

parseJSONList :: Value -> Parser [Permission] #

FromJSON Protocol 
Instance details

Defined in Amazonka.S3.Types.Protocol

Methods

parseJSON :: Value -> Parser Protocol #

parseJSONList :: Value -> Parser [Protocol] #

FromJSON QuoteFields 
Instance details

Defined in Amazonka.S3.Types.QuoteFields

Methods

parseJSON :: Value -> Parser QuoteFields #

parseJSONList :: Value -> Parser [QuoteFields] #

FromJSON ReplicaModificationsStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicaModificationsStatus

Methods

parseJSON :: Value -> Parser ReplicaModificationsStatus #

parseJSONList :: Value -> Parser [ReplicaModificationsStatus] #

FromJSON ReplicationRuleStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicationRuleStatus

Methods

parseJSON :: Value -> Parser ReplicationRuleStatus #

parseJSONList :: Value -> Parser [ReplicationRuleStatus] #

FromJSON ReplicationStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicationStatus

Methods

parseJSON :: Value -> Parser ReplicationStatus #

parseJSONList :: Value -> Parser [ReplicationStatus] #

FromJSON ReplicationTimeStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicationTimeStatus

Methods

parseJSON :: Value -> Parser ReplicationTimeStatus #

parseJSONList :: Value -> Parser [ReplicationTimeStatus] #

FromJSON RequestCharged 
Instance details

Defined in Amazonka.S3.Types.RequestCharged

Methods

parseJSON :: Value -> Parser RequestCharged #

parseJSONList :: Value -> Parser [RequestCharged] #

FromJSON RequestPayer 
Instance details

Defined in Amazonka.S3.Types.RequestPayer

Methods

parseJSON :: Value -> Parser RequestPayer #

parseJSONList :: Value -> Parser [RequestPayer] #

FromJSON RestoreRequestType 
Instance details

Defined in Amazonka.S3.Types.RestoreRequestType

Methods

parseJSON :: Value -> Parser RestoreRequestType #

parseJSONList :: Value -> Parser [RestoreRequestType] #

FromJSON ServerSideEncryption 
Instance details

Defined in Amazonka.S3.Types.ServerSideEncryption

Methods

parseJSON :: Value -> Parser ServerSideEncryption #

parseJSONList :: Value -> Parser [ServerSideEncryption] #

FromJSON SseKmsEncryptedObjectsStatus 
Instance details

Defined in Amazonka.S3.Types.SseKmsEncryptedObjectsStatus

Methods

parseJSON :: Value -> Parser SseKmsEncryptedObjectsStatus #

parseJSONList :: Value -> Parser [SseKmsEncryptedObjectsStatus] #

FromJSON StorageClass 
Instance details

Defined in Amazonka.S3.Types.StorageClass

Methods

parseJSON :: Value -> Parser StorageClass #

parseJSONList :: Value -> Parser [StorageClass] #

FromJSON StorageClassAnalysisSchemaVersion 
Instance details

Defined in Amazonka.S3.Types.StorageClassAnalysisSchemaVersion

Methods

parseJSON :: Value -> Parser StorageClassAnalysisSchemaVersion #

parseJSONList :: Value -> Parser [StorageClassAnalysisSchemaVersion] #

FromJSON TaggingDirective 
Instance details

Defined in Amazonka.S3.Types.TaggingDirective

Methods

parseJSON :: Value -> Parser TaggingDirective #

parseJSONList :: Value -> Parser [TaggingDirective] #

FromJSON Tier 
Instance details

Defined in Amazonka.S3.Types.Tier

Methods

parseJSON :: Value -> Parser Tier #

parseJSONList :: Value -> Parser [Tier] #

FromJSON TransitionStorageClass 
Instance details

Defined in Amazonka.S3.Types.TransitionStorageClass

Methods

parseJSON :: Value -> Parser TransitionStorageClass #

parseJSONList :: Value -> Parser [TransitionStorageClass] #

FromJSON Type 
Instance details

Defined in Amazonka.S3.Types.Type

Methods

parseJSON :: Value -> Parser Type #

parseJSONList :: Value -> Parser [Type] #

FromJSON AccountInfo 
Instance details

Defined in Amazonka.SSO.Types.AccountInfo

Methods

parseJSON :: Value -> Parser AccountInfo #

parseJSONList :: Value -> Parser [AccountInfo] #

FromJSON RoleCredentials 
Instance details

Defined in Amazonka.SSO.Types.RoleCredentials

Methods

parseJSON :: Value -> Parser RoleCredentials #

parseJSONList :: Value -> Parser [RoleCredentials] #

FromJSON RoleInfo 
Instance details

Defined in Amazonka.SSO.Types.RoleInfo

Methods

parseJSON :: Value -> Parser RoleInfo #

parseJSONList :: Value -> Parser [RoleInfo] #

FromJSON Version 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Version #

parseJSONList :: Value -> Parser [Version] #

FromJSON Void 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Void #

parseJSONList :: Value -> Parser [Void] #

FromJSON CTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser CTime #

parseJSONList :: Value -> Parser [CTime] #

FromJSON Int16 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Int16 #

parseJSONList :: Value -> Parser [Int16] #

FromJSON Int32 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Int32 #

parseJSONList :: Value -> Parser [Int32] #

FromJSON Int64 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Int64 #

parseJSONList :: Value -> Parser [Int64] #

FromJSON Int8 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Int8 #

parseJSONList :: Value -> Parser [Int8] #

FromJSON Word16 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Word16 #

parseJSONList :: Value -> Parser [Word16] #

FromJSON Word32 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Word32 #

parseJSONList :: Value -> Parser [Word32] #

FromJSON Word64 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Word64 #

parseJSONList :: Value -> Parser [Word64] #

FromJSON Word8 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Word8 #

parseJSONList :: Value -> Parser [Word8] #

FromJSON IntSet 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser IntSet #

parseJSONList :: Value -> Parser [IntSet] #

FromJSON CharacterSet 
Instance details

Defined in Dhall.Pretty.Internal

Methods

parseJSON :: Value -> Parser CharacterSet #

parseJSONList :: Value -> Parser [CharacterSet] #

FromJSON Source 
Instance details

Defined in EventDataTheory.Core

Methods

parseJSON :: Value -> Parser Source #

parseJSONList :: Value -> Parser [Source] #

FromJSON Ordering 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Ordering #

parseJSONList :: Value -> Parser [Ordering] #

FromJSON LoggedMessage 
Instance details

Defined in Control.Monad.Logger.Aeson.Internal

Methods

parseJSON :: Value -> Parser LoggedMessage #

parseJSONList :: Value -> Parser [LoggedMessage] #

FromJSON Scientific 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Scientific #

parseJSONList :: Value -> Parser [Scientific] #

FromJSON Text 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Text #

parseJSONList :: Value -> Parser [Text] #

FromJSON Text 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Text #

parseJSONList :: Value -> Parser [Text] #

FromJSON ShortText 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser ShortText #

parseJSONList :: Value -> Parser [ShortText] #

FromJSON CalendarDiffDays 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser CalendarDiffDays #

parseJSONList :: Value -> Parser [CalendarDiffDays] #

FromJSON Day 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Day #

parseJSONList :: Value -> Parser [Day] #

FromJSON Month 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Month #

parseJSONList :: Value -> Parser [Month] #

FromJSON Quarter 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Quarter #

parseJSONList :: Value -> Parser [Quarter] #

FromJSON QuarterOfYear 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser QuarterOfYear #

parseJSONList :: Value -> Parser [QuarterOfYear] #

FromJSON DayOfWeek 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser DayOfWeek #

parseJSONList :: Value -> Parser [DayOfWeek] #

FromJSON DiffTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser DiffTime #

parseJSONList :: Value -> Parser [DiffTime] #

FromJSON NominalDiffTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser NominalDiffTime #

parseJSONList :: Value -> Parser [NominalDiffTime] #

FromJSON SystemTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser SystemTime #

parseJSONList :: Value -> Parser [SystemTime] #

FromJSON UTCTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser UTCTime #

parseJSONList :: Value -> Parser [UTCTime] #

FromJSON CalendarDiffTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser CalendarDiffTime #

parseJSONList :: Value -> Parser [CalendarDiffTime] #

FromJSON LocalTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser LocalTime #

parseJSONList :: Value -> Parser [LocalTime] #

FromJSON TimeOfDay 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser TimeOfDay #

parseJSONList :: Value -> Parser [TimeOfDay] #

FromJSON ZonedTime 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser ZonedTime #

parseJSONList :: Value -> Parser [ZonedTime] #

FromJSON UUID 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser UUID #

parseJSONList :: Value -> Parser [UUID] #

FromJSON Integer 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Integer #

parseJSONList :: Value -> Parser [Integer] #

FromJSON Natural 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Natural #

parseJSONList :: Value -> Parser [Natural] #

FromJSON () 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser () #

parseJSONList :: Value -> Parser [()] #

FromJSON Bool 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Bool #

parseJSONList :: Value -> Parser [Bool] #

FromJSON Char 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Char #

parseJSONList :: Value -> Parser [Char] #

FromJSON Double 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Double #

parseJSONList :: Value -> Parser [Double] #

FromJSON Float 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Float #

parseJSONList :: Value -> Parser [Float] #

FromJSON Int 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Int #

parseJSONList :: Value -> Parser [Int] #

FromJSON Word 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser Word #

parseJSONList :: Value -> Parser [Word] #

FromJSON v => FromJSON (KeyMap v) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (KeyMap v) #

parseJSONList :: Value -> Parser [KeyMap v] #

FromJSON a => FromJSON (Sensitive a) 
Instance details

Defined in Amazonka.Data.Sensitive

Methods

parseJSON :: Value -> Parser (Sensitive a) #

parseJSONList :: Value -> Parser [Sensitive a] #

FromJSON a => FromJSON (Identity a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Identity a) #

parseJSONList :: Value -> Parser [Identity a] #

FromJSON a => FromJSON (First a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (First a) #

parseJSONList :: Value -> Parser [First a] #

FromJSON a => FromJSON (Last a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Last a) #

parseJSONList :: Value -> Parser [Last a] #

FromJSON a => FromJSON (First a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (First a) #

parseJSONList :: Value -> Parser [First a] #

FromJSON a => FromJSON (Last a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Last a) #

parseJSONList :: Value -> Parser [Last a] #

FromJSON a => FromJSON (Max a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Max a) #

parseJSONList :: Value -> Parser [Max a] #

FromJSON a => FromJSON (Min a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Min a) #

parseJSONList :: Value -> Parser [Min a] #

FromJSON a => FromJSON (WrappedMonoid a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (WrappedMonoid a) #

parseJSONList :: Value -> Parser [WrappedMonoid a] #

FromJSON a => FromJSON (Dual a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Dual a) #

parseJSONList :: Value -> Parser [Dual a] #

(FromJSON a, Integral a) => FromJSON (Ratio a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Ratio a) #

parseJSONList :: Value -> Parser [Ratio a] #

FromJSON a => FromJSON (IntMap a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (IntMap a) #

parseJSONList :: Value -> Parser [IntMap a] #

FromJSON a => FromJSON (Seq a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Seq a) #

parseJSONList :: Value -> Parser [Seq a] #

(Ord a, FromJSON a) => FromJSON (Set a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Set a) #

parseJSONList :: Value -> Parser [Set a] #

FromJSON v => FromJSON (Tree v) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Tree v) #

parseJSONList :: Value -> Parser [Tree v] #

FromJSON1 f => FromJSON (Fix f) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Fix f) #

parseJSONList :: Value -> Parser [Fix f] #

(FromJSON1 f, Functor f) => FromJSON (Mu f) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Mu f) #

parseJSONList :: Value -> Parser [Mu f] #

(FromJSON1 f, Functor f) => FromJSON (Nu f) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Nu f) #

parseJSONList :: Value -> Parser [Nu f] #

FromJSON a => FromJSON (DNonEmpty a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (DNonEmpty a) #

parseJSONList :: Value -> Parser [DNonEmpty a] #

FromJSON a => FromJSON (DList a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (DList a) #

parseJSONList :: Value -> Parser [DList a] #

FromJSON t => FromJSON (Tag t) 
Instance details

Defined in EventDataTheory.Core

Methods

parseJSON :: Value -> Parser (Tag t) #

parseJSONList :: Value -> Parser [Tag t] #

(Ord t, FromJSON t) => FromJSON (TagSet t) 
Instance details

Defined in EventDataTheory.Core

Methods

parseJSON :: Value -> Parser (TagSet t) #

parseJSONList :: Value -> Parser [TagSet t] #

FromJSON a => FromJSON (TimeLine a) 
Instance details

Defined in EventDataTheory.EventLines

Methods

parseJSON :: Value -> Parser (TimeLine a) #

parseJSONList :: Value -> Parser [TimeLine a] #

FromJSON a => FromJSON (Array a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Array a) #

parseJSONList :: Value -> Parser [Array a] #

(Prim a, FromJSON a) => FromJSON (PrimArray a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (PrimArray a) #

parseJSONList :: Value -> Parser [PrimArray a] #

FromJSON a => FromJSON (SmallArray a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (SmallArray a) #

parseJSONList :: Value -> Parser [SmallArray a] #

FromJSON a => FromJSON (Maybe a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Maybe a) #

parseJSONList :: Value -> Parser [Maybe a] #

(Eq a, Hashable a, FromJSON a) => FromJSON (HashSet a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (HashSet a) #

parseJSONList :: Value -> Parser [HashSet a] #

FromJSON a => FromJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Vector a) #

parseJSONList :: Value -> Parser [Vector a] #

(Prim a, FromJSON a) => FromJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Vector a) #

parseJSONList :: Value -> Parser [Vector a] #

(Storable a, FromJSON a) => FromJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Vector a) #

parseJSONList :: Value -> Parser [Vector a] #

(Vector Vector a, FromJSON a) => FromJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Vector a) #

parseJSONList :: Value -> Parser [Vector a] #

FromJSON a => FromJSON (NonEmpty a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (NonEmpty a) #

parseJSONList :: Value -> Parser [NonEmpty a] #

FromJSON a => FromJSON (Maybe a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Maybe a) #

parseJSONList :: Value -> Parser [Maybe a] #

FromJSON a => FromJSON (a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a) #

parseJSONList :: Value -> Parser [(a)] #

FromJSON a => FromJSON [a] 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser [a] #

parseJSONList :: Value -> Parser [[a]] #

(FromJSON a, FromJSON b) => FromJSON (Either a b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Either a b) #

parseJSONList :: Value -> Parser [Either a b] #

HasResolution a => FromJSON (Fixed a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Fixed a) #

parseJSONList :: Value -> Parser [Fixed a] #

FromJSON (Proxy a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Proxy a) #

parseJSONList :: Value -> Parser [Proxy a] #

(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Map k v) #

parseJSONList :: Value -> Parser [Map k v] #

(Ord t, FromJSON t, FromJSON m) => FromJSON (Context t m) 
Instance details

Defined in EventDataTheory.Core

Methods

parseJSON :: Value -> Parser (Context t m) #

parseJSONList :: Value -> Parser [Context t m] #

(FromJSON a, FromJSON m) => FromJSON (FactsLine m a) 
Instance details

Defined in EventDataTheory.EventLines

Methods

parseJSON :: Value -> Parser (FactsLine m a) #

parseJSONList :: Value -> Parser [FactsLine m a] #

(FromJSON a, FromJSON b) => FromJSON (Either a b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Either a b) #

parseJSONList :: Value -> Parser [Either a b] #

(FromJSON a, FromJSON b) => FromJSON (These a b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (These a b) #

parseJSONList :: Value -> Parser [These a b] #

(FromJSON a, FromJSON b) => FromJSON (Pair a b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Pair a b) #

parseJSONList :: Value -> Parser [Pair a b] #

(FromJSON a, FromJSON b) => FromJSON (These a b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (These a b) #

parseJSONList :: Value -> Parser [These a b] #

(FromJSON v, FromJSONKey k, Eq k, Hashable k) => FromJSON (HashMap k v) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (HashMap k v) #

parseJSONList :: Value -> Parser [HashMap k v] #

(FromJSON a, FromJSON b) => FromJSON (a, b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b) #

parseJSONList :: Value -> Parser [(a, b)] #

FromJSON a => FromJSON (Const a b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Const a b) #

parseJSONList :: Value -> Parser [Const a b] #

(Ord t, FromJSON t, FromJSON m, FromJSON a) => FromJSON (Event t m a) 
Instance details

Defined in EventDataTheory.Core

Methods

parseJSON :: Value -> Parser (Event t m a) #

parseJSONList :: Value -> Parser [Event t m a] #

FromJSONEvent t m a => FromJSON (EventLine t m a) 
Instance details

Defined in EventDataTheory.EventLines

Methods

parseJSON :: Value -> Parser (EventLine t m a) #

parseJSONList :: Value -> Parser [EventLine t m a] #

FromJSON b => FromJSON (Tagged a b) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Tagged a b) #

parseJSONList :: Value -> Parser [Tagged a b] #

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (These1 f g a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (These1 f g a) #

parseJSONList :: Value -> Parser [These1 f g a] #

(FromJSON a, FromJSON b, FromJSON c) => FromJSON (a, b, c) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c) #

parseJSONList :: Value -> Parser [(a, b, c)] #

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Product f g a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Product f g a) #

parseJSONList :: Value -> Parser [Product f g a] #

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Sum f g a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Sum f g a) #

parseJSONList :: Value -> Parser [Sum f g a] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d) => FromJSON (a, b, c, d) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d) #

parseJSONList :: Value -> Parser [(a, b, c, d)] #

(FromJSON1 f, FromJSON1 g, FromJSON a) => FromJSON (Compose f g a) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Compose f g a) #

parseJSONList :: Value -> Parser [Compose f g a] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e) => FromJSON (a, b, c, d, e) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e) #

parseJSONList :: Value -> Parser [(a, b, c, d, e)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f) => FromJSON (a, b, c, d, e, f) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g) => FromJSON (a, b, c, d, e, f, g) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h) => FromJSON (a, b, c, d, e, f, g, h) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i) => FromJSON (a, b, c, d, e, f, g, h, i) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j) => FromJSON (a, b, c, d, e, f, g, h, i, j) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k) => FromJSON (a, b, c, d, e, f, g, h, i, j, k) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] #

(FromJSON a, FromJSON b, FromJSON c, FromJSON d, FromJSON e, FromJSON f, FromJSON g, FromJSON h, FromJSON i, FromJSON j, FromJSON k, FromJSON l, FromJSON m, FromJSON n, FromJSON o) => FromJSON (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) 
Instance details

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

parseJSONList :: Value -> Parser [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] #

class ToJSON a where #

Minimal complete definition

Nothing

Methods

toJSON :: a -> Value #

toEncoding :: a -> Encoding #

toJSONList :: [a] -> Value #

toEncodingList :: [a] -> Encoding #

Instances

Instances details
ToJSON Key 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Key -> Value #

toEncoding :: Key -> Encoding #

toJSONList :: [Key] -> Value #

toEncodingList :: [Key] -> Encoding #

ToJSON DotNetTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: DotNetTime -> Value #

toEncoding :: DotNetTime -> Encoding #

toJSONList :: [DotNetTime] -> Value #

toEncodingList :: [DotNetTime] -> Encoding #

ToJSON Value 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Value -> Value #

toEncoding :: Value -> Encoding #

toJSONList :: [Value] -> Value #

toEncodingList :: [Value] -> Encoding #

ToJSON IdentityDocument 
Instance details

Defined in Amazonka.EC2.Metadata

Methods

toJSON :: IdentityDocument -> Value #

toEncoding :: IdentityDocument -> Encoding #

toJSONList :: [IdentityDocument] -> Value #

toEncodingList :: [IdentityDocument] -> Encoding #

ToJSON Base64 
Instance details

Defined in Amazonka.Data.Base64

Methods

toJSON :: Base64 -> Value #

toEncoding :: Base64 -> Encoding #

toJSONList :: [Base64] -> Value #

toEncodingList :: [Base64] -> Encoding #

ToJSON AWSTime 
Instance details

Defined in Amazonka.Data.Time

Methods

toJSON :: AWSTime -> Value #

toEncoding :: AWSTime -> Encoding #

toJSONList :: [AWSTime] -> Value #

toEncodingList :: [AWSTime] -> Encoding #

ToJSON BasicTime 
Instance details

Defined in Amazonka.Data.Time

Methods

toJSON :: BasicTime -> Value #

toEncoding :: BasicTime -> Encoding #

toJSONList :: [BasicTime] -> Value #

toEncodingList :: [BasicTime] -> Encoding #

ToJSON ISO8601 
Instance details

Defined in Amazonka.Data.Time

Methods

toJSON :: ISO8601 -> Value #

toEncoding :: ISO8601 -> Encoding #

toJSONList :: [ISO8601] -> Value #

toEncodingList :: [ISO8601] -> Encoding #

ToJSON POSIX 
Instance details

Defined in Amazonka.Data.Time

Methods

toJSON :: POSIX -> Value #

toEncoding :: POSIX -> Encoding #

toJSONList :: [POSIX] -> Value #

toEncodingList :: [POSIX] -> Encoding #

ToJSON RFC822 
Instance details

Defined in Amazonka.Data.Time

Methods

toJSON :: RFC822 -> Value #

toEncoding :: RFC822 -> Encoding #

toJSONList :: [RFC822] -> Value #

toEncodingList :: [RFC822] -> Encoding #

ToJSON AccessKey 
Instance details

Defined in Amazonka.Types

Methods

toJSON :: AccessKey -> Value #

toEncoding :: AccessKey -> Encoding #

toJSONList :: [AccessKey] -> Value #

toEncodingList :: [AccessKey] -> Encoding #

ToJSON Region 
Instance details

Defined in Amazonka.Types

Methods

toJSON :: Region -> Value #

toEncoding :: Region -> Encoding #

toJSONList :: [Region] -> Value #

toEncodingList :: [Region] -> Encoding #

ToJSON SecretKey 
Instance details

Defined in Amazonka.Types

Methods

toJSON :: SecretKey -> Value #

toEncoding :: SecretKey -> Encoding #

toJSONList :: [SecretKey] -> Value #

toEncodingList :: [SecretKey] -> Encoding #

ToJSON SessionToken 
Instance details

Defined in Amazonka.Types

Methods

toJSON :: SessionToken -> Value #

toEncoding :: SessionToken -> Encoding #

toJSONList :: [SessionToken] -> Value #

toEncodingList :: [SessionToken] -> Encoding #

ToJSON AnalyticsS3ExportFileFormat 
Instance details

Defined in Amazonka.S3.Types.AnalyticsS3ExportFileFormat

Methods

toJSON :: AnalyticsS3ExportFileFormat -> Value #

toEncoding :: AnalyticsS3ExportFileFormat -> Encoding #

toJSONList :: [AnalyticsS3ExportFileFormat] -> Value #

toEncodingList :: [AnalyticsS3ExportFileFormat] -> Encoding #

ToJSON ArchiveStatus 
Instance details

Defined in Amazonka.S3.Types.ArchiveStatus

Methods

toJSON :: ArchiveStatus -> Value #

toEncoding :: ArchiveStatus -> Encoding #

toJSONList :: [ArchiveStatus] -> Value #

toEncodingList :: [ArchiveStatus] -> Encoding #

ToJSON BucketAccelerateStatus 
Instance details

Defined in Amazonka.S3.Types.BucketAccelerateStatus

Methods

toJSON :: BucketAccelerateStatus -> Value #

toEncoding :: BucketAccelerateStatus -> Encoding #

toJSONList :: [BucketAccelerateStatus] -> Value #

toEncodingList :: [BucketAccelerateStatus] -> Encoding #

ToJSON BucketCannedACL 
Instance details

Defined in Amazonka.S3.Types.BucketCannedACL

Methods

toJSON :: BucketCannedACL -> Value #

toEncoding :: BucketCannedACL -> Encoding #

toJSONList :: [BucketCannedACL] -> Value #

toEncodingList :: [BucketCannedACL] -> Encoding #

ToJSON BucketLogsPermission 
Instance details

Defined in Amazonka.S3.Types.BucketLogsPermission

Methods

toJSON :: BucketLogsPermission -> Value #

toEncoding :: BucketLogsPermission -> Encoding #

toJSONList :: [BucketLogsPermission] -> Value #

toEncodingList :: [BucketLogsPermission] -> Encoding #

ToJSON BucketVersioningStatus 
Instance details

Defined in Amazonka.S3.Types.BucketVersioningStatus

Methods

toJSON :: BucketVersioningStatus -> Value #

toEncoding :: BucketVersioningStatus -> Encoding #

toJSONList :: [BucketVersioningStatus] -> Value #

toEncodingList :: [BucketVersioningStatus] -> Encoding #

ToJSON CompressionType 
Instance details

Defined in Amazonka.S3.Types.CompressionType

Methods

toJSON :: CompressionType -> Value #

toEncoding :: CompressionType -> Encoding #

toJSONList :: [CompressionType] -> Value #

toEncodingList :: [CompressionType] -> Encoding #

ToJSON DeleteMarkerReplicationStatus 
Instance details

Defined in Amazonka.S3.Types.DeleteMarkerReplicationStatus

Methods

toJSON :: DeleteMarkerReplicationStatus -> Value #

toEncoding :: DeleteMarkerReplicationStatus -> Encoding #

toJSONList :: [DeleteMarkerReplicationStatus] -> Value #

toEncodingList :: [DeleteMarkerReplicationStatus] -> Encoding #

ToJSON EncodingType 
Instance details

Defined in Amazonka.S3.Types.EncodingType

Methods

toJSON :: EncodingType -> Value #

toEncoding :: EncodingType -> Encoding #

toJSONList :: [EncodingType] -> Value #

toEncodingList :: [EncodingType] -> Encoding #

ToJSON Event 
Instance details

Defined in Amazonka.S3.Types.Event

Methods

toJSON :: Event -> Value #

toEncoding :: Event -> Encoding #

toJSONList :: [Event] -> Value #

toEncodingList :: [Event] -> Encoding #

ToJSON ExistingObjectReplicationStatus 
Instance details

Defined in Amazonka.S3.Types.ExistingObjectReplicationStatus

Methods

toJSON :: ExistingObjectReplicationStatus -> Value #

toEncoding :: ExistingObjectReplicationStatus -> Encoding #

toJSONList :: [ExistingObjectReplicationStatus] -> Value #

toEncodingList :: [ExistingObjectReplicationStatus] -> Encoding #

ToJSON ExpirationStatus 
Instance details

Defined in Amazonka.S3.Types.ExpirationStatus

Methods

toJSON :: ExpirationStatus -> Value #

toEncoding :: ExpirationStatus -> Encoding #

toJSONList :: [ExpirationStatus] -> Value #

toEncodingList :: [ExpirationStatus] -> Encoding #

ToJSON ExpressionType 
Instance details

Defined in Amazonka.S3.Types.ExpressionType

Methods

toJSON :: ExpressionType -> Value #

toEncoding :: ExpressionType -> Encoding #

toJSONList :: [ExpressionType] -> Value #

toEncodingList :: [ExpressionType] -> Encoding #

ToJSON FileHeaderInfo 
Instance details

Defined in Amazonka.S3.Types.FileHeaderInfo

Methods

toJSON :: FileHeaderInfo -> Value #

toEncoding :: FileHeaderInfo -> Encoding #

toJSONList :: [FileHeaderInfo] -> Value #

toEncodingList :: [FileHeaderInfo] -> Encoding #

ToJSON FilterRuleName 
Instance details

Defined in Amazonka.S3.Types.FilterRuleName

Methods

toJSON :: FilterRuleName -> Value #

toEncoding :: FilterRuleName -> Encoding #

toJSONList :: [FilterRuleName] -> Value #

toEncodingList :: [FilterRuleName] -> Encoding #

ToJSON IntelligentTieringAccessTier 
Instance details

Defined in Amazonka.S3.Types.IntelligentTieringAccessTier

Methods

toJSON :: IntelligentTieringAccessTier -> Value #

toEncoding :: IntelligentTieringAccessTier -> Encoding #

toJSONList :: [IntelligentTieringAccessTier] -> Value #

toEncodingList :: [IntelligentTieringAccessTier] -> Encoding #

ToJSON IntelligentTieringStatus 
Instance details

Defined in Amazonka.S3.Types.IntelligentTieringStatus

Methods

toJSON :: IntelligentTieringStatus -> Value #

toEncoding :: IntelligentTieringStatus -> Encoding #

toJSONList :: [IntelligentTieringStatus] -> Value #

toEncodingList :: [IntelligentTieringStatus] -> Encoding #

ToJSON InventoryFormat 
Instance details

Defined in Amazonka.S3.Types.InventoryFormat

Methods

toJSON :: InventoryFormat -> Value #

toEncoding :: InventoryFormat -> Encoding #

toJSONList :: [InventoryFormat] -> Value #

toEncodingList :: [InventoryFormat] -> Encoding #

ToJSON InventoryFrequency 
Instance details

Defined in Amazonka.S3.Types.InventoryFrequency

Methods

toJSON :: InventoryFrequency -> Value #

toEncoding :: InventoryFrequency -> Encoding #

toJSONList :: [InventoryFrequency] -> Value #

toEncodingList :: [InventoryFrequency] -> Encoding #

ToJSON InventoryIncludedObjectVersions 
Instance details

Defined in Amazonka.S3.Types.InventoryIncludedObjectVersions

Methods

toJSON :: InventoryIncludedObjectVersions -> Value #

toEncoding :: InventoryIncludedObjectVersions -> Encoding #

toJSONList :: [InventoryIncludedObjectVersions] -> Value #

toEncodingList :: [InventoryIncludedObjectVersions] -> Encoding #

ToJSON InventoryOptionalField 
Instance details

Defined in Amazonka.S3.Types.InventoryOptionalField

Methods

toJSON :: InventoryOptionalField -> Value #

toEncoding :: InventoryOptionalField -> Encoding #

toJSONList :: [InventoryOptionalField] -> Value #

toEncodingList :: [InventoryOptionalField] -> Encoding #

ToJSON JSONType 
Instance details

Defined in Amazonka.S3.Types.JSONType

Methods

toJSON :: JSONType -> Value #

toEncoding :: JSONType -> Encoding #

toJSONList :: [JSONType] -> Value #

toEncodingList :: [JSONType] -> Encoding #

ToJSON MFADelete 
Instance details

Defined in Amazonka.S3.Types.MFADelete

Methods

toJSON :: MFADelete -> Value #

toEncoding :: MFADelete -> Encoding #

toJSONList :: [MFADelete] -> Value #

toEncodingList :: [MFADelete] -> Encoding #

ToJSON MFADeleteStatus 
Instance details

Defined in Amazonka.S3.Types.MFADeleteStatus

Methods

toJSON :: MFADeleteStatus -> Value #

toEncoding :: MFADeleteStatus -> Encoding #

toJSONList :: [MFADeleteStatus] -> Value #

toEncodingList :: [MFADeleteStatus] -> Encoding #

ToJSON MetadataDirective 
Instance details

Defined in Amazonka.S3.Types.MetadataDirective

Methods

toJSON :: MetadataDirective -> Value #

toEncoding :: MetadataDirective -> Encoding #

toJSONList :: [MetadataDirective] -> Value #

toEncodingList :: [MetadataDirective] -> Encoding #

ToJSON MetricsStatus 
Instance details

Defined in Amazonka.S3.Types.MetricsStatus

Methods

toJSON :: MetricsStatus -> Value #

toEncoding :: MetricsStatus -> Encoding #

toJSONList :: [MetricsStatus] -> Value #

toEncodingList :: [MetricsStatus] -> Encoding #

ToJSON ObjectCannedACL 
Instance details

Defined in Amazonka.S3.Types.ObjectCannedACL

Methods

toJSON :: ObjectCannedACL -> Value #

toEncoding :: ObjectCannedACL -> Encoding #

toJSONList :: [ObjectCannedACL] -> Value #

toEncodingList :: [ObjectCannedACL] -> Encoding #

ToJSON ObjectLockEnabled 
Instance details

Defined in Amazonka.S3.Types.ObjectLockEnabled

Methods

toJSON :: ObjectLockEnabled -> Value #

toEncoding :: ObjectLockEnabled -> Encoding #

toJSONList :: [ObjectLockEnabled] -> Value #

toEncodingList :: [ObjectLockEnabled] -> Encoding #

ToJSON ObjectLockLegalHoldStatus 
Instance details

Defined in Amazonka.S3.Types.ObjectLockLegalHoldStatus

Methods

toJSON :: ObjectLockLegalHoldStatus -> Value #

toEncoding :: ObjectLockLegalHoldStatus -> Encoding #

toJSONList :: [ObjectLockLegalHoldStatus] -> Value #

toEncodingList :: [ObjectLockLegalHoldStatus] -> Encoding #

ToJSON ObjectLockMode 
Instance details

Defined in Amazonka.S3.Types.ObjectLockMode

Methods

toJSON :: ObjectLockMode -> Value #

toEncoding :: ObjectLockMode -> Encoding #

toJSONList :: [ObjectLockMode] -> Value #

toEncodingList :: [ObjectLockMode] -> Encoding #

ToJSON ObjectLockRetentionMode 
Instance details

Defined in Amazonka.S3.Types.ObjectLockRetentionMode

Methods

toJSON :: ObjectLockRetentionMode -> Value #

toEncoding :: ObjectLockRetentionMode -> Encoding #

toJSONList :: [ObjectLockRetentionMode] -> Value #

toEncodingList :: [ObjectLockRetentionMode] -> Encoding #

ToJSON ObjectOwnership 
Instance details

Defined in Amazonka.S3.Types.ObjectOwnership

Methods

toJSON :: ObjectOwnership -> Value #

toEncoding :: ObjectOwnership -> Encoding #

toJSONList :: [ObjectOwnership] -> Value #

toEncodingList :: [ObjectOwnership] -> Encoding #

ToJSON ObjectStorageClass 
Instance details

Defined in Amazonka.S3.Types.ObjectStorageClass

Methods

toJSON :: ObjectStorageClass -> Value #

toEncoding :: ObjectStorageClass -> Encoding #

toJSONList :: [ObjectStorageClass] -> Value #

toEncodingList :: [ObjectStorageClass] -> Encoding #

ToJSON ObjectVersionStorageClass 
Instance details

Defined in Amazonka.S3.Types.ObjectVersionStorageClass

Methods

toJSON :: ObjectVersionStorageClass -> Value #

toEncoding :: ObjectVersionStorageClass -> Encoding #

toJSONList :: [ObjectVersionStorageClass] -> Value #

toEncodingList :: [ObjectVersionStorageClass] -> Encoding #

ToJSON OwnerOverride 
Instance details

Defined in Amazonka.S3.Types.OwnerOverride

Methods

toJSON :: OwnerOverride -> Value #

toEncoding :: OwnerOverride -> Encoding #

toJSONList :: [OwnerOverride] -> Value #

toEncodingList :: [OwnerOverride] -> Encoding #

ToJSON Payer 
Instance details

Defined in Amazonka.S3.Types.Payer

Methods

toJSON :: Payer -> Value #

toEncoding :: Payer -> Encoding #

toJSONList :: [Payer] -> Value #

toEncodingList :: [Payer] -> Encoding #

ToJSON Permission 
Instance details

Defined in Amazonka.S3.Types.Permission

Methods

toJSON :: Permission -> Value #

toEncoding :: Permission -> Encoding #

toJSONList :: [Permission] -> Value #

toEncodingList :: [Permission] -> Encoding #

ToJSON Protocol 
Instance details

Defined in Amazonka.S3.Types.Protocol

Methods

toJSON :: Protocol -> Value #

toEncoding :: Protocol -> Encoding #

toJSONList :: [Protocol] -> Value #

toEncodingList :: [Protocol] -> Encoding #

ToJSON QuoteFields 
Instance details

Defined in Amazonka.S3.Types.QuoteFields

Methods

toJSON :: QuoteFields -> Value #

toEncoding :: QuoteFields -> Encoding #

toJSONList :: [QuoteFields] -> Value #

toEncodingList :: [QuoteFields] -> Encoding #

ToJSON ReplicaModificationsStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicaModificationsStatus

Methods

toJSON :: ReplicaModificationsStatus -> Value #

toEncoding :: ReplicaModificationsStatus -> Encoding #

toJSONList :: [ReplicaModificationsStatus] -> Value #

toEncodingList :: [ReplicaModificationsStatus] -> Encoding #

ToJSON ReplicationRuleStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicationRuleStatus

Methods

toJSON :: ReplicationRuleStatus -> Value #

toEncoding :: ReplicationRuleStatus -> Encoding #

toJSONList :: [ReplicationRuleStatus] -> Value #

toEncodingList :: [ReplicationRuleStatus] -> Encoding #

ToJSON ReplicationStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicationStatus

Methods

toJSON :: ReplicationStatus -> Value #

toEncoding :: ReplicationStatus -> Encoding #

toJSONList :: [ReplicationStatus] -> Value #

toEncodingList :: [ReplicationStatus] -> Encoding #

ToJSON ReplicationTimeStatus 
Instance details

Defined in Amazonka.S3.Types.ReplicationTimeStatus

Methods

toJSON :: ReplicationTimeStatus -> Value #

toEncoding :: ReplicationTimeStatus -> Encoding #

toJSONList :: [ReplicationTimeStatus] -> Value #

toEncodingList :: [ReplicationTimeStatus] -> Encoding #

ToJSON RequestCharged 
Instance details

Defined in Amazonka.S3.Types.RequestCharged

Methods

toJSON :: RequestCharged -> Value #

toEncoding :: RequestCharged -> Encoding #

toJSONList :: [RequestCharged] -> Value #

toEncodingList :: [RequestCharged] -> Encoding #

ToJSON RequestPayer 
Instance details

Defined in Amazonka.S3.Types.RequestPayer

Methods

toJSON :: RequestPayer -> Value #

toEncoding :: RequestPayer -> Encoding #

toJSONList :: [RequestPayer] -> Value #

toEncodingList :: [RequestPayer] -> Encoding #

ToJSON RestoreRequestType 
Instance details

Defined in Amazonka.S3.Types.RestoreRequestType

Methods

toJSON :: RestoreRequestType -> Value #

toEncoding :: RestoreRequestType -> Encoding #

toJSONList :: [RestoreRequestType] -> Value #

toEncodingList :: [RestoreRequestType] -> Encoding #

ToJSON ServerSideEncryption 
Instance details

Defined in Amazonka.S3.Types.ServerSideEncryption

Methods

toJSON :: ServerSideEncryption -> Value #

toEncoding :: ServerSideEncryption -> Encoding #

toJSONList :: [ServerSideEncryption] -> Value #

toEncodingList :: [ServerSideEncryption] -> Encoding #

ToJSON SseKmsEncryptedObjectsStatus 
Instance details

Defined in Amazonka.S3.Types.SseKmsEncryptedObjectsStatus

Methods

toJSON :: SseKmsEncryptedObjectsStatus -> Value #

toEncoding :: SseKmsEncryptedObjectsStatus -> Encoding #

toJSONList :: [SseKmsEncryptedObjectsStatus] -> Value #

toEncodingList :: [SseKmsEncryptedObjectsStatus] -> Encoding #

ToJSON StorageClass 
Instance details

Defined in Amazonka.S3.Types.StorageClass

Methods

toJSON :: StorageClass -> Value #

toEncoding :: StorageClass -> Encoding #

toJSONList :: [StorageClass] -> Value #

toEncodingList :: [StorageClass] -> Encoding #

ToJSON StorageClassAnalysisSchemaVersion 
Instance details

Defined in Amazonka.S3.Types.StorageClassAnalysisSchemaVersion

Methods

toJSON :: StorageClassAnalysisSchemaVersion -> Value #

toEncoding :: StorageClassAnalysisSchemaVersion -> Encoding #

toJSONList :: [StorageClassAnalysisSchemaVersion] -> Value #

toEncodingList :: [StorageClassAnalysisSchemaVersion] -> Encoding #

ToJSON TaggingDirective 
Instance details

Defined in Amazonka.S3.Types.TaggingDirective

Methods

toJSON :: TaggingDirective -> Value #

toEncoding :: TaggingDirective -> Encoding #

toJSONList :: [TaggingDirective] -> Value #

toEncodingList :: [TaggingDirective] -> Encoding #

ToJSON Tier 
Instance details

Defined in Amazonka.S3.Types.Tier

Methods

toJSON :: Tier -> Value #

toEncoding :: Tier -> Encoding #

toJSONList :: [Tier] -> Value #

toEncodingList :: [Tier] -> Encoding #

ToJSON TransitionStorageClass 
Instance details

Defined in Amazonka.S3.Types.TransitionStorageClass

Methods

toJSON :: TransitionStorageClass -> Value #

toEncoding :: TransitionStorageClass -> Encoding #

toJSONList :: [TransitionStorageClass] -> Value #

toEncodingList :: [TransitionStorageClass] -> Encoding #

ToJSON Type 
Instance details

Defined in Amazonka.S3.Types.Type

Methods

toJSON :: Type -> Value #

toEncoding :: Type -> Encoding #

toJSONList :: [Type] -> Value #

toEncodingList :: [Type] -> Encoding #

ToJSON Number 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Number -> Value #

toEncoding :: Number -> Encoding #

toJSONList :: [Number] -> Value #

toEncodingList :: [Number] -> Encoding #

ToJSON Version 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Version -> Value #

toEncoding :: Version -> Encoding #

toJSONList :: [Version] -> Value #

toEncodingList :: [Version] -> Encoding #

ToJSON Void 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Void -> Value #

toEncoding :: Void -> Encoding #

toJSONList :: [Void] -> Value #

toEncodingList :: [Void] -> Encoding #

ToJSON CTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: CTime -> Value #

toEncoding :: CTime -> Encoding #

toJSONList :: [CTime] -> Value #

toEncodingList :: [CTime] -> Encoding #

ToJSON Int16 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Int16 -> Value #

toEncoding :: Int16 -> Encoding #

toJSONList :: [Int16] -> Value #

toEncodingList :: [Int16] -> Encoding #

ToJSON Int32 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Int32 -> Value #

toEncoding :: Int32 -> Encoding #

toJSONList :: [Int32] -> Value #

toEncodingList :: [Int32] -> Encoding #

ToJSON Int64 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Int64 -> Value #

toEncoding :: Int64 -> Encoding #

toJSONList :: [Int64] -> Value #

toEncodingList :: [Int64] -> Encoding #

ToJSON Int8 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Int8 -> Value #

toEncoding :: Int8 -> Encoding #

toJSONList :: [Int8] -> Value #

toEncodingList :: [Int8] -> Encoding #

ToJSON Word16 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Word16 -> Value #

toEncoding :: Word16 -> Encoding #

toJSONList :: [Word16] -> Value #

toEncodingList :: [Word16] -> Encoding #

ToJSON Word32 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Word32 -> Value #

toEncoding :: Word32 -> Encoding #

toJSONList :: [Word32] -> Value #

toEncodingList :: [Word32] -> Encoding #

ToJSON Word64 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Word64 -> Value #

toEncoding :: Word64 -> Encoding #

toJSONList :: [Word64] -> Value #

toEncodingList :: [Word64] -> Encoding #

ToJSON Word8 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Word8 -> Value #

toEncoding :: Word8 -> Encoding #

toJSONList :: [Word8] -> Value #

toEncodingList :: [Word8] -> Encoding #

ToJSON IntSet 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: IntSet -> Value #

toEncoding :: IntSet -> Encoding #

toJSONList :: [IntSet] -> Value #

toEncodingList :: [IntSet] -> Encoding #

ToJSON Source 
Instance details

Defined in EventDataTheory.Core

Methods

toJSON :: Source -> Value #

toEncoding :: Source -> Encoding #

toJSONList :: [Source] -> Value #

toEncodingList :: [Source] -> Encoding #

ToJSON Ordering 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Ordering -> Value #

toEncoding :: Ordering -> Encoding #

toJSONList :: [Ordering] -> Value #

toEncodingList :: [Ordering] -> Encoding #

ToJSON AttritionInfo 
Instance details

Defined in Cohort.Cohort

Methods

toJSON :: AttritionInfo -> Value #

toEncoding :: AttritionInfo -> Encoding #

toJSONList :: [AttritionInfo] -> Value #

toEncodingList :: [AttritionInfo] -> Encoding #

ToJSON AttritionStatus 
Instance details

Defined in Cohort.Cohort

Methods

toJSON :: AttritionStatus -> Value #

toEncoding :: AttritionStatus -> Encoding #

toJSONList :: [AttritionStatus] -> Value #

toEncodingList :: [AttritionStatus] -> Encoding #

ToJSON SubjId 
Instance details

Defined in Cohort.Cohort

Methods

toJSON :: SubjId -> Value #

toEncoding :: SubjId -> Encoding #

toJSONList :: [SubjId] -> Value #

toEncodingList :: [SubjId] -> Encoding #

ToJSON CohortJSON 
Instance details

Defined in Cohort.Output

Methods

toJSON :: CohortJSON -> Value #

toEncoding :: CohortJSON -> Encoding #

toJSONList :: [CohortJSON] -> Value #

toEncodingList :: [CohortJSON] -> Encoding #

ToJSON ObsUnitJSON 
Instance details

Defined in Cohort.Output

Methods

toJSON :: ObsUnitJSON -> Value #

toEncoding :: ObsUnitJSON -> Encoding #

toJSONList :: [ObsUnitJSON] -> Value #

toEncodingList :: [ObsUnitJSON] -> Encoding #

ToJSON Featureable 
Instance details

Defined in Features.Featureable

Methods

toJSON :: Featureable -> Value #

toEncoding :: Featureable -> Encoding #

toJSONList :: [Featureable] -> Value #

toEncodingList :: [Featureable] -> Encoding #

ToJSON Featureset 
Instance details

Defined in Features.Featureset

Methods

toJSON :: Featureset -> Value #

toEncoding :: Featureset -> Encoding #

toJSONList :: [Featureset] -> Value #

toEncodingList :: [Featureset] -> Encoding #

ToJSON NameTypeAttr 
Instance details

Defined in Features.Output

Methods

toJSON :: NameTypeAttr -> Value #

toEncoding :: NameTypeAttr -> Encoding #

toJSONList :: [NameTypeAttr] -> Value #

toEncodingList :: [NameTypeAttr] -> Encoding #

ToJSON VarAttrs 
Instance details

Defined in Variable.Attributes

Methods

toJSON :: VarAttrs -> Value #

toEncoding :: VarAttrs -> Encoding #

toJSONList :: [VarAttrs] -> Value #

toEncodingList :: [VarAttrs] -> Encoding #

ToJSON Factor 
Instance details

Defined in Variable.R.Factor

Methods

toJSON :: Factor -> Value #

toEncoding :: Factor -> Encoding #

toJSONList :: [Factor] -> Value #

toEncodingList :: [Factor] -> Encoding #

ToJSON SomeRTypeRep 
Instance details

Defined in Variable.R.SEXP

Methods

toJSON :: SomeRTypeRep -> Value #

toEncoding :: SomeRTypeRep -> Encoding #

toJSONList :: [SomeRTypeRep] -> Value #

toEncodingList :: [SomeRTypeRep] -> Encoding #

ToJSON StypeAttrs 
Instance details

Defined in Variable.R.Stype

Methods

toJSON :: StypeAttrs -> Value #

toEncoding :: StypeAttrs -> Encoding #

toJSONList :: [StypeAttrs] -> Value #

toEncodingList :: [StypeAttrs] -> Encoding #

ToJSON StypeRole 
Instance details

Defined in Variable.R.Stype

Methods

toJSON :: StypeRole -> Value #

toEncoding :: StypeRole -> Encoding #

toJSONList :: [StypeRole] -> Value #

toEncodingList :: [StypeRole] -> Encoding #

ToJSON WrappedStypeAttrs 
Instance details

Defined in Variable.R.Stype

Methods

toJSON :: WrappedStypeAttrs -> Value #

toEncoding :: WrappedStypeAttrs -> Encoding #

toJSONList :: [WrappedStypeAttrs] -> Value #

toEncodingList :: [WrappedStypeAttrs] -> Encoding #

ToJSON Variable 
Instance details

Defined in Variable.Variable

Methods

toJSON :: Variable -> Value #

toEncoding :: Variable -> Encoding #

toJSONList :: [Variable] -> Value #

toEncodingList :: [Variable] -> Encoding #

ToJSON VariableWrapped 
Instance details

Defined in Variable.Variable

Methods

toJSON :: VariableWrapped -> Value #

toEncoding :: VariableWrapped -> Encoding #

toJSONList :: [VariableWrapped] -> Value #

toEncodingList :: [VariableWrapped] -> Encoding #

ToJSON LoggedMessage 
Instance details

Defined in Control.Monad.Logger.Aeson.Internal

Methods

toJSON :: LoggedMessage -> Value #

toEncoding :: LoggedMessage -> Encoding #

toJSONList :: [LoggedMessage] -> Value #

toEncodingList :: [LoggedMessage] -> Encoding #

ToJSON Scientific 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Scientific -> Value #

toEncoding :: Scientific -> Encoding #

toJSONList :: [Scientific] -> Value #

toEncodingList :: [Scientific] -> Encoding #

ToJSON Text 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Text -> Value #

toEncoding :: Text -> Encoding #

toJSONList :: [Text] -> Value #

toEncodingList :: [Text] -> Encoding #

ToJSON Text 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Text -> Value #

toEncoding :: Text -> Encoding #

toJSONList :: [Text] -> Value #

toEncodingList :: [Text] -> Encoding #

ToJSON ShortText 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: ShortText -> Value #

toEncoding :: ShortText -> Encoding #

toJSONList :: [ShortText] -> Value #

toEncodingList :: [ShortText] -> Encoding #

ToJSON CalendarDiffDays 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: CalendarDiffDays -> Value #

toEncoding :: CalendarDiffDays -> Encoding #

toJSONList :: [CalendarDiffDays] -> Value #

toEncodingList :: [CalendarDiffDays] -> Encoding #

ToJSON Day 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Day -> Value #

toEncoding :: Day -> Encoding #

toJSONList :: [Day] -> Value #

toEncodingList :: [Day] -> Encoding #

ToJSON Month 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Month -> Value #

toEncoding :: Month -> Encoding #

toJSONList :: [Month] -> Value #

toEncodingList :: [Month] -> Encoding #

ToJSON Quarter 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Quarter -> Value #

toEncoding :: Quarter -> Encoding #

toJSONList :: [Quarter] -> Value #

toEncodingList :: [Quarter] -> Encoding #

ToJSON QuarterOfYear 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: QuarterOfYear -> Value #

toEncoding :: QuarterOfYear -> Encoding #

toJSONList :: [QuarterOfYear] -> Value #

toEncodingList :: [QuarterOfYear] -> Encoding #

ToJSON DayOfWeek 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: DayOfWeek -> Value #

toEncoding :: DayOfWeek -> Encoding #

toJSONList :: [DayOfWeek] -> Value #

toEncodingList :: [DayOfWeek] -> Encoding #

ToJSON DiffTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: DiffTime -> Value #

toEncoding :: DiffTime -> Encoding #

toJSONList :: [DiffTime] -> Value #

toEncodingList :: [DiffTime] -> Encoding #

ToJSON NominalDiffTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: NominalDiffTime -> Value #

toEncoding :: NominalDiffTime -> Encoding #

toJSONList :: [NominalDiffTime] -> Value #

toEncodingList :: [NominalDiffTime] -> Encoding #

ToJSON SystemTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: SystemTime -> Value #

toEncoding :: SystemTime -> Encoding #

toJSONList :: [SystemTime] -> Value #

toEncodingList :: [SystemTime] -> Encoding #

ToJSON UTCTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: UTCTime -> Value #

toEncoding :: UTCTime -> Encoding #

toJSONList :: [UTCTime] -> Value #

toEncodingList :: [UTCTime] -> Encoding #

ToJSON CalendarDiffTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: CalendarDiffTime -> Value #

toEncoding :: CalendarDiffTime -> Encoding #

toJSONList :: [CalendarDiffTime] -> Value #

toEncodingList :: [CalendarDiffTime] -> Encoding #

ToJSON LocalTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: LocalTime -> Value #

toEncoding :: LocalTime -> Encoding #

toJSONList :: [LocalTime] -> Value #

toEncodingList :: [LocalTime] -> Encoding #

ToJSON TimeOfDay 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: TimeOfDay -> Value #

toEncoding :: TimeOfDay -> Encoding #

toJSONList :: [TimeOfDay] -> Value #

toEncodingList :: [TimeOfDay] -> Encoding #

ToJSON ZonedTime 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: ZonedTime -> Value #

toEncoding :: ZonedTime -> Encoding #

toJSONList :: [ZonedTime] -> Value #

toEncodingList :: [ZonedTime] -> Encoding #

ToJSON UUID 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: UUID -> Value #

toEncoding :: UUID -> Encoding #

toJSONList :: [UUID] -> Value #

toEncodingList :: [UUID] -> Encoding #

ToJSON Integer 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Integer -> Value #

toEncoding :: Integer -> Encoding #

toJSONList :: [Integer] -> Value #

toEncodingList :: [Integer] -> Encoding #

ToJSON Natural 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Natural -> Value #

toEncoding :: Natural -> Encoding #

toJSONList :: [Natural] -> Value #

toEncodingList :: [Natural] -> Encoding #

ToJSON () 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: () -> Value #

toEncoding :: () -> Encoding #

toJSONList :: [()] -> Value #

toEncodingList :: [()] -> Encoding #

ToJSON Bool 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Bool -> Value #

toEncoding :: Bool -> Encoding #

toJSONList :: [Bool] -> Value #

toEncodingList :: [Bool] -> Encoding #

ToJSON Char 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Char -> Value #

toEncoding :: Char -> Encoding #

toJSONList :: [Char] -> Value #

toEncodingList :: [Char] -> Encoding #

ToJSON Double 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Double -> Value #

toEncoding :: Double -> Encoding #

toJSONList :: [Double] -> Value #

toEncodingList :: [Double] -> Encoding #

ToJSON Float 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Float -> Value #

toEncoding :: Float -> Encoding #

toJSONList :: [Float] -> Value #

toEncodingList :: [Float] -> Encoding #

ToJSON Int 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Int -> Value #

toEncoding :: Int -> Encoding #

toJSONList :: [Int] -> Value #

toEncodingList :: [Int] -> Encoding #

ToJSON Word 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Word -> Value #

toEncoding :: Word -> Encoding #

toJSONList :: [Word] -> Value #

toEncodingList :: [Word] -> Encoding #

ToJSON v => ToJSON (KeyMap v) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: KeyMap v -> Value #

toEncoding :: KeyMap v -> Encoding #

toJSONList :: [KeyMap v] -> Value #

toEncodingList :: [KeyMap v] -> Encoding #

ToJSON a => ToJSON (Sensitive a) 
Instance details

Defined in Amazonka.Data.Sensitive

Methods

toJSON :: Sensitive a -> Value #

toEncoding :: Sensitive a -> Encoding #

toJSONList :: [Sensitive a] -> Value #

toEncodingList :: [Sensitive a] -> Encoding #

ToJSON a => ToJSON (Identity a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Identity a -> Value #

toEncoding :: Identity a -> Encoding #

toJSONList :: [Identity a] -> Value #

toEncodingList :: [Identity a] -> Encoding #

ToJSON a => ToJSON (First a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: First a -> Value #

toEncoding :: First a -> Encoding #

toJSONList :: [First a] -> Value #

toEncodingList :: [First a] -> Encoding #

ToJSON a => ToJSON (Last a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Last a -> Value #

toEncoding :: Last a -> Encoding #

toJSONList :: [Last a] -> Value #

toEncodingList :: [Last a] -> Encoding #

ToJSON a => ToJSON (First a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: First a -> Value #

toEncoding :: First a -> Encoding #

toJSONList :: [First a] -> Value #

toEncodingList :: [First a] -> Encoding #

ToJSON a => ToJSON (Last a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Last a -> Value #

toEncoding :: Last a -> Encoding #

toJSONList :: [Last a] -> Value #

toEncodingList :: [Last a] -> Encoding #

ToJSON a => ToJSON (Max a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Max a -> Value #

toEncoding :: Max a -> Encoding #

toJSONList :: [Max a] -> Value #

toEncodingList :: [Max a] -> Encoding #

ToJSON a => ToJSON (Min a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Min a -> Value #

toEncoding :: Min a -> Encoding #

toJSONList :: [Min a] -> Value #

toEncodingList :: [Min a] -> Encoding #

ToJSON a => ToJSON (WrappedMonoid a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: WrappedMonoid a -> Value #

toEncoding :: WrappedMonoid a -> Encoding #

toJSONList :: [WrappedMonoid a] -> Value #

toEncodingList :: [WrappedMonoid a] -> Encoding #

ToJSON a => ToJSON (Dual a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Dual a -> Value #

toEncoding :: Dual a -> Encoding #

toJSONList :: [Dual a] -> Value #

toEncodingList :: [Dual a] -> Encoding #

(ToJSON a, Integral a) => ToJSON (Ratio a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Ratio a -> Value #

toEncoding :: Ratio a -> Encoding #

toJSONList :: [Ratio a] -> Value #

toEncodingList :: [Ratio a] -> Encoding #

ToJSON a => ToJSON (IntMap a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: IntMap a -> Value #

toEncoding :: IntMap a -> Encoding #

toJSONList :: [IntMap a] -> Value #

toEncodingList :: [IntMap a] -> Encoding #

ToJSON a => ToJSON (Seq a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Seq a -> Value #

toEncoding :: Seq a -> Encoding #

toJSONList :: [Seq a] -> Value #

toEncodingList :: [Seq a] -> Encoding #

ToJSON a => ToJSON (Set a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Set a -> Value #

toEncoding :: Set a -> Encoding #

toJSONList :: [Set a] -> Value #

toEncodingList :: [Set a] -> Encoding #

ToJSON v => ToJSON (Tree v) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Tree v -> Value #

toEncoding :: Tree v -> Encoding #

toJSONList :: [Tree v] -> Value #

toEncodingList :: [Tree v] -> Encoding #

ToJSON1 f => ToJSON (Fix f) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Fix f -> Value #

toEncoding :: Fix f -> Encoding #

toJSONList :: [Fix f] -> Value #

toEncodingList :: [Fix f] -> Encoding #

(ToJSON1 f, Functor f) => ToJSON (Mu f) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Mu f -> Value #

toEncoding :: Mu f -> Encoding #

toJSONList :: [Mu f] -> Value #

toEncodingList :: [Mu f] -> Encoding #

(ToJSON1 f, Functor f) => ToJSON (Nu f) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Nu f -> Value #

toEncoding :: Nu f -> Encoding #

toJSONList :: [Nu f] -> Value #

toEncodingList :: [Nu f] -> Encoding #

ToJSON a => ToJSON (DNonEmpty a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: DNonEmpty a -> Value #

toEncoding :: DNonEmpty a -> Encoding #

toJSONList :: [DNonEmpty a] -> Value #

toEncodingList :: [DNonEmpty a] -> Encoding #

ToJSON a => ToJSON (DList a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: DList a -> Value #

toEncoding :: DList a -> Encoding #

toJSONList :: [DList a] -> Value #

toEncodingList :: [DList a] -> Encoding #

ToJSON t => ToJSON (Tag t) 
Instance details

Defined in EventDataTheory.Core

Methods

toJSON :: Tag t -> Value #

toEncoding :: Tag t -> Encoding #

toJSONList :: [Tag t] -> Value #

toEncodingList :: [Tag t] -> Encoding #

ToJSON t => ToJSON (TagSet t) 
Instance details

Defined in EventDataTheory.Core

Methods

toJSON :: TagSet t -> Value #

toEncoding :: TagSet t -> Encoding #

toJSONList :: [TagSet t] -> Value #

toEncodingList :: [TagSet t] -> Encoding #

ToJSON a => ToJSON (TimeLine a) 
Instance details

Defined in EventDataTheory.EventLines

Methods

toJSON :: TimeLine a -> Value #

toEncoding :: TimeLine a -> Encoding #

toJSONList :: [TimeLine a] -> Value #

toEncodingList :: [TimeLine a] -> Encoding #

ToJSON a => ToJSON (ObsId a) 
Instance details

Defined in Cohort.Cohort

Methods

toJSON :: ObsId a -> Value #

toEncoding :: ObsId a -> Encoding #

toJSONList :: [ObsId a] -> Value #

toEncodingList :: [ObsId a] -> Encoding #

ToJSON (OutputShape a) 
Instance details

Defined in Features.Output

Methods

toJSON :: OutputShape a -> Value #

toEncoding :: OutputShape a -> Encoding #

toJSONList :: [OutputShape a] -> Value #

toEncodingList :: [OutputShape a] -> Encoding #

ToJSON a => ToJSON (Array a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Array a -> Value #

toEncoding :: Array a -> Encoding #

toJSONList :: [Array a] -> Value #

toEncodingList :: [Array a] -> Encoding #

(Prim a, ToJSON a) => ToJSON (PrimArray a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: PrimArray a -> Value #

toEncoding :: PrimArray a -> Encoding #

toJSONList :: [PrimArray a] -> Value #

toEncodingList :: [PrimArray a] -> Encoding #

ToJSON a => ToJSON (SmallArray a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: SmallArray a -> Value #

toEncoding :: SmallArray a -> Encoding #

toJSONList :: [SmallArray a] -> Value #

toEncodingList :: [SmallArray a] -> Encoding #

ToJSON a => ToJSON (Maybe a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Maybe a -> Value #

toEncoding :: Maybe a -> Encoding #

toJSONList :: [Maybe a] -> Value #

toEncodingList :: [Maybe a] -> Encoding #

ToJSON a => ToJSON (HashSet a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: HashSet a -> Value #

toEncoding :: HashSet a -> Encoding #

toJSONList :: [HashSet a] -> Value #

toEncodingList :: [HashSet a] -> Encoding #

ToJSON a => ToJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Vector a -> Value #

toEncoding :: Vector a -> Encoding #

toJSONList :: [Vector a] -> Value #

toEncodingList :: [Vector a] -> Encoding #

(Prim a, ToJSON a) => ToJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Vector a -> Value #

toEncoding :: Vector a -> Encoding #

toJSONList :: [Vector a] -> Value #

toEncodingList :: [Vector a] -> Encoding #

(Storable a, ToJSON a) => ToJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Vector a -> Value #

toEncoding :: Vector a -> Encoding #

toJSONList :: [Vector a] -> Value #

toEncodingList :: [Vector a] -> Encoding #

(Vector Vector a, ToJSON a) => ToJSON (Vector a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Vector a -> Value #

toEncoding :: Vector a -> Encoding #

toJSONList :: [Vector a] -> Value #

toEncodingList :: [Vector a] -> Encoding #

ToJSON a => ToJSON (NonEmpty a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: NonEmpty a -> Value #

toEncoding :: NonEmpty a -> Encoding #

toJSONList :: [NonEmpty a] -> Value #

toEncodingList :: [NonEmpty a] -> Encoding #

ToJSON a => ToJSON (Maybe a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Maybe a -> Value #

toEncoding :: Maybe a -> Encoding #

toJSONList :: [Maybe a] -> Value #

toEncodingList :: [Maybe a] -> Encoding #

ToJSON a => ToJSON (a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a) -> Value #

toEncoding :: (a) -> Encoding #

toJSONList :: [(a)] -> Value #

toEncodingList :: [(a)] -> Encoding #

ToJSON a => ToJSON [a] 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: [a] -> Value #

toEncoding :: [a] -> Encoding #

toJSONList :: [[a]] -> Value #

toEncodingList :: [[a]] -> Encoding #

(ToJSON a, ToJSON b) => ToJSON (Either a b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Either a b -> Value #

toEncoding :: Either a b -> Encoding #

toJSONList :: [Either a b] -> Value #

toEncodingList :: [Either a b] -> Encoding #

HasResolution a => ToJSON (Fixed a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Fixed a -> Value #

toEncoding :: Fixed a -> Encoding #

toJSONList :: [Fixed a] -> Value #

toEncodingList :: [Fixed a] -> Encoding #

ToJSON (Proxy a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Proxy a -> Value #

toEncoding :: Proxy a -> Encoding #

toJSONList :: [Proxy a] -> Value #

toEncodingList :: [Proxy a] -> Encoding #

(ToJSON v, ToJSONKey k) => ToJSON (Map k v) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Map k v -> Value #

toEncoding :: Map k v -> Encoding #

toJSONList :: [Map k v] -> Value #

toEncodingList :: [Map k v] -> Encoding #

(Ord t, ToJSON t, ToJSON m) => ToJSON (Context t m) 
Instance details

Defined in EventDataTheory.Core

Methods

toJSON :: Context t m -> Value #

toEncoding :: Context t m -> Encoding #

toJSONList :: [Context t m] -> Value #

toEncodingList :: [Context t m] -> Encoding #

(ToJSON a, ToJSON m) => ToJSON (FactsLine m a) 
Instance details

Defined in EventDataTheory.EventLines

Methods

toJSON :: FactsLine m a -> Value #

toEncoding :: FactsLine m a -> Encoding #

toJSONList :: [FactsLine m a] -> Value #

toEncodingList :: [FactsLine m a] -> Encoding #

(ToJSON a, ToJSON b) => ToJSON (Either a b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Either a b -> Value #

toEncoding :: Either a b -> Encoding #

toJSONList :: [Either a b] -> Value #

toEncodingList :: [Either a b] -> Encoding #

(ToJSON a, ToJSON b) => ToJSON (These a b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: These a b -> Value #

toEncoding :: These a b -> Encoding #

toJSONList :: [These a b] -> Value #

toEncodingList :: [These a b] -> Encoding #

(ToJSON a, ToJSON b) => ToJSON (Pair a b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Pair a b -> Value #

toEncoding :: Pair a b -> Encoding #

toJSONList :: [Pair a b] -> Value #

toEncodingList :: [Pair a b] -> Encoding #

(ToJSON a, ToJSON b) => ToJSON (These a b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: These a b -> Value #

toEncoding :: These a b -> Encoding #

toJSONList :: [These a b] -> Value #

toEncodingList :: [These a b] -> Encoding #

(ToJSON v, ToJSONKey k) => ToJSON (HashMap k v) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: HashMap k v -> Value #

toEncoding :: HashMap k v -> Encoding #

toJSONList :: [HashMap k v] -> Value #

toEncodingList :: [HashMap k v] -> Encoding #

(ToJSON a, ToJSON b) => ToJSON (a, b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b) -> Value #

toEncoding :: (a, b) -> Encoding #

toJSONList :: [(a, b)] -> Value #

toEncodingList :: [(a, b)] -> Encoding #

ToJSON a => ToJSON (Const a b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Const a b -> Value #

toEncoding :: Const a b -> Encoding #

toJSONList :: [Const a b] -> Value #

toEncodingList :: [Const a b] -> Encoding #

(Ord t, ToJSON t, ToJSON m, ToJSON a) => ToJSON (Event t m a) 
Instance details

Defined in EventDataTheory.Core

Methods

toJSON :: Event t m a -> Value #

toEncoding :: Event t m a -> Encoding #

toJSONList :: [Event t m a] -> Value #

toEncodingList :: [Event t m a] -> Encoding #

(ToJSON a, ToJSON t, ToJSON m) => ToJSON (EventLine t m a) 
Instance details

Defined in EventDataTheory.EventLines

Methods

toJSON :: EventLine t m a -> Value #

toEncoding :: EventLine t m a -> Encoding #

toJSONList :: [EventLine t m a] -> Value #

toEncodingList :: [EventLine t m a] -> Encoding #

ToJSON b => ToJSON (Tagged a b) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Tagged a b -> Value #

toEncoding :: Tagged a b -> Encoding #

toJSONList :: [Tagged a b] -> Value #

toEncodingList :: [Tagged a b] -> Encoding #

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (These1 f g a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: These1 f g a -> Value #

toEncoding :: These1 f g a -> Encoding #

toJSONList :: [These1 f g a] -> Value #

toEncodingList :: [These1 f g a] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c) => ToJSON (a, b, c) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c) -> Value #

toEncoding :: (a, b, c) -> Encoding #

toJSONList :: [(a, b, c)] -> Value #

toEncodingList :: [(a, b, c)] -> Encoding #

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Product f g a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Product f g a -> Value #

toEncoding :: Product f g a -> Encoding #

toJSONList :: [Product f g a] -> Value #

toEncodingList :: [Product f g a] -> Encoding #

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Sum f g a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Sum f g a -> Value #

toEncoding :: Sum f g a -> Encoding #

toJSONList :: [Sum f g a] -> Value #

toEncodingList :: [Sum f g a] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d) => ToJSON (a, b, c, d) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d) -> Value #

toEncoding :: (a, b, c, d) -> Encoding #

toJSONList :: [(a, b, c, d)] -> Value #

toEncodingList :: [(a, b, c, d)] -> Encoding #

(ToJSON1 f, ToJSON1 g, ToJSON a) => ToJSON (Compose f g a) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Compose f g a -> Value #

toEncoding :: Compose f g a -> Encoding #

toJSONList :: [Compose f g a] -> Value #

toEncodingList :: [Compose f g a] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e) => ToJSON (a, b, c, d, e) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d, e) -> Value #

toEncoding :: (a, b, c, d, e) -> Encoding #

toJSONList :: [(a, b, c, d, e)] -> Value #

toEncodingList :: [(a, b, c, d, e)] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f) => ToJSON (a, b, c, d, e, f) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d, e, f) -> Value #

toEncoding :: (a, b, c, d, e, f) -> Encoding #

toJSONList :: [(a, b, c, d, e, f)] -> Value #

toEncodingList :: [(a, b, c, d, e, f)] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g) => ToJSON (a, b, c, d, e, f, g) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d, e, f, g) -> Value #

toEncoding :: (a, b, c, d, e, f, g) -> Encoding #

toJSONList :: [(a, b, c, d, e, f, g)] -> Value #

toEncodingList :: [(a, b, c, d, e, f, g)] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h) => ToJSON (a, b, c, d, e, f, g, h) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d, e, f, g, h) -> Value #

toEncoding :: (a, b, c, d, e, f, g, h) -> Encoding #

toJSONList :: [(a, b, c, d, e, f, g, h)] -> Value #

toEncodingList :: [(a, b, c, d, e, f, g, h)] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i) => ToJSON (a, b, c, d, e, f, g, h, i) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d, e, f, g, h, i) -> Value #

toEncoding :: (a, b, c, d, e, f, g, h, i) -> Encoding #

toJSONList :: [(a, b, c, d, e, f, g, h, i)] -> Value #

toEncodingList :: [(a, b, c, d, e, f, g, h, i)] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j) => ToJSON (a, b, c, d, e, f, g, h, i, j) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j) -> Value #

toEncoding :: (a, b, c, d, e, f, g, h, i, j) -> Encoding #

toJSONList :: [(a, b, c, d, e, f, g, h, i, j)] -> Value #

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j)] -> Encoding #

(ToJSON a, ToJSON b, ToJSON c, ToJSON d, ToJSON e, ToJSON f, ToJSON g, ToJSON h, ToJSON i, ToJSON j, ToJSON k) => ToJSON (a, b, c, d, e, f, g, h, i, j, k) 
Instance details

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: (a, b, c, d, e, f, g, h, i, j, k) -> Value #

toEncoding :: (a, b, c, d, e, f, g, h, i, j, k) -> Encoding #

toJSONList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Value #

toEncodingList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Encoding #<