The FeatureData type is a container for an (almost) arbitrary type d that can have a "failed" or "missing" state. The failure is represented by the Left of an Either, while the data d is contained in the Either's Right.

To construct a successful value, use featureDataR. A missing value can be constructed with featureDataL or its synonym missingBecause.

Defines the reasons that a FeatureData value may be missing. Can be used to indicate the reason that a Feature's data was unable to be derived or does not need to be derived.

The Feature is an abstraction for named data, where the name is a *type*. Essentially, it is a container for FeatureData that assigns a name to the data.

Except when using pure to lift data into a Feature, Features can only be derived from other Feature via a Definition.

Type synonym for Feature.

Creates a missing FeatureData.

>>> featureDataL (CustomFlag "no good reason") :: FeatureData P.Int
MkFeatureData (Left (CustomFlag "no good reason"))

>>> featureDataL (CustomFlag "no good reason") :: FeatureData Text
MkFeatureData (Left (CustomFlag "no good reason"))

Creates a non-missing FeatureData. Since FeatureData is an instance of Applicative, pure is also a synonym of for featureDataR.

>>> featureDataR "aString"
MkFeatureData (Right "aString")
>>> featureDataR (1 :: P.Int)
MkFeatureData (Right 1)

>>> featureDataR ("aString", (1 :: P.Int))
MkFeatureData (Right ("aString",1))

A synonym for featureDataL.

A utility for constructing a Feature from FeatureData. Since name is a type, you may need to annotate the type when using this function.

>>> makeFeature (pure "test") :: Feature "dummy" Text
"dummy": MkFeatureData {getFeatureData = Right "test"}

Unwrap FeatureData.

Gets the FeatureData from a Feature.

A utility for getting the (inner) FeatureData content of a Feature.

A Definition can be thought of as a lifted function. Specifically, the define function takes an arbitrary function (currently up to three arguments) and returns a Defintion where the arguments have been lifted to a new domain.

For example, here we take f and lift to to a function of Features.

f :: Int -> String -> Bool
f i s
  | 1 "yes" = True
  | otherwise = FALSE

myFeature :: Definition (Feature A Int -> Feature B String -> Feature C Bool )
myFeature = define f

See eval for evaluating Defintions.

Define (and 'DefineA) provide a means to create new Definitions via define (defineA). The define function takes a single function input and returns a lifted function. For example,

f :: Int -> String -> Bool
f i s
  | 1 "yes" = True
  | otherwise = FALSE

myFeature :: Definition (Feature A Int -> Feature B String -> Feature C Bool )
myFeature = define f

The defineA function is similar, except that the return type of the input function is already lifted. In the example below, an input of Nothing is considered a missing state:

f :: Int -> Maybe String -> Feature C Bool
f i s
  | 1 (Just "yes")   = pure True
  | _ (Just _ )      = pure False -- False for any Int and any (Just String)
  | otherwise        = pure $ missingBecause InsufficientData -- missing if no string

myFeature :: Definition (Feature A Int -> Feature B String -> Feature C Bool )
myFeature = defineA f

See Define.

Type synonym for Definition.

Evaluate a Definition. Note that (currently), the second argument of eval is a *tuple* of inputs. For example,

f :: Int -> String -> Bool
f i s
  | 1 "yes" = True
  | otherwise = FALSE

myFeature :: Definition (Feature A Int -> Feature B String -> Feature C Bool )
myFeature = define f

a :: Feature A Int
a = pure 1

b :: Feature B String
b = pure "yes"

c = eval myFeature a b

A typeclass providing a single method for attaching Attributes to a name and data. The type of data is determined by the name, by way of using a functional dependency.

The default method is emptyAttributes.

The setAttributes function creates a template Haskell splice, which generates a HasAttributes instance declaration. For example, instead of writing

  instance HasAttributes "foo" Bool where
    getAttributes = basicAttributes "lab" "long label" [Covariate] []

one can instead write

  setAttributes
    (basicAttributes "lab" "long label" [Covariate] [])
    "foo" ''Bool

The latter approach is useful for writing helper functions to generate Attributes.

   covariateAttrs label tag  =
       setAttributes (labeller label tag)
       where labeller = basicAttributes label label [Covariate] [tag]

   covariateAttrs "foo var" "a" "foo" ''Bool
   covariateAttrs "bar bar" "b" "bar" ''Int

A data type for holding attritbutes of features.

Attributes are not generally used with asclepias itself, and instead used to pass contextual information to downstream applications.

For example, the Attributes type directly maps to a [stype context](https:/docs.novisci.comstypereferencecontext.html).

See emptyAttributes and basicAttributes for convenience constructor functions.

A type to identify a feature's (i.e. variable's) role in a research study. In a Purpose, multiple roles can be specified.

A type to identify a feature's purpose. The Role type enumerates many common purposes, and the getTags field can be used for additional information.

An empty attributes value.

Create attributes with just short label, long label, roles, and tags.

An empty purpose value.

Creates a template haskell splice for HasAttributes instance. See HasAttributes for an example.

Usage requires the template haskell language extension.

A convenience function for declaring a HasAttributes instance as emptyAttributes.

A convenience function for declaring many HasAttributes instances given a list of inputs to setAttributes.

Existential type to hold features, which allows for Features to be put into a homogeneous list.

Pack a feature into a Featurable.

Get the Attributes from a Featureable.

A Featureset is a (non-empty) list of Featureable.

A newtype wrapper for a NonEmpty Featureset.

Constructor of a Featureset.

Constructor of a Featureset.

Gets a list of Attributes from a Featureset, one Attributes per Featureable.

Constructor of a Featureset.

Transpose a FeaturesetList

Compare two Featuresets via their ShapeOutput and ToJSON implementations. They cannot be compared directly because an existential type cannot be Eq. Comparing by JSON at the moment makes the most sense because that is the output format and thus how downstream applications will understand "equality". Still, this should be revisited.

A class that provides methods for transforming some type to an OutputShape.

A type used to determine the output shape of a Feature.