ASCII

The American Standard Code for Information Interchange (ASCII) comprises a set of 128 characters, each represented by 7 bits. 33 of these characters are Control codes; a few of these are still in use, but most are obsolete relics of the early days of computing. The other 95 are Printable characters such as letters and numbers, mostly corresponding to the keys on an American English keyboard.

Nowadays instead of ASCII we typically work with text using an encoding such as UTF-8 that can represent the entire Unicode character set, which includes over a hundred thousand characters and is not limited to the symbols of any particular writing system or culture. However, ASCII is still relevant to network protocols; for example, we can see it in the specification of HTTP message headers.

There is a convenient relationship between ASCII and Unicode: the ASCII characters are the first 128 characters of the much larger Unicode character set. The C0 Controls and Basic Latin section of the Unicode standard contains a list of all the ASCII characters. You may also find this list replicated in the ASCII.Char module; each ASCII character corresponds to a constructor of the Char type.

We do not elaborate on the semantics of the control characters here, because this information is both obsolete and restricted by copyright law. It is described by a document entitled "Coded Character Sets - 7-Bit American National Standard Code for Information Interchange (7-Bit ASCII)", published by American National Standards Institute (ANSI) and available for purchase on their website.

Char

See also: ASCII.Char

data Char

A character in the ASCII character set.

Instances

Bounded Char

The least character is Null, and the greatest character is Delete. You can write ([minBound .. maxBound] :: [ASCII.Char]) to get a list of all the ASCII characters.

Defined in ASCII.Char

Methods

minBound :: Char

maxBound :: Char

Enum Char

The Enum instance allows us to use range syntax, for example [SmallLetterA .. SmallLetterZ] is a list all lower-case letters from a to z. Instead of toEnum and fromEnum, consider using toInt and fromIntMaybe.

Defined in ASCII.Char

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

ASCII characters can be compared for equality using (==). Comparisons are case-sensitive; SmallLetterA /= CapitalLetterA.

Defined in ASCII.Char

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Data Char

The Data instance allows ASCII characters to be used with generic programming in the “SYB” style. (See the syb package and the 2003 paper Scrap Your Boilerplate by Ralf Lämmel and Simon Peyton Jones.)

Defined in ASCII.Char

Methods

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

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

toConstr :: Char -> Constr

dataTypeOf :: Char -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Char -> Char

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

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

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

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

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

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

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

Ord Char

ASCII characters are ordered; for example, the letter A is "less than" (<) the letter B because it appears earlier in the list. The ordering of ASCII characters is the same as the ordering of the corresponding Unicode Chars.

Defined in ASCII.Char

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Show Char

show produces the name of a constructor. For example, the character e is shown as “SmallLetterE”. See ASCII.Char for the complete list of constructor names.

Defined in ASCII.Char

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Generic Char

The Generic instance allows ASCII characters to be used with generic programming in the “generic deriving” style. (See the generic-data package and the 2010 paper A generic deriving mechanism for Haskell by José Pedro Magalhães, Atze Dijkstra, Johan Jeuring, and Andres Löh.)

Defined in ASCII.Char

Associated Types

type Rep Char :: Type -> Type

Methods

from :: Char -> Rep Char x

to :: Rep Char x -> Char

Hashable Char

The Hashable instance lets us collect ASCII characters in hash-based sets, and it lets us use ASCII characters as keys in hash-based maps. (See the unordered-containers package.)

Defined in ASCII.Char

Methods

hashWithSalt :: Int -> Char -> Int

hash :: Char -> Int

CharIso Char

Char is trivially isomorphic to itself. (This instance is uninteresting.)

Defined in ASCII.Isomorphism

Methods

toChar :: Char -> Char

CharSuperset Char

Char is trivially a superset of itself. (This instance is uninteresting.)

Defined in ASCII.Superset

Methods

isAsciiChar :: Char -> Bool

fromChar :: Char -> Char

toCharUnsafe :: Char -> Char

CharSuperset superset => Lift Char superset

An ASCII Char may be lifted into any larger character set (a CharSuperset); for example, lift can convert an ASCII character into a value of the standard Char type in Prelude.

Defined in ASCII.Lift

Methods

lift :: Char -> superset

