{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

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

-- |
-- Module      : Amazonka.DataBrew.CreateRuleset
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a new ruleset that can be used in a profile job to validate the
-- data quality of a dataset.
module Amazonka.DataBrew.CreateRuleset
  ( -- * Creating a Request
    CreateRuleset (..),
    newCreateRuleset,

    -- * Request Lenses
    createRuleset_description,
    createRuleset_tags,
    createRuleset_name,
    createRuleset_targetArn,
    createRuleset_rules,

    -- * Destructuring the Response
    CreateRulesetResponse (..),
    newCreateRulesetResponse,

    -- * Response Lenses
    createRulesetResponse_httpStatus,
    createRulesetResponse_name,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.DataBrew.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateRuleset' smart constructor.
data CreateRuleset = CreateRuleset'
  { -- | The description of the ruleset.
    CreateRuleset -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Metadata tags to apply to the ruleset.
    CreateRuleset -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The name of the ruleset to be created. Valid characters are alphanumeric
    -- (A-Z, a-z, 0-9), hyphen (-), period (.), and space.
    CreateRuleset -> Text
name :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) of a resource (dataset) that the ruleset
    -- is associated with.
    CreateRuleset -> Text
targetArn :: Prelude.Text,
    -- | A list of rules that are defined with the ruleset. A rule includes one
    -- or more checks to be validated on a DataBrew dataset.
    CreateRuleset -> NonEmpty Rule
rules :: Prelude.NonEmpty Rule
  }
  deriving (CreateRuleset -> CreateRuleset -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRuleset -> CreateRuleset -> Bool
$c/= :: CreateRuleset -> CreateRuleset -> Bool
== :: CreateRuleset -> CreateRuleset -> Bool
$c== :: CreateRuleset -> CreateRuleset -> Bool
Prelude.Eq, ReadPrec [CreateRuleset]
ReadPrec CreateRuleset
Int -> ReadS CreateRuleset
ReadS [CreateRuleset]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRuleset]
$creadListPrec :: ReadPrec [CreateRuleset]
readPrec :: ReadPrec CreateRuleset
$creadPrec :: ReadPrec CreateRuleset
readList :: ReadS [CreateRuleset]
$creadList :: ReadS [CreateRuleset]
readsPrec :: Int -> ReadS CreateRuleset
$creadsPrec :: Int -> ReadS CreateRuleset
Prelude.Read, Int -> CreateRuleset -> ShowS
[CreateRuleset] -> ShowS
CreateRuleset -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRuleset] -> ShowS
$cshowList :: [CreateRuleset] -> ShowS
show :: CreateRuleset -> String
$cshow :: CreateRuleset -> String
showsPrec :: Int -> CreateRuleset -> ShowS
$cshowsPrec :: Int -> CreateRuleset -> ShowS
Prelude.Show, forall x. Rep CreateRuleset x -> CreateRuleset
forall x. CreateRuleset -> Rep CreateRuleset x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateRuleset x -> CreateRuleset
$cfrom :: forall x. CreateRuleset -> Rep CreateRuleset x
Prelude.Generic)

-- |
-- Create a value of 'CreateRuleset' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'description', 'createRuleset_description' - The description of the ruleset.
--
-- 'tags', 'createRuleset_tags' - Metadata tags to apply to the ruleset.
--
-- 'name', 'createRuleset_name' - The name of the ruleset to be created. Valid characters are alphanumeric
-- (A-Z, a-z, 0-9), hyphen (-), period (.), and space.
--
-- 'targetArn', 'createRuleset_targetArn' - The Amazon Resource Name (ARN) of a resource (dataset) that the ruleset
-- is associated with.
--
-- 'rules', 'createRuleset_rules' - A list of rules that are defined with the ruleset. A rule includes one
-- or more checks to be validated on a DataBrew dataset.
newCreateRuleset ::
  -- | 'name'
  Prelude.Text ->
  -- | 'targetArn'
  Prelude.Text ->
  -- | 'rules'
  Prelude.NonEmpty Rule ->
  CreateRuleset
newCreateRuleset :: Text -> Text -> NonEmpty Rule -> CreateRuleset
newCreateRuleset Text
pName_ Text
pTargetArn_ NonEmpty Rule
pRules_ =
  CreateRuleset'
    { $sel:description:CreateRuleset' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateRuleset' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateRuleset' :: Text
name = Text
pName_,
      $sel:targetArn:CreateRuleset' :: Text
targetArn = Text
pTargetArn_,
      $sel:rules:CreateRuleset' :: NonEmpty Rule
rules = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Rule
pRules_
    }

-- | The description of the ruleset.
createRuleset_description :: Lens.Lens' CreateRuleset (Prelude.Maybe Prelude.Text)
createRuleset_description :: Lens' CreateRuleset (Maybe Text)
createRuleset_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleset' {Maybe Text
description :: Maybe Text
$sel:description:CreateRuleset' :: CreateRuleset -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateRuleset
s@CreateRuleset' {} Maybe Text
a -> CreateRuleset
s {$sel:description:CreateRuleset' :: Maybe Text
description = Maybe Text
a} :: CreateRuleset)

-- | Metadata tags to apply to the ruleset.
createRuleset_tags :: Lens.Lens' CreateRuleset (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createRuleset_tags :: Lens' CreateRuleset (Maybe (HashMap Text Text))
createRuleset_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleset' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateRuleset' :: CreateRuleset -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateRuleset
s@CreateRuleset' {} Maybe (HashMap Text Text)
a -> CreateRuleset
s {$sel:tags:CreateRuleset' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateRuleset) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the ruleset to be created. Valid characters are alphanumeric
-- (A-Z, a-z, 0-9), hyphen (-), period (.), and space.
createRuleset_name :: Lens.Lens' CreateRuleset Prelude.Text
createRuleset_name :: Lens' CreateRuleset Text
createRuleset_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleset' {Text
name :: Text
$sel:name:CreateRuleset' :: CreateRuleset -> Text
name} -> Text
name) (\s :: CreateRuleset
s@CreateRuleset' {} Text
a -> CreateRuleset
s {$sel:name:CreateRuleset' :: Text
name = Text
a} :: CreateRuleset)

-- | The Amazon Resource Name (ARN) of a resource (dataset) that the ruleset
-- is associated with.
createRuleset_targetArn :: Lens.Lens' CreateRuleset Prelude.Text
createRuleset_targetArn :: Lens' CreateRuleset Text
createRuleset_targetArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleset' {Text
targetArn :: Text
$sel:targetArn:CreateRuleset' :: CreateRuleset -> Text
targetArn} -> Text
targetArn) (\s :: CreateRuleset
s@CreateRuleset' {} Text
a -> CreateRuleset
s {$sel:targetArn:CreateRuleset' :: Text
targetArn = Text
a} :: CreateRuleset)

-- | A list of rules that are defined with the ruleset. A rule includes one
-- or more checks to be validated on a DataBrew dataset.
createRuleset_rules :: Lens.Lens' CreateRuleset (Prelude.NonEmpty Rule)
createRuleset_rules :: Lens' CreateRuleset (NonEmpty Rule)
createRuleset_rules = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleset' {NonEmpty Rule
rules :: NonEmpty Rule
$sel:rules:CreateRuleset' :: CreateRuleset -> NonEmpty Rule
rules} -> NonEmpty Rule
rules) (\s :: CreateRuleset
s@CreateRuleset' {} NonEmpty Rule
a -> CreateRuleset
s {$sel:rules:CreateRuleset' :: NonEmpty Rule
rules = NonEmpty Rule
a} :: CreateRuleset) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest CreateRuleset where
  type
    AWSResponse CreateRuleset =
      CreateRulesetResponse
  request :: (Service -> Service) -> CreateRuleset -> Request CreateRuleset
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CreateRuleset
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateRuleset)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Int -> Text -> CreateRulesetResponse
CreateRulesetResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"Name")
      )

instance Prelude.Hashable CreateRuleset where
  hashWithSalt :: Int -> CreateRuleset -> Int
hashWithSalt Int
_salt CreateRuleset' {Maybe Text
Maybe (HashMap Text Text)
NonEmpty Rule
Text
rules :: NonEmpty Rule
targetArn :: Text
name :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
$sel:rules:CreateRuleset' :: CreateRuleset -> NonEmpty Rule
$sel:targetArn:CreateRuleset' :: CreateRuleset -> Text
$sel:name:CreateRuleset' :: CreateRuleset -> Text
$sel:tags:CreateRuleset' :: CreateRuleset -> Maybe (HashMap Text Text)
$sel:description:CreateRuleset' :: CreateRuleset -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
targetArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Rule
rules

instance Prelude.NFData CreateRuleset where
  rnf :: CreateRuleset -> ()
rnf CreateRuleset' {Maybe Text
Maybe (HashMap Text Text)
NonEmpty Rule
Text
rules :: NonEmpty Rule
targetArn :: Text
name :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
$sel:rules:CreateRuleset' :: CreateRuleset -> NonEmpty Rule
$sel:targetArn:CreateRuleset' :: CreateRuleset -> Text
$sel:name:CreateRuleset' :: CreateRuleset -> Text
$sel:tags:CreateRuleset' :: CreateRuleset -> Maybe (HashMap Text Text)
$sel:description:CreateRuleset' :: CreateRuleset -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
targetArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Rule
rules

instance Data.ToHeaders CreateRuleset where
  toHeaders :: CreateRuleset -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateRuleset where
  toJSON :: CreateRuleset -> Value
toJSON CreateRuleset' {Maybe Text
Maybe (HashMap Text Text)
NonEmpty Rule
Text
rules :: NonEmpty Rule
targetArn :: Text
name :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
$sel:rules:CreateRuleset' :: CreateRuleset -> NonEmpty Rule
$sel:targetArn:CreateRuleset' :: CreateRuleset -> Text
$sel:name:CreateRuleset' :: CreateRuleset -> Text
$sel:tags:CreateRuleset' :: CreateRuleset -> Maybe (HashMap Text Text)
$sel:description:CreateRuleset' :: CreateRuleset -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Description" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
description,
            (Key
"Tags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just (Key
"TargetArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
targetArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"Rules" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Rule
rules)
          ]
      )

instance Data.ToPath CreateRuleset where
  toPath :: CreateRuleset -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/rulesets"

instance Data.ToQuery CreateRuleset where
  toQuery :: CreateRuleset -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newCreateRulesetResponse' smart constructor.
data CreateRulesetResponse = CreateRulesetResponse'
  { -- | The response's http status code.
    CreateRulesetResponse -> Int
httpStatus :: Prelude.Int,
    -- | The unique name of the created ruleset.
    CreateRulesetResponse -> Text
name :: Prelude.Text
  }
  deriving (CreateRulesetResponse -> CreateRulesetResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRulesetResponse -> CreateRulesetResponse -> Bool
$c/= :: CreateRulesetResponse -> CreateRulesetResponse -> Bool
== :: CreateRulesetResponse -> CreateRulesetResponse -> Bool
$c== :: CreateRulesetResponse -> CreateRulesetResponse -> Bool
Prelude.Eq, ReadPrec [CreateRulesetResponse]
ReadPrec CreateRulesetResponse
Int -> ReadS CreateRulesetResponse
ReadS [CreateRulesetResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRulesetResponse]
$creadListPrec :: ReadPrec [CreateRulesetResponse]
readPrec :: ReadPrec CreateRulesetResponse
$creadPrec :: ReadPrec CreateRulesetResponse
readList :: ReadS [CreateRulesetResponse]
$creadList :: ReadS [CreateRulesetResponse]
readsPrec :: Int -> ReadS CreateRulesetResponse
$creadsPrec :: Int -> ReadS CreateRulesetResponse
Prelude.Read, Int -> CreateRulesetResponse -> ShowS
[CreateRulesetResponse] -> ShowS
CreateRulesetResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRulesetResponse] -> ShowS
$cshowList :: [CreateRulesetResponse] -> ShowS
show :: CreateRulesetResponse -> String
$cshow :: CreateRulesetResponse -> String
showsPrec :: Int -> CreateRulesetResponse -> ShowS
$cshowsPrec :: Int -> CreateRulesetResponse -> ShowS
Prelude.Show, forall x. Rep CreateRulesetResponse x -> CreateRulesetResponse
forall x. CreateRulesetResponse -> Rep CreateRulesetResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateRulesetResponse x -> CreateRulesetResponse
$cfrom :: forall x. CreateRulesetResponse -> Rep CreateRulesetResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateRulesetResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'httpStatus', 'createRulesetResponse_httpStatus' - The response's http status code.
--
-- 'name', 'createRulesetResponse_name' - The unique name of the created ruleset.
newCreateRulesetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'name'
  Prelude.Text ->
  CreateRulesetResponse
newCreateRulesetResponse :: Int -> Text -> CreateRulesetResponse
newCreateRulesetResponse Int
pHttpStatus_ Text
pName_ =
  CreateRulesetResponse'
    { $sel:httpStatus:CreateRulesetResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:name:CreateRulesetResponse' :: Text
name = Text
pName_
    }

-- | The response's http status code.
createRulesetResponse_httpStatus :: Lens.Lens' CreateRulesetResponse Prelude.Int
createRulesetResponse_httpStatus :: Lens' CreateRulesetResponse Int
createRulesetResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRulesetResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateRulesetResponse' :: CreateRulesetResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateRulesetResponse
s@CreateRulesetResponse' {} Int
a -> CreateRulesetResponse
s {$sel:httpStatus:CreateRulesetResponse' :: Int
httpStatus = Int
a} :: CreateRulesetResponse)

-- | The unique name of the created ruleset.
createRulesetResponse_name :: Lens.Lens' CreateRulesetResponse Prelude.Text
createRulesetResponse_name :: Lens' CreateRulesetResponse Text
createRulesetResponse_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRulesetResponse' {Text
name :: Text
$sel:name:CreateRulesetResponse' :: CreateRulesetResponse -> Text
name} -> Text
name) (\s :: CreateRulesetResponse
s@CreateRulesetResponse' {} Text
a -> CreateRulesetResponse
s {$sel:name:CreateRulesetResponse' :: Text
name = Text
a} :: CreateRulesetResponse)

instance Prelude.NFData CreateRulesetResponse where
  rnf :: CreateRulesetResponse -> ()
rnf CreateRulesetResponse' {Int
Text
name :: Text
httpStatus :: Int
$sel:name:CreateRulesetResponse' :: CreateRulesetResponse -> Text
$sel:httpStatus:CreateRulesetResponse' :: CreateRulesetResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name