Prelude/Text.ad

Outline
module Prelude.TextText (datatype)
pack (declaration + definition)
unpack (declaration + definition)
LiteralString Text (typeclass-instance)mkLiteralString (definition)
EqP Text (typeclass-instance)
Eq Text (typeclass-instance)
Ord Text (typeclass-instance)
Semigroup Text (typeclass-instance)<> (definition)
Monoid Text (typeclass-instance)mempty (definition)

Content
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

module Prelude.Text (
  Textdatatype `Prelude.Text.Text`
   kind `*`
   executable,
  packconstant `Prelude.Text.pack`
   constant
   type `String -> Text`
   executable,
  unpackconstant `Prelude.Text.unpack`
   constant
   type `Text -> String`
   executable
) where

{-# NoImplicitPrelude #-}

import Prelude.List ()
import Prelude.Eq
import Prelude.BasicClasses
import Prelude.Ord
import Prelude.String
import Prelude.Function
import Prelude.Literal
import Prelude.Bool

datatype Textdatatype `Prelude.Text.Text`
   kind `*`
   executable := Text Stringabbreviation-type `Prelude.String.String`
   kind `*`
   type `String` abbreviates type `[Prelude.Char.Char]`
   executable

declare packconstant `Prelude.Text.pack`
   constant
   type `String -> Text`
   executable :: Stringabbreviation-type `Prelude.String.String`
   kind `*`
   type `String` abbreviates type `[Prelude.Char.Char]`
   executable -> Textdatatype `Prelude.Text.Text`
   kind `*`
   executable
define packconstant `Prelude.Text.pack`
   constant
   type `String -> Text`
   executable := Textconstant `Prelude.Text.Text`
   constructor of datatype `Text`
   type `String -> Text`
   executable

declare unpackconstant `Prelude.Text.unpack`
   constant
   type `Text -> String`
   executable :: Textdatatype `Prelude.Text.Text`
   kind `*`
   executable -> Stringabbreviation-type `Prelude.String.String`
   kind `*`
   type `String` abbreviates type `[Prelude.Char.Char]`
   executable
define unpackconstant `Prelude.Text.unpack`
   constant
   type `Text -> String`
   executable (Textconstant `Prelude.Text.Text`
   constructor of datatype `Text`
   type `String -> Text`
   executable svariable `s`
   type `String`) := svariable `s`
   type `String`

instance LiteralStringtype-class `Prelude.Literal.LiteralString`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.Eq 'a
   statically-resolved Textdatatype `Prelude.Text.Text`
   kind `*`
   executable where
  define mkLiteralStringconstant `Prelude.Literal.mkLiteralString`
   constant of type-class instance `LiteralString Text`
   type `BuiltInString -> Text`
   executable := packconstant `Prelude.Text.pack`
   constant
   type `String -> Text`
   executable .constant `Prelude.Function.(.)`
   constant of type-class `Dot`
   type `'a -> 'b -> 'c`
   type in context `(String -> Text) -> (BuiltInString -> [Prelude.Char.Char]) -> BuiltInString -> Text`
   executable
   statically resolved type-class instance mkLiteralStringconstant `Prelude.Literal.mkLiteralString`
   statically resolved constant of type-class `LiteralString`
   type `BuiltInString -> 'a`
   type in context `BuiltInString -> [Prelude.Char.Char]`
   executable
   statically resolved type-class instance
  {-# inline mkLiteralStringconstant `Prelude.Literal.mkLiteralString`
   constant of type-class instance `LiteralString Text`
   type `BuiltInString -> Text`
   executable #-}
end-instance

derive Textdatatype `Prelude.Text.Text`
   kind `*`
   executable instances (EqPtype-class `Prelude.Eq.EqP`
   arguments: ('a :: *)
   has default derive templates
   derive-template labels
     - eq (only deriving)
     - fullgenerated code:

instance EqP Text where
  define non-exec (===) x y := bool2prop (x == y)
end-instance
, Eqtype-class `Prelude.Eq.Eq`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.EqP 'a
   has default derive templatesgenerated code:

instance Eq Text where
  define (==) (Text x1) (Text y1) := (x1 == y1)
end-instance
, Ordtype-class `Prelude.Ord.Ord`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.Eq.Eq 'a
   has default derive templatesgenerated code:

instance Ord Text where
  define compare (Text x1) (Text y1) := compare x1 y1
end-instance
)

instance Semigrouptype-class `Prelude.BasicClasses.Semigroup`
   arguments: ('a :: *) Textdatatype `Prelude.Text.Text`
   kind `*`
   executable where
  define (<>)constant `Prelude.BasicClasses.(<>)`
   constant of type-class instance `Semigroup Text`
   type `Text -> Text -> Text`
   executable (Textconstant `Prelude.Text.Text`
   constructor of datatype `Text`
   type `String -> Text`
   executable s1variable `s1`
   type `String`) (Textconstant `Prelude.Text.Text`
   constructor of datatype `Text`
   type `String -> Text`
   executable s2variable `s2`
   type `String`) := Textconstant `Prelude.Text.Text`
   constructor of datatype `Text`
   type `String -> Text`
   executable (s1variable `s1`
   type `String` <>constant `Prelude.BasicClasses.(<>)`
   constant of type-class `Semigroup`
   type `'a -> 'a -> 'a`
   type in context `String -> String -> String`
   executable
   statically resolved type-class instance s2variable `s2`
   type `String`)
end-instance

instance Monoidtype-class `Prelude.BasicClasses.Monoid`
   arguments: ('a :: *)
   super-class constraints:
     - Prelude.BasicClasses.Semigroup 'a Textdatatype `Prelude.Text.Text`
   kind `*`
   executable where
  define memptyconstant `Prelude.BasicClasses.mempty`
   constant of type-class instance `Monoid Text`
   type `Text`
   executable := packconstant `Prelude.Text.pack`
   constant
   type `String -> Text`
   executable ""type `String`
end-instance



end-moduleend of module Prelude.Text