StringSuperset superset => Lift [Char] superset

An ASCII Char list may be lifted into a string of any larger character set (a StringSuperset); for example, lift can convert a list of ASCII characters into a value of the standard String type in Prelude.

Defined in ASCII.Lift

Methods

lift :: [Char] -> superset

type Rep Char

Defined in ASCII.Char

type Rep Char = D1 ('MetaData "Char" "ASCII.Char" "ascii-char-1.0.0.10-1qC26iLM96z9hSmcEMMiHE" 'False) (((((((C1 ('MetaCons "Null" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StartOfHeading" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "StartOfText" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EndOfText" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "EndOfTransmission" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Enquiry" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Acknowledgement" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Bell" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "Backspace" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "HorizontalTab" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LineFeed" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "VerticalTab" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "FormFeed" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CarriageReturn" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ShiftOut" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ShiftIn" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "DataLinkEscape" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeviceControl1" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DeviceControl2" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeviceControl3" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "DeviceControl4" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NegativeAcknowledgement" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SynchronousIdle" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EndOfTransmissionBlock" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "Cancel" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EndOfMedium" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Substitute" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Escape" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "FileSeparator" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GroupSeparator" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "RecordSeparator" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnitSeparator" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: (((((C1 ('MetaCons "Space" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExclamationMark" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "QuotationMark" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NumberSign" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "DollarSign" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PercentSign" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Ampersand" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Apostrophe" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "LeftParenthesis" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RightParenthesis" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Asterisk" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PlusSign" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Comma" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "HyphenMinus" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "FullStop" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Slash" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "Digit0" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Digit1" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Digit2" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Digit3" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Digit4" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Digit5" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Digit6" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Digit7" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "Digit8" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Digit9" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Colon" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Semicolon" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "LessThanSign" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EqualsSign" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "GreaterThanSign" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "QuestionMark" 'PrefixI 'False) (U1 :: Type -> Type))))))) :+: ((((((C1 ('MetaCons "AtSign" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterA" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CapitalLetterB" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterC" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "CapitalLetterD" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterE" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CapitalLetterF" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterG" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "CapitalLetterH" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterI" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CapitalLetterJ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterK" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "CapitalLetterL" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterM" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CapitalLetterN" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterO" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "CapitalLetterP" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterQ" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CapitalLetterR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterS" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "CapitalLetterT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterU" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CapitalLetterV" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterW" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "CapitalLetterX" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "CapitalLetterY" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CapitalLetterZ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LeftSquareBracket" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "Backslash" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RightSquareBracket" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Caret" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Underscore" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: (((((C1 ('MetaCons "GraveAccent" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterA" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SmallLetterB" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterC" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "SmallLetterD" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterE" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SmallLetterF" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterG" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "SmallLetterH" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterI" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SmallLetterJ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterK" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "SmallLetterL" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterM" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SmallLetterN" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterO" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "SmallLetterP" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterQ" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SmallLetterR" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterS" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "SmallLetterT" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterU" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SmallLetterV" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterW" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "SmallLetterX" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SmallLetterY" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SmallLetterZ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LeftCurlyBracket" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "VerticalLine" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RightCurlyBracket" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Tilde" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Delete" 'PrefixI 'False) (U1 :: Type -> Type))))))))

Character classifications

Print/control groups

ASCII characters are broadly categorized into two groups: control codes and printable characters.

See also: ASCII.Group

data Group

Constructors

Control

33 of the ASCII characters are control codes. A few of these are still in use, but most are obsolete relics of the early days of computing.

Printable

95 of the ASCII characters are printable characters such as letters and numbers, mostly corresponding to the keys on an American English keyboard.

Instances

Bounded Group

Defined in ASCII.Group

Methods

minBound :: Group

maxBound :: Group

Enum Group

Defined in ASCII.Group

Methods

succ :: Group -> Group

pred :: Group -> Group

toEnum :: Int -> Group

fromEnum :: Group -> Int

enumFrom :: Group -> [Group]

enumFromThen :: Group -> Group -> [Group]

enumFromTo :: Group -> Group -> [Group]

enumFromThenTo :: Group -> Group -> Group -> [Group]

Eq Group

Defined in ASCII.Group

Methods

(==) :: Group -> Group -> Bool

(/=) :: Group -> Group -> Bool

Data Group

Defined in ASCII.Group

Methods

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

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

toConstr :: Group -> Constr

dataTypeOf :: Group -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Group -> Group

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

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

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

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

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

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

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

Ord Group

Defined in ASCII.Group

Methods

compare :: Group -> Group -> Ordering

(<) :: Group -> Group -> Bool

(<=) :: Group -> Group -> Bool

(>) :: Group -> Group -> Bool

(>=) :: Group -> Group -> Bool

max :: Group -> Group -> Group

min :: Group -> Group -> Group

Show Group

Defined in ASCII.Group

Methods

showsPrec :: Int -> Group -> ShowS

show :: Group -> String

showList :: [Group] -> ShowS

Generic Group

Defined in ASCII.Group

Associated Types

type Rep Group :: Type -> Type

Methods

from :: Group -> Rep Group x

to :: Rep Group x -> Group

Hashable Group

Defined in ASCII.Group

Methods

hashWithSalt :: Int -> Group -> Int

hash :: Group -> Int

type Rep Group

Defined in ASCII.Group

type Rep Group = D1 ('MetaData "Group" "ASCII.Group" "ascii-group-1.0.0.6-AWec6PAMYcb6vnQp6Tw106" 'False) (C1 ('MetaCons "Control" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Printable" 'PrefixI 'False) (U1 :: Type -> Type))

charGroup :: CharIso char => char -> Group

Determine which group a particular character belongs to.

>>> map charGroup [CapitalLetterA,EndOfTransmission]
[Printable,Control]

inGroup :: CharSuperset char => Group -> char -> Bool

Test whether a character belongs to a particular ASCII group.

>>> inGroup Printable EndOfTransmission
False

>>> inGroup Control EndOfTransmission
True

>>> map (inGroup Printable) ( [-1, 5, 65, 97, 127, 130] :: [Int] )
[False,False,True,True,False,False]

Upper/lower case

Case is a property of letters. A-Z are upper case letters, and a-z are lower case letters. No other ASCII characters have case.

See also: ASCII.Case

data Case

Constructors

UpperCase

The letters from CapitalLetterA to CapitalLetterZ.

LowerCase

The letters from SmallLetterA to SmallLetterZ.

Instances

Bounded Case

Defined in ASCII.Case

Methods

minBound :: Case

maxBound :: Case

Enum Case

Defined in ASCII.Case

Methods

succ :: Case -> Case

pred :: Case -> Case

toEnum :: Int -> Case

fromEnum :: Case -> Int

enumFrom :: Case -> [Case]

enumFromThen :: Case -> Case -> [Case]

enumFromTo :: Case -> Case -> [Case]

enumFromThenTo :: Case -> Case -> Case -> [Case]

Eq Case

Defined in ASCII.Case

Methods

(==) :: Case -> Case -> Bool

(/=) :: Case -> Case -> Bool

Data Case

Defined in ASCII.Case

Methods

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

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

toConstr :: Case -> Constr

dataTypeOf :: Case -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Case -> Case

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

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

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

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

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

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

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

Ord Case

Defined in ASCII.Case

Methods

compare :: Case -> Case -> Ordering

(<) :: Case -> Case -> Bool

(<=) :: Case -> Case -> Bool

(>) :: Case -> Case -> Bool

(>=) :: Case -> Case -> Bool

max :: Case -> Case -> Case

min :: Case -> Case -> Case

Show Case

Defined in ASCII.Case

Methods

showsPrec :: Int -> Case -> ShowS

show :: Case -> String

showList :: [Case] -> ShowS

Generic Case

Defined in ASCII.Case

Associated Types

type Rep Case :: Type -> Type

Methods

from :: Case -> Rep Case x

to :: Rep Case x -> Case

Hashable Case

Defined in ASCII.Case

Methods

hashWithSalt :: Int -> Case -> Int

hash :: Case -> Int

type Rep Case

Defined in ASCII.Case

type Rep Case = D1 ('MetaData "Case" "ASCII.Case" "ascii-case-1.0.0.6-EHDX6vji2erL7VudjlYfkZ" 'False) (C1 ('MetaCons "UpperCase" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LowerCase" 'PrefixI 'False) (U1 :: Type -> Type))

letterCase :: CharSuperset char => char -> Maybe Case

Determines whether a character is an ASCII letter, and if so, whether it is upper or lower case.

>>> map letterCase [SmallLetterA, CapitalLetterA, ExclamationMark]
[Just LowerCase,Just UpperCase,Nothing]

>>> map letterCase ( [string|Hey!|] :: [ASCII Word8] )
[Just UpperCase,Just LowerCase,Just LowerCase,Nothing]

isCase :: CharSuperset char => Case -> char -> Bool

Determines whether a character is an ASCII letter of a particular case.

>>> map (isCase UpperCase) [SmallLetterA, CapitalLetterA, ExclamationMark]
[False,True,False]

>>> map (isCase UpperCase) ( [string|Hey!|] :: [ASCII Word8] )
[True,False,False,False]

>>> map (isCase UpperCase) ( [-1, 65, 97, 150] :: [Int] )
[False,True,False,False]

toCaseChar :: CharIso char => Case -> char -> char

Maps a letter character to its upper/lower case equivalent.

>>> toCaseChar UpperCase SmallLetterA
CapitalLetterA

>>> ([char|a|] :: ASCII Word8, toCaseChar UpperCase [char|a|] :: ASCII Word8)
(asciiUnsafe 97,asciiUnsafe 65)

toCaseString :: StringIso string => Case -> string -> string

Maps each of the characters in a string to its upper/lower case equivalent.

>>> toCaseString UpperCase [CapitalLetterH,SmallLetterE,SmallLetterY,ExclamationMark]
[CapitalLetterH,CapitalLetterE,CapitalLetterY,ExclamationMark]

>>> toCaseString UpperCase [string|Hey!|] :: ASCII Text
asciiUnsafe "HEY!"

Letters and numbers

isAlphaNum :: CharSuperset char => char -> Bool

Returns True if the character is either an ASCII letter (isLetter) or an ASCII digit (isDigit).

isLetter :: CharSuperset char => char -> Bool

Returns True for ASCII letters:

• SmallLetterA to SmallLetterZ
• CapitalLetterA to CapitalLetterZ

isDigit :: CharSuperset char => char -> Bool

Returns True for the characters from Digit0 to Digit9.

isOctDigit :: CharSuperset char => char -> Bool

Returns True for the characters from Digit0 to Digit7.

isHexDigit :: CharSuperset char => char -> Bool

Returns True for characters in any of the following ranges:

• Digit0 to Digit9
• CapitalLetterA to CapitalLetterF
• SmallLetterA to SmallLetterF

Spaces and symbols

isSpace :: CharSuperset char => char -> Bool

Returns True for the following characters:

• Space
• HorizontalTab
• LineFeed
• VerticalTab
• FormFeed
• CarriageReturn

isPunctuation :: CharSuperset char => char -> Bool

Returns True for the following characters:

• ExclamationMark
• QuotationMark
• NumberSign
• PercentSign
• Ampersand
• Apostrophe
• LeftParenthesis
• RightParenthesis
• Asterisk
• Comma
• HyphenMinus
• FullStop
• Slash
• Colon
• Semicolon
• QuestionMark
• AtSign
• LeftSquareBracket
• Backslash
• RightSquareBracket
• Underscore
• LeftCurlyBracket
• RightCurlyBracket

isSymbol :: CharSuperset char => char -> Bool

Returns True for the following characters:

• DollarSign
• PlusSign
• LessThanSign
• EqualsSign
• GreaterThanSign
• Caret
• GraveAccent
• VerticalLine
• Tilde

Monomorphic conversions

These are a few simple monomorphic functions to convert between ASCII and types representing some other character set.

This is not intended to be an exhaustive list of all possible conversions. For more options, see ASCII.Superset.

Int

These functions convert between the ASCII Char type and Int.

charToInt :: Char -> Int

>>> map charToInt [Null, CapitalLetterA, SmallLetterA, Delete]
[0,65,97,127]

intToCharMaybe :: Int -> Maybe Char

intToCharUnsafe :: Int -> Char

Word8

These functions convert between the ASCII Char type and Word8.

charToWord8 :: Char -> Word8

>>> map charToWord8 [Null, CapitalLetterA, SmallLetterA, Delete]
[0,65,97,127]

word8ToCharMaybe :: Word8 -> Maybe Char

word8ToCharUnsafe :: Word8 -> Char

Char

These functions convert between the ASCII Char type and the Unicode Char type.

charToUnicode :: Char -> Char

unicodeToCharMaybe :: Char -> Maybe Char

unicodeToCharUnsafe :: Char -> Char

String

These functions convert between [Char] (a list of ASCII characters) and String (a list of Unicode characters).

charListToUnicodeString :: [Char] -> String

unicodeStringToCharListMaybe :: String -> Maybe [Char]

unicodeStringToCharListUnsafe :: String -> [Char]

Text

These functions convert between [Char] and Text.

charListToText :: [Char] -> Text

>>> charListToText [CapitalLetterH,SmallLetterI,ExclamationMark]
"Hi!"

textToCharListMaybe :: Text -> Maybe [Char]

textToCharListUnsafe :: Text -> [Char]

ByteString

These functions convert between [Char] and ByteString.

charListToByteString :: [Char] -> ByteString

byteStringToCharListMaybe :: ByteString -> Maybe [Char]

byteStringToCharListUnsafe :: ByteString -> [Char]

Monomorphic conversions between ASCII supersets

These functions are all specializations of convertStringMaybe. They convert a string from one ASCII-superset type to another.

>>> ASCII.byteListToUnicodeStringMaybe [0x48, 0x54, 0x54, 0x50]
Just "HTTP"

If any of the characters in the input is outside the ASCII character set, the result is Nothing.

>>> ASCII.byteListToUnicodeStringMaybe [0x48, 0x54, 0x54, 0x80]
Nothing

ByteString / String

byteStringToUnicodeStringMaybe :: ByteString -> Maybe String

unicodeStringToByteStringMaybe :: String -> Maybe ByteString

[Word8] / String

byteListToUnicodeStringMaybe :: [Word8] -> Maybe String

unicodeStringToByteListMaybe :: String -> Maybe [Word8]

Refinement type

See also: ASCII.Refinement

ASCII

data ASCII superset

This type constructor indicates that a value from some ASCII superset is valid ASCII. The type parameter is the ASCII superset, which should be a type with an instance of either CharSuperset or StringSuperset.

For example, whereas a Text value may contain a combination of ASCII and non-ASCII characters, a value of type ASCII Text may contain only ASCII characters.

Instances

Eq superset => Eq (ASCII superset)

Defined in ASCII.Refinement

Methods

(==) :: ASCII superset -> ASCII superset -> Bool

(/=) :: ASCII superset -> ASCII superset -> Bool

Data superset => Data (ASCII superset)

Defined in ASCII.Refinement

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ASCII superset -> c (ASCII superset)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ASCII superset)

toConstr :: ASCII superset -> Constr

dataTypeOf :: ASCII superset -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ASCII superset))

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

gmapT :: (forall b. Data b => b -> b) -> ASCII superset -> ASCII superset

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ASCII superset -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ASCII superset -> r

gmapQ :: (forall d. Data d => d -> u) -> ASCII superset -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ASCII superset -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ASCII superset -> m (ASCII superset)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ASCII superset -> m (ASCII superset)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ASCII superset -> m (ASCII superset)

Ord superset => Ord (ASCII superset)

Defined in ASCII.Refinement

Methods

compare :: ASCII superset -> ASCII superset -> Ordering

(<) :: ASCII superset -> ASCII superset -> Bool

(<=) :: ASCII superset -> ASCII superset -> Bool

(>) :: ASCII superset -> ASCII superset -> Bool

(>=) :: ASCII superset -> ASCII superset -> Bool

max :: ASCII superset -> ASCII superset -> ASCII superset

min :: ASCII superset -> ASCII superset -> ASCII superset

Show superset => Show (ASCII superset)

Defined in ASCII.Refinement

Methods

showsPrec :: Int -> ASCII superset -> ShowS

show :: ASCII superset -> String

showList :: [ASCII superset] -> ShowS

Generic (ASCII superset)

Defined in ASCII.Refinement

Associated Types

type Rep (ASCII superset) :: Type -> Type

Methods

from :: ASCII superset -> Rep (ASCII superset) x

to :: Rep (ASCII superset) x -> ASCII superset

Semigroup superset => Semigroup (ASCII superset)

Defined in ASCII.Refinement

Methods

(<>) :: ASCII superset -> ASCII superset -> ASCII superset

sconcat :: NonEmpty (ASCII superset) -> ASCII superset

stimes :: Integral b => b -> ASCII superset -> ASCII superset

Monoid superset => Monoid (ASCII superset)

Defined in ASCII.Refinement

Methods

mempty :: ASCII superset

mappend :: ASCII superset -> ASCII superset -> ASCII superset

mconcat :: [ASCII superset] -> ASCII superset

Hashable superset => Hashable (ASCII superset)

Defined in ASCII.Refinement

Methods

hashWithSalt :: Int -> ASCII superset -> Int

hash :: ASCII superset -> Int

CharSuperset char => CharIso (ASCII char)

Defined in ASCII.Refinement

Methods

toChar :: ASCII char -> Char

StringSuperset string => StringIso (ASCII string)

Defined in ASCII.Refinement

Methods

toCharList :: ASCII string -> [Char]

mapChars :: (Char -> Char) -> ASCII string -> ASCII string

CharSuperset char => CharSuperset (ASCII char)

Defined in ASCII.Refinement

Methods

isAsciiChar :: ASCII char -> Bool

fromChar :: Char -> ASCII char

toCharUnsafe :: ASCII char -> Char

StringSuperset string => StringSuperset (ASCII string)

Defined in ASCII.Refinement

Methods

isAsciiString :: ASCII string -> Bool

fromCharList :: [Char] -> ASCII string

toCharListUnsafe :: ASCII string -> [Char]

toCharListSub :: ASCII string -> [Char]

substituteString :: ASCII string -> ASCII string

mapCharsUnsafe :: (Char -> Char) -> ASCII string -> ASCII string

Lift (ASCII superset) superset

A value from an ASCII superset that has been refined by the ASCII type constructor may be lifted back into the superset by unwrapping it from the ASCII type.

Defined in ASCII.Lift

Methods

lift :: ASCII superset -> superset

type Rep (ASCII superset)

Defined in ASCII.Refinement

type Rep (ASCII superset) = D1 ('MetaData "ASCII" "ASCII.Refinement" "ascii-superset-1.0.1.6-F3hvabithXAB2mMAYfwh8x" 'True) (C1 ('MetaCons "ASCII_Unsafe" 'PrefixI 'True) (S1 ('MetaSel ('Just "lift") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 superset)))

Polymorphic conversions

Validate

validateChar :: CharSuperset superset => superset -> Maybe (ASCII superset)

>>> map validateChar [-1, 65, 97, 128] :: [Maybe (ASCII Int)]
[Nothing,Just (asciiUnsafe 65),Just (asciiUnsafe 97),Nothing]

validateString :: StringSuperset superset => superset -> Maybe (ASCII superset)

>>> map validateString ["Hello", "Cristóbal"] :: [Maybe (ASCII Text)]
[Just (asciiUnsafe "Hello"),Nothing]

>>> map validateString ["Hello", "Cristóbal"] :: [Maybe (ASCII String)]
[Just (asciiUnsafe "Hello"),Nothing]

Lift

See also: ASCII.Lift

lift :: Lift ascii superset => ascii -> superset

Converts from ASCII to any larger type.

For example, (lift @ASCII.Char @Word8) is the same function as charToWord8.

>>> lift CapitalLetterA :: Word8
65

And (lift @[ASCII.Char] @Text) is equivalent to charListToText.

>>> lift [CapitalLetterH,SmallLetterI,ExclamationMark] :: Text
"Hi!"

Due to the highly polymorphic nature of the lift function, often it must used with an explicit type signature or type application to avoid any type ambiguity.

Convert

These functions all convert from one ASCII-superset type to another, failing if any of the characters in the input is outside the ASCII character set.

convertCharMaybe :: (CharSuperset char1, CharSuperset char2) => char1 -> Maybe char2

convertCharOrFail :: (CharSuperset char1, CharSuperset char2, MonadFail context) => char1 -> context char2

convertStringMaybe :: (StringSuperset string1, StringSuperset string2) => string1 -> Maybe string2

convertStringOrFail :: (StringSuperset string1, StringSuperset string2, MonadFail context) => string1 -> context string2

Classes

CharSuperset

class CharSuperset char

Minimal complete definition

isAsciiChar, fromChar, toCharUnsafe

Instances

CharSuperset Char

Defined in ASCII.Superset

Methods

isAsciiChar :: Char -> Bool

fromChar :: Char0 -> Char

toCharUnsafe :: Char -> Char0

CharSuperset Int

Defined in ASCII.Superset

Methods

isAsciiChar :: Int -> Bool

fromChar :: Char -> Int

toCharUnsafe :: Int -> Char

CharSuperset Natural

Defined in ASCII.Superset

Methods

isAsciiChar :: Natural -> Bool

fromChar :: Char -> Natural

toCharUnsafe :: Natural -> Char

CharSuperset Word8

Defined in ASCII.Superset

Methods

isAsciiChar :: Word8 -> Bool

fromChar :: Char -> Word8

toCharUnsafe :: Word8 -> Char

CharSuperset Char

Char is trivially a superset of itself. (This instance is uninteresting.)

Defined in ASCII.Superset

Methods

isAsciiChar :: Char -> Bool

fromChar :: Char -> Char

toCharUnsafe :: Char -> Char

CharSuperset char => CharSuperset (ASCII char)

Defined in ASCII.Refinement

Methods

isAsciiChar :: ASCII char -> Bool

fromChar :: Char -> ASCII char

toCharUnsafe :: ASCII char -> Char

StringSuperset

class StringSuperset string

Minimal complete definition

isAsciiString, fromCharList, toCharListUnsafe, toCharListSub, substituteString

Instances

StringSuperset ByteString

Defined in ASCII.Superset

Methods

isAsciiString :: ByteString -> Bool

fromCharList :: [Char] -> ByteString

toCharListUnsafe :: ByteString -> [Char]

toCharListSub :: ByteString -> [Char]

substituteString :: ByteString -> ByteString

mapCharsUnsafe :: (Char -> Char) -> ByteString -> ByteString

StringSuperset ByteString

Defined in ASCII.Superset

Methods

isAsciiString :: ByteString -> Bool

fromCharList :: [Char] -> ByteString

toCharListUnsafe :: ByteString -> [Char]

toCharListSub :: ByteString -> [Char]

substituteString :: ByteString -> ByteString

mapCharsUnsafe :: (Char -> Char) -> ByteString -> ByteString

StringSuperset Builder

Defined in ASCII.Superset

Methods

isAsciiString :: Builder -> Bool

fromCharList :: [Char] -> Builder

toCharListUnsafe :: Builder -> [Char]

toCharListSub :: Builder -> [Char]

substituteString :: Builder -> Builder

mapCharsUnsafe :: (Char -> Char) -> Builder -> Builder

StringSuperset Builder

Defined in ASCII.Superset

Methods

isAsciiString :: Builder -> Bool

fromCharList :: [Char] -> Builder

toCharListUnsafe :: Builder -> [Char]

toCharListSub :: Builder -> [Char]

substituteString :: Builder -> Builder

mapCharsUnsafe :: (Char -> Char) -> Builder -> Builder

StringSuperset Text

Defined in ASCII.Superset

Methods

isAsciiString :: Text -> Bool

fromCharList :: [Char] -> Text

toCharListUnsafe :: Text -> [Char]

toCharListSub :: Text -> [Char]

substituteString :: Text -> Text

mapCharsUnsafe :: (Char -> Char) -> Text -> Text

StringSuperset Text

Defined in ASCII.Superset

Methods

isAsciiString :: Text -> Bool

fromCharList :: [Char] -> Text

toCharListUnsafe :: Text -> [Char]

toCharListSub :: Text -> [Char]

substituteString :: Text -> Text

mapCharsUnsafe :: (Char -> Char) -> Text -> Text

CharSuperset char => StringSuperset [char]

Defined in ASCII.Superset

Methods

isAsciiString :: [char] -> Bool

fromCharList :: [Char] -> [char]

toCharListUnsafe :: [char] -> [Char]

toCharListSub :: [char] -> [Char]

substituteString :: [char] -> [char]

mapCharsUnsafe :: (Char -> Char) -> [char] -> [char]

StringSuperset string => StringSuperset (ASCII string)

Defined in ASCII.Refinement

Methods

isAsciiString :: ASCII string -> Bool

fromCharList :: [Char] -> ASCII string

toCharListUnsafe :: ASCII string -> [Char]

toCharListSub :: ASCII string -> [Char]

substituteString :: ASCII string -> ASCII string

mapCharsUnsafe :: (Char -> Char) -> ASCII string -> ASCII string

Lift

class Lift ascii superset

Minimal complete definition

lift

Instances

CharSuperset superset => Lift Char superset

An ASCII Char may be lifted into any larger character set (a CharSuperset); for example, lift can convert an ASCII character into a value of the standard Char type in Prelude.

Defined in ASCII.Lift

Methods

lift :: Char -> superset

StringSuperset superset => Lift [Char] superset

An ASCII Char list may be lifted into a string of any larger character set (a StringSuperset); for example, lift can convert a list of ASCII characters into a value of the standard String type in Prelude.

Defined in ASCII.Lift

Methods

lift :: [Char] -> superset

Lift (ASCII superset) superset

A value from an ASCII superset that has been refined by the ASCII type constructor may be lifted back into the superset by unwrapping it from the ASCII type.

Defined in ASCII.Lift

Methods

lift :: ASCII superset -> superset

CharIso

class CharSuperset char => CharIso char

Minimal complete definition

toChar

Instances

CharIso Char

Char is trivially isomorphic to itself. (This instance is uninteresting.)

Defined in ASCII.Isomorphism

Methods

toChar :: Char -> Char

CharSuperset char => CharIso (ASCII char)

Defined in ASCII.Refinement

Methods

toChar :: ASCII char -> Char

StringIso

class StringSuperset string => StringIso string

Minimal complete definition

toCharList, mapChars

Instances

CharIso char => StringIso [char]

Defined in ASCII.Isomorphism

Methods

toCharList :: [char] -> [Char]

mapChars :: (Char -> Char) -> [char] -> [char]

StringSuperset string => StringIso (ASCII string)

Defined in ASCII.Refinement

Methods

toCharList :: ASCII string -> [Char]

mapChars :: (Char -> Char) -> ASCII string -> ASCII string

Quasi-quoters

char

char :: QuasiQuoter

Produces an expression or a pattern corresponding to an ASCII character.

The result will have an CharSuperset constraint; since this is polymorphic, use with a type signature to specify the particular you want is recommended.

The quasi-quoted string must consist of a single character that is within the ASCII character set.

>>> :set -XQuasiQuotes

>>> [char|e|] :: ASCII.Char
SmallLetterE

>>> [char|e|] :: Word8
101

Use in a pattern context requires enabling the ViewPatterns language extension.

>>> :set -XViewPatterns

>>> case Tilde of [char|@|] -> 1; [char|~|] -> 2; _ -> 3
2

string

string :: QuasiQuoter

Produces an expression or a pattern corresponding to an ASCII string.

The result will have an StringSuperset constraint; since this is polymorphic, use with a type signature to specify the particular you want is recommended.

The quasi-quoted string must consist only of characters are within the ASCII character set.

>>> :set -XQuasiQuotes

>>> [string|Hello!|] :: [ASCII.Char]
[CapitalLetterH,SmallLetterE,SmallLetterL,SmallLetterL,SmallLetterO,ExclamationMark]

>>> [string|Hello!|] :: Data.String.String
"Hello!"

>>> [string|Hello!|] :: Data.Text.Text
"Hello!"

>>> Data.ByteString.Builder.toLazyByteString [string|Hello!|]
"Hello!"

Use in a pattern context requires enabling the ViewPatterns language extension.

>>> :set -XViewPatterns

>>> case [CapitalLetterH, SmallLetterI] of [string|Bye|] -> 1; [string|Hi|] -> 2; _ -> 3
2