{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.SageMaker.Types.ProblemType
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.SageMaker.Types.ProblemType
  ( ProblemType
      ( ..,
        ProblemType_BinaryClassification,
        ProblemType_MulticlassClassification,
        ProblemType_Regression
      ),
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Prelude as Prelude

newtype ProblemType = ProblemType'
  { ProblemType -> Text
fromProblemType ::
      Core.Text
  }
  deriving stock
    ( Int -> ProblemType -> ShowS
[ProblemType] -> ShowS
ProblemType -> String
(Int -> ProblemType -> ShowS)
-> (ProblemType -> String)
-> ([ProblemType] -> ShowS)
-> Show ProblemType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProblemType] -> ShowS
$cshowList :: [ProblemType] -> ShowS
show :: ProblemType -> String
$cshow :: ProblemType -> String
showsPrec :: Int -> ProblemType -> ShowS
$cshowsPrec :: Int -> ProblemType -> ShowS
Prelude.Show,
      ReadPrec [ProblemType]
ReadPrec ProblemType
Int -> ReadS ProblemType
ReadS [ProblemType]
(Int -> ReadS ProblemType)
-> ReadS [ProblemType]
-> ReadPrec ProblemType
-> ReadPrec [ProblemType]
-> Read ProblemType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ProblemType]
$creadListPrec :: ReadPrec [ProblemType]
readPrec :: ReadPrec ProblemType
$creadPrec :: ReadPrec ProblemType
readList :: ReadS [ProblemType]
$creadList :: ReadS [ProblemType]
readsPrec :: Int -> ReadS ProblemType
$creadsPrec :: Int -> ReadS ProblemType
Prelude.Read,
      ProblemType -> ProblemType -> Bool
(ProblemType -> ProblemType -> Bool)
-> (ProblemType -> ProblemType -> Bool) -> Eq ProblemType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProblemType -> ProblemType -> Bool
$c/= :: ProblemType -> ProblemType -> Bool
== :: ProblemType -> ProblemType -> Bool
$c== :: ProblemType -> ProblemType -> Bool
Prelude.Eq,
      Eq ProblemType
Eq ProblemType
-> (ProblemType -> ProblemType -> Ordering)
-> (ProblemType -> ProblemType -> Bool)
-> (ProblemType -> ProblemType -> Bool)
-> (ProblemType -> ProblemType -> Bool)
-> (ProblemType -> ProblemType -> Bool)
-> (ProblemType -> ProblemType -> ProblemType)
-> (ProblemType -> ProblemType -> ProblemType)
-> Ord ProblemType
ProblemType -> ProblemType -> Bool
ProblemType -> ProblemType -> Ordering
ProblemType -> ProblemType -> ProblemType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ProblemType -> ProblemType -> ProblemType
$cmin :: ProblemType -> ProblemType -> ProblemType
max :: ProblemType -> ProblemType -> ProblemType
$cmax :: ProblemType -> ProblemType -> ProblemType
>= :: ProblemType -> ProblemType -> Bool
$c>= :: ProblemType -> ProblemType -> Bool
> :: ProblemType -> ProblemType -> Bool
$c> :: ProblemType -> ProblemType -> Bool
<= :: ProblemType -> ProblemType -> Bool
$c<= :: ProblemType -> ProblemType -> Bool
< :: ProblemType -> ProblemType -> Bool
$c< :: ProblemType -> ProblemType -> Bool
compare :: ProblemType -> ProblemType -> Ordering
$ccompare :: ProblemType -> ProblemType -> Ordering
$cp1Ord :: Eq ProblemType
Prelude.Ord,
      (forall x. ProblemType -> Rep ProblemType x)
-> (forall x. Rep ProblemType x -> ProblemType)
-> Generic ProblemType
forall x. Rep ProblemType x -> ProblemType
forall x. ProblemType -> Rep ProblemType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ProblemType x -> ProblemType
$cfrom :: forall x. ProblemType -> Rep ProblemType x
Prelude.Generic
    )
  deriving newtype
    ( Int -> ProblemType -> Int
ProblemType -> Int
(Int -> ProblemType -> Int)
-> (ProblemType -> Int) -> Hashable ProblemType
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: ProblemType -> Int
$chash :: ProblemType -> Int
hashWithSalt :: Int -> ProblemType -> Int
$chashWithSalt :: Int -> ProblemType -> Int
Prelude.Hashable,
      ProblemType -> ()
(ProblemType -> ()) -> NFData ProblemType
forall a. (a -> ()) -> NFData a
rnf :: ProblemType -> ()
$crnf :: ProblemType -> ()
Prelude.NFData,
      Text -> Either String ProblemType
(Text -> Either String ProblemType) -> FromText ProblemType
forall a. (Text -> Either String a) -> FromText a
fromText :: Text -> Either String ProblemType
$cfromText :: Text -> Either String ProblemType
Core.FromText,
      ProblemType -> Text
(ProblemType -> Text) -> ToText ProblemType
forall a. (a -> Text) -> ToText a
toText :: ProblemType -> Text
$ctoText :: ProblemType -> Text
Core.ToText,
      ProblemType -> ByteString
(ProblemType -> ByteString) -> ToByteString ProblemType
forall a. (a -> ByteString) -> ToByteString a
toBS :: ProblemType -> ByteString
$ctoBS :: ProblemType -> ByteString
Core.ToByteString,
      ProblemType -> ByteStringBuilder
(ProblemType -> ByteStringBuilder) -> ToLog ProblemType
forall a. (a -> ByteStringBuilder) -> ToLog a
build :: ProblemType -> ByteStringBuilder
$cbuild :: ProblemType -> ByteStringBuilder
Core.ToLog,
      HeaderName -> ProblemType -> [Header]
(HeaderName -> ProblemType -> [Header]) -> ToHeader ProblemType
forall a. (HeaderName -> a -> [Header]) -> ToHeader a
toHeader :: HeaderName -> ProblemType -> [Header]
$ctoHeader :: HeaderName -> ProblemType -> [Header]
Core.ToHeader,
      ProblemType -> QueryString
(ProblemType -> QueryString) -> ToQuery ProblemType
forall a. (a -> QueryString) -> ToQuery a
toQuery :: ProblemType -> QueryString
$ctoQuery :: ProblemType -> QueryString
Core.ToQuery,
      Value -> Parser [ProblemType]
Value -> Parser ProblemType
(Value -> Parser ProblemType)
-> (Value -> Parser [ProblemType]) -> FromJSON ProblemType
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [ProblemType]
$cparseJSONList :: Value -> Parser [ProblemType]
parseJSON :: Value -> Parser ProblemType
$cparseJSON :: Value -> Parser ProblemType
Core.FromJSON,
      FromJSONKeyFunction [ProblemType]
FromJSONKeyFunction ProblemType
FromJSONKeyFunction ProblemType
-> FromJSONKeyFunction [ProblemType] -> FromJSONKey ProblemType
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
fromJSONKeyList :: FromJSONKeyFunction [ProblemType]
$cfromJSONKeyList :: FromJSONKeyFunction [ProblemType]
fromJSONKey :: FromJSONKeyFunction ProblemType
$cfromJSONKey :: FromJSONKeyFunction ProblemType
Core.FromJSONKey,
      [ProblemType] -> Encoding
[ProblemType] -> Value
ProblemType -> Encoding
ProblemType -> Value
(ProblemType -> Value)
-> (ProblemType -> Encoding)
-> ([ProblemType] -> Value)
-> ([ProblemType] -> Encoding)
-> ToJSON ProblemType
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [ProblemType] -> Encoding
$ctoEncodingList :: [ProblemType] -> Encoding
toJSONList :: [ProblemType] -> Value
$ctoJSONList :: [ProblemType] -> Value
toEncoding :: ProblemType -> Encoding
$ctoEncoding :: ProblemType -> Encoding
toJSON :: ProblemType -> Value
$ctoJSON :: ProblemType -> Value
Core.ToJSON,
      ToJSONKeyFunction [ProblemType]
ToJSONKeyFunction ProblemType
ToJSONKeyFunction ProblemType
-> ToJSONKeyFunction [ProblemType] -> ToJSONKey ProblemType
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
toJSONKeyList :: ToJSONKeyFunction [ProblemType]
$ctoJSONKeyList :: ToJSONKeyFunction [ProblemType]
toJSONKey :: ToJSONKeyFunction ProblemType
$ctoJSONKey :: ToJSONKeyFunction ProblemType
Core.ToJSONKey,
      [Node] -> Either String ProblemType
([Node] -> Either String ProblemType) -> FromXML ProblemType
forall a. ([Node] -> Either String a) -> FromXML a
parseXML :: [Node] -> Either String ProblemType
$cparseXML :: [Node] -> Either String ProblemType
Core.FromXML,
      ProblemType -> XML
(ProblemType -> XML) -> ToXML ProblemType
forall a. (a -> XML) -> ToXML a
toXML :: ProblemType -> XML
$ctoXML :: ProblemType -> XML
Core.ToXML
    )

pattern ProblemType_BinaryClassification :: ProblemType
pattern $bProblemType_BinaryClassification :: ProblemType
$mProblemType_BinaryClassification :: forall r. ProblemType -> (Void# -> r) -> (Void# -> r) -> r
ProblemType_BinaryClassification = ProblemType' "BinaryClassification"

pattern ProblemType_MulticlassClassification :: ProblemType
pattern $bProblemType_MulticlassClassification :: ProblemType
$mProblemType_MulticlassClassification :: forall r. ProblemType -> (Void# -> r) -> (Void# -> r) -> r
ProblemType_MulticlassClassification = ProblemType' "MulticlassClassification"

pattern ProblemType_Regression :: ProblemType
pattern $bProblemType_Regression :: ProblemType
$mProblemType_Regression :: forall r. ProblemType -> (Void# -> r) -> (Void# -> r) -> r
ProblemType_Regression = ProblemType' "Regression"

{-# COMPLETE
  ProblemType_BinaryClassification,
  ProblemType_MulticlassClassification,
  ProblemType_Regression,
  ProblemType'
  #-}