-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Internal Phonetic Alphabet (IPA)
--   
--   See the README at <a>https://gitlab.com/ngua/ipa-hs</a>
@package ipa
@version 0.3.1


module Language.IPA.Types

-- | Textual representation of a speech segment or grouping of segments,
--   with zero or more articulatory features; encoded in IPA transcription.
--   Note this has a <a>Semigroup</a> instance, so various <a>IPA</a>s can
--   conveniently be concatenated with <tt>&lt;&gt;</tt>
newtype IPA
IPA :: Text -> IPA

-- | The <a>Text</a> value should be <a>normalize</a>d to <a>NFC</a>
[unIPA] :: IPA -> Text

-- | <a>normalize</a>s <a>Text</a> value to <a>NFC</a> before wrapping it
--   in <a>IPA</a>. This is to ensure the comparability of <a>IPA</a>
--   values
mkIPA :: Text -> IPA

-- | X-SAMPA is an ASCII encoding of the IPA (ca. 1993). Note that fewer
--   transcriptions are possible using X-SAMPA than the IPA, so certain
--   valid <a>IPA</a> <a>Segment</a>s have no direct equivalence using
--   <a>XSampa</a>. As with <a>IPA</a>, <a>XSampa</a> is an instance of
--   <a>Semigroup</a>
newtype XSampa
XSampa :: Text -> XSampa

-- | The wrapped <a>Text</a> should only contain ASCII characters
[unXSampa] :: XSampa -> Text

-- | Wraps a <a>Text</a> value in <a>XSampa</a>, provided the text only
--   contains ASCII characters
mkXSampa :: Text -> Maybe XSampa

-- | A single segment, or combination of a segment and articulatory feature
data Segment

-- | Pulmonic and non-pulmonic consonants
Consonant :: Consonant -> Segment

-- | Monoph-, diph-, and triphthongs
Vowel :: Vowel -> Segment

-- | A null/zero phone
Zero :: Segment

-- | Various other articulatory features
WithSegmentalFeature :: SegmentalFeature -> Segment -> Segment

-- | A segment that is conventionally surrounded by parentheses. This is
--   not an official part of the IPA, but is nevertheless encountered
--   fairly frequently in IPA notation in the wild
Optional :: Segment -> Segment

-- | Pulmonic and non-pulmonic consonants
data Consonant
Pulmonic :: Phonation -> Place -> Manner -> Consonant
Ejective :: Place -> Manner -> Consonant
Implosive :: Phonation -> Place -> Consonant

-- | <a>PostAlveolar</a> place represents a lateral click
Click :: Place -> Consonant
DoublyArticulated :: Phonation -> Place -> Place -> Manner -> Consonant
pattern PulmonicConsonant :: Phonation -> Place -> Manner -> Segment
pattern EjectiveConsonant :: Place -> Manner -> Segment
pattern ClickConsonant :: Place -> Segment
pattern ImplosiveConsonant :: Phonation -> Place -> Segment
pattern DoublyArticulatedConsonant :: Phonation -> Place -> Place -> Manner -> Segment

-- | Consonantal manner of articulation
data Manner
Nasal :: Manner
Plosive :: Manner
Fricative :: Sibilance -> Manner
Affricate :: Sibilance -> Manner
Approximant :: Manner
Flap :: Manner
Trill :: Manner
LateralAffricate :: Manner
LateralFricative :: Manner
LateralApproximant :: Manner
LateralFlap :: Manner

-- | Consonantal place of articulation
data Place
Bilabial :: Place
LabioDental :: Place
LinguoLabial :: Place
Dental :: Place
Alveolar :: Place
PostAlveolar :: Place
Retroflex :: Place
Palatal :: Place
Velar :: Place
Uvular :: Place
Pharyngeal :: Place
Glottal :: Place

-- | Phonation (voicing)
data Phonation
Voiced :: Phonation
Voiceless :: Phonation

-- | Sibilance for fricative consonants
data Sibilance
Sibilant :: Sibilance
NonSibilant :: Sibilance

-- | Vowel type. Note that this type does not prevent the construction of
--   nonsensical vowel values such as <tt>Diphthong (Diphthong ...)
--   (Diphthong ...)</tt>
data Vowel
Pure :: Height -> Backness -> Roundedness -> Vowel
Diphthongized :: Vowel -> Vowel -> Vowel
Triphthongized :: Vowel -> Vowel -> Vowel -> Vowel
pattern PureVowel :: Height -> Backness -> Roundedness -> Segment
pattern Diphthong :: Vowel -> Vowel -> Segment
pattern Triphthong :: Vowel -> Vowel -> Vowel -> Segment

-- | Vowel height
data Height
Close :: Height
NearClose :: Height
CloseMid :: Height
Mid :: Height
OpenMid :: Height
NearOpen :: Height
Open :: Height

-- | Vowel backness
data Backness
Front :: Backness
NearFront :: Backness
Central :: Backness
NearBack :: Backness
Back :: Backness

-- | Vowel roundedness
data Roundedness
Rounded :: Roundedness
Unrounded :: Roundedness

-- | Constraint synonym for syllable containers
type MultiSegment t = (Applicative t, Traversable t, Monoid (t Segment))

-- | Multiple segments, or combination of multiple segments with
--   suprasegmental feature
data Syllable t

-- | A grouping of segments without extra suprasegmental information
Syllable :: t Segment -> Syllable t

-- | Articulatory features that affect/encompass the entire syllable
WithSuprasegmentalFeature :: SuprasegmentalFeature -> Syllable t -> Syllable t
data SuprasegmentalFeature

-- | Level lexical tones in Chao letters
LevelLexicalTone :: LevelTone -> SuprasegmentalFeature

-- | Level lexical tones, diacritic. The tone is a combining character
LevelLexicalToneDiacritic :: LevelTone -> SuprasegmentalFeature

-- | Lexical tone contours in Chao letters
LexicalToneContour :: ToneContour -> SuprasegmentalFeature

-- | Lexical tone contours, as diacritics. Each contour is a combining
--   character
LexicalToneContourDiacritic :: ToneContour -> SuprasegmentalFeature
ToneNumber :: Int -> SuprasegmentalFeature

-- | Syllable stress
Stress :: Stress -> SuprasegmentalFeature

-- | Explicit syllable break
Break :: SuprasegmentalFeature

-- | Absence of a break
Linking :: SuprasegmentalFeature

-- | Lexical tone represented as a contour
data ToneContour
Rising :: ToneContour
Falling :: ToneContour
HighRising :: ToneContour
LowRising :: ToneContour
HighFalling :: ToneContour
LowFalling :: ToneContour
RisingFalling :: ToneContour
FallingRising :: ToneContour
GlobalRise :: ToneContour
GlobalFall :: ToneContour

-- | Lexical tone with Chao-style tone letters
data LevelTone
ExtraHighTone :: LevelTone
HighTone :: LevelTone
MidTone :: LevelTone
LowTone :: LevelTone
ExtraLowTone :: LevelTone
DownStep :: LevelTone
UpStep :: LevelTone
data Stress
Primary :: Stress
Secondary :: Stress

-- | Vowel length; also serves as a notation for consonant gemination in
--   the IPA
data Length
OverLong :: Length
HalfLong :: Length
Long :: Length

-- | The default/unmarked length; using this constructor doesn't affect the
--   default IPA representation of the segment
Short :: Length
ExtraShort :: Length

-- | Various articulatory features with a diacritic represenation in the
--   IPA. These can be combined with <a>Segment</a>s using the
--   <a>WithSegmentalFeature</a> constructor of that type to produce a
--   <a>Segment</a> annotated with a given articulatory feature, e.g.:
--   
--   <pre>
--   &gt;&gt;&gt; toIPA $ WithSegmentalFeature (Length Long) (Vowel Close Front Unrounded)
--   Just (IPA "i\720") -- iː
--   </pre>
data SegmentalFeature
Voicing :: Phonation -> SegmentalFeature
Length :: Length -> SegmentalFeature
SecondaryArticulation :: Segment -> SegmentalFeature
Aspirated :: SegmentalFeature
MoreRounded :: SegmentalFeature
LessRounded :: SegmentalFeature
Advanced :: SegmentalFeature
Retracted :: SegmentalFeature
Centralized :: SegmentalFeature
MidCentralized :: SegmentalFeature
Compressed :: SegmentalFeature
Syllabic :: SegmentalFeature
NonSyllabic :: SegmentalFeature
Rhotacized :: SegmentalFeature
BreathyVoice :: SegmentalFeature
CreakyVoice :: SegmentalFeature
LinguoLabialized :: SegmentalFeature
Labialized :: SegmentalFeature
Palatalized :: SegmentalFeature
Velarized :: SegmentalFeature
Pharyngealized :: SegmentalFeature
Raised :: SegmentalFeature
Lowered :: SegmentalFeature
AdvancedTongueRoot :: SegmentalFeature
RetractedTongueRoot :: SegmentalFeature
Dentalized :: SegmentalFeature
Apical :: SegmentalFeature
Laminal :: SegmentalFeature
Nasalized :: SegmentalFeature
NasalRelease :: SegmentalFeature
LateralRelease :: SegmentalFeature
NoAudibleRelease :: SegmentalFeature

-- | Transcription delimiters/brackets
data Delimiter

-- | Actual pronunciation, transcribed with square brackets, [ .. ]
Phonetic :: Delimiter

-- | Abstract phonemic representation, transcribed with slashes, / .. /
Phonemic :: Delimiter
data IPAException
InvalidIPA :: Text -> IPAException
InvalidXSampa :: Text -> IPAException
instance GHC.Base.Semigroup Language.IPA.Types.IPA
instance GHC.Generics.Generic Language.IPA.Types.IPA
instance GHC.Classes.Eq Language.IPA.Types.IPA
instance GHC.Show.Show Language.IPA.Types.IPA
instance GHC.Base.Semigroup Language.IPA.Types.XSampa
instance GHC.Generics.Generic Language.IPA.Types.XSampa
instance GHC.Classes.Eq Language.IPA.Types.XSampa
instance GHC.Show.Show Language.IPA.Types.XSampa
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Place
instance Data.Data.Data Language.IPA.Types.Place
instance GHC.Classes.Ord Language.IPA.Types.Place
instance GHC.Generics.Generic Language.IPA.Types.Place
instance GHC.Classes.Eq Language.IPA.Types.Place
instance GHC.Show.Show Language.IPA.Types.Place
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Phonation
instance Data.Data.Data Language.IPA.Types.Phonation
instance GHC.Generics.Generic Language.IPA.Types.Phonation
instance GHC.Classes.Eq Language.IPA.Types.Phonation
instance GHC.Show.Show Language.IPA.Types.Phonation
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Sibilance
instance Data.Data.Data Language.IPA.Types.Sibilance
instance GHC.Generics.Generic Language.IPA.Types.Sibilance
instance GHC.Classes.Eq Language.IPA.Types.Sibilance
instance GHC.Show.Show Language.IPA.Types.Sibilance
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Manner
instance Data.Data.Data Language.IPA.Types.Manner
instance GHC.Generics.Generic Language.IPA.Types.Manner
instance GHC.Classes.Eq Language.IPA.Types.Manner
instance GHC.Show.Show Language.IPA.Types.Manner
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Consonant
instance Data.Data.Data Language.IPA.Types.Consonant
instance GHC.Generics.Generic Language.IPA.Types.Consonant
instance GHC.Classes.Eq Language.IPA.Types.Consonant
instance GHC.Show.Show Language.IPA.Types.Consonant
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Height
instance Data.Data.Data Language.IPA.Types.Height
instance GHC.Generics.Generic Language.IPA.Types.Height
instance GHC.Classes.Eq Language.IPA.Types.Height
instance GHC.Show.Show Language.IPA.Types.Height
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Backness
instance Data.Data.Data Language.IPA.Types.Backness
instance GHC.Classes.Ord Language.IPA.Types.Backness
instance GHC.Generics.Generic Language.IPA.Types.Backness
instance GHC.Classes.Eq Language.IPA.Types.Backness
instance GHC.Show.Show Language.IPA.Types.Backness
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Roundedness
instance Data.Data.Data Language.IPA.Types.Roundedness
instance GHC.Generics.Generic Language.IPA.Types.Roundedness
instance GHC.Classes.Eq Language.IPA.Types.Roundedness
instance GHC.Show.Show Language.IPA.Types.Roundedness
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Vowel
instance Data.Data.Data Language.IPA.Types.Vowel
instance GHC.Generics.Generic Language.IPA.Types.Vowel
instance GHC.Classes.Eq Language.IPA.Types.Vowel
instance GHC.Show.Show Language.IPA.Types.Vowel
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.LevelTone
instance Data.Data.Data Language.IPA.Types.LevelTone
instance GHC.Classes.Ord Language.IPA.Types.LevelTone
instance GHC.Generics.Generic Language.IPA.Types.LevelTone
instance GHC.Classes.Eq Language.IPA.Types.LevelTone
instance GHC.Show.Show Language.IPA.Types.LevelTone
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.ToneContour
instance Data.Data.Data Language.IPA.Types.ToneContour
instance GHC.Classes.Ord Language.IPA.Types.ToneContour
instance GHC.Generics.Generic Language.IPA.Types.ToneContour
instance GHC.Classes.Eq Language.IPA.Types.ToneContour
instance GHC.Show.Show Language.IPA.Types.ToneContour
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Length
instance Data.Data.Data Language.IPA.Types.Length
instance GHC.Classes.Ord Language.IPA.Types.Length
instance GHC.Generics.Generic Language.IPA.Types.Length
instance GHC.Classes.Eq Language.IPA.Types.Length
instance GHC.Show.Show Language.IPA.Types.Length
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Segment
instance Data.Data.Data Language.IPA.Types.Segment
instance GHC.Generics.Generic Language.IPA.Types.Segment
instance GHC.Classes.Eq Language.IPA.Types.Segment
instance GHC.Show.Show Language.IPA.Types.Segment
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.SegmentalFeature
instance Data.Data.Data Language.IPA.Types.SegmentalFeature
instance GHC.Generics.Generic Language.IPA.Types.SegmentalFeature
instance GHC.Classes.Eq Language.IPA.Types.SegmentalFeature
instance GHC.Show.Show Language.IPA.Types.SegmentalFeature
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.Stress
instance Data.Data.Data Language.IPA.Types.Stress
instance GHC.Classes.Ord Language.IPA.Types.Stress
instance GHC.Generics.Generic Language.IPA.Types.Stress
instance GHC.Classes.Eq Language.IPA.Types.Stress
instance GHC.Show.Show Language.IPA.Types.Stress
instance Language.Haskell.TH.Syntax.Lift Language.IPA.Types.SuprasegmentalFeature
instance Data.Data.Data Language.IPA.Types.SuprasegmentalFeature
instance GHC.Generics.Generic Language.IPA.Types.SuprasegmentalFeature
instance GHC.Classes.Eq Language.IPA.Types.SuprasegmentalFeature
instance GHC.Show.Show Language.IPA.Types.SuprasegmentalFeature
instance GHC.Generics.Generic (Language.IPA.Types.Syllable t)
instance GHC.Generics.Generic Language.IPA.Types.Delimiter
instance GHC.Classes.Eq Language.IPA.Types.Delimiter
instance GHC.Show.Show Language.IPA.Types.Delimiter
instance GHC.Generics.Generic Language.IPA.Types.IPAException
instance GHC.Classes.Eq Language.IPA.Types.IPAException
instance GHC.Show.Show Language.IPA.Types.IPAException
instance GHC.Show.Show (t Language.IPA.Types.Segment) => GHC.Show.Show (Language.IPA.Types.Syllable t)
instance GHC.Classes.Eq (t Language.IPA.Types.Segment) => GHC.Classes.Eq (Language.IPA.Types.Syllable t)
instance (Data.Data.Data (t Language.IPA.Types.Segment), Data.Typeable.Internal.Typeable t) => Data.Data.Data (Language.IPA.Types.Syllable t)
instance Language.Haskell.TH.Syntax.Lift (t Language.IPA.Types.Segment) => Language.Haskell.TH.Syntax.Lift (Language.IPA.Types.Syllable t)
instance GHC.Exception.Type.Exception Language.IPA.Types.IPAException


-- | Parser for IPA literals
module Language.IPA.Parser

-- | Parse a single literal segment in IPA notation, returning
--   <a>InvalidIPA</a> upon failure and a <a>Segment</a> upon success. Note
--   that supplying two or more segment literals will cause the parse to
--   fail
--   
--   <pre>
--   &gt;&gt;&gt; parseSegment "ɨːː"
--   Right (WithSegmentalFeature (Length OverLong) (Vowel Close Central Unrounded))
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseSegment "ɨːːb"
--   Left (InvalidIPA "Failed to parse character 'b'")
--   </pre>
parseSegment :: Text -> Either IPAException Segment

-- | Parser for segments. This function is exposed to allow users to create
--   more specific parsers for multi-segment sequences
segmentP :: Parser Segment

-- | Parse a literal syllable in IPA notation, returning <a>InvalidIPA</a>
--   upon failure and a <a>Syllable</a> upon success, where the syllable is
--   parameterized by some type <tt>t</tt> satisfying a <a>MultiSegment</a>
--   constraint. Note that, as with <a>parseSegment</a>, supplying two or
--   more syllable literals will cause the parse to fail
--   
--   <pre>
--   &gt;&gt;&gt; parseSyllable @[] "ma˧˥"
--   Right (WithSuprasegmentalFeature (LexicalToneContour HighRising)
--         (Syllable [Consonant (Pulmonic Voiced Bilabial Nasal),Vowel Open Front Unrounded]))
--   </pre>
parseSyllable :: MultiSegment t => Text -> Either IPAException (Syllable t)

-- | Parser for syllables. This function is exposed to allow users to
--   create more specific parsers for aggregations of multiple syllables
syllableP :: MultiSegment t => Parser (Syllable t)

-- | Parse several syllables into a container parameterized by the same
--   type as that parameterizing the individual <a>Syllable</a>s.
--   Whitespace between syllables is interpreted as a syllable boundary
--   
--   <pre>
--   &gt;&gt;&gt; parseSyllables @[] "haːj˧ ɓaː˧"
--   Right [ WithSuprasegmentalFeature (LevelLexicalTone MidTone)
--             (Syllable [ Consonant (Pulmonic Voiceless Glottal (Fricative NonSibilant))
--                       , WithSegmentalFeature (Length Long) (Vowel Open Front Unrounded)
--                       , Consonant (Pulmonic Voiced Palatal Approximant)
--                       ])
--         , WithSuprasegmentalFeature (LevelLexicalTone MidTone)
--             (Syllable [ Consonant (Implosive Voiced Bilabial)
--                       , WithSegmentalFeature (Length Long) (Vowel Open Front Unrounded)
--                       ])
--         ]
--   </pre>
parseSyllables :: (MultiSegment t, Monoid (t (Syllable t))) => Text -> Either IPAException (t (Syllable t))

-- | Parser for poly-syllabic sequences, with individual syllables
--   separated by (optional) whitespace
syllablesP :: (MultiSegment t, Monoid (t (Syllable t))) => Parser (t (Syllable t))

-- | As <a>parseSegment</a>, but in X-SAMPA notation
parseSegmentXSampa :: Text -> Either IPAException Segment

-- | As <a>segmentP</a>, but in X-SAMPA notation
segmentXSampaP :: Parser Segment

-- | As <a>parseSyllable</a>, but in X-SAMPA notation
parseSyllableXSampa :: MultiSegment t => Text -> Either IPAException (Syllable t)

-- | As <a>parseSyllables</a>, but in X-SAMPA notation
parseSyllablesXSampa :: (MultiSegment t, Monoid (t (Syllable t))) => Text -> Either IPAException (t (Syllable t))

-- | As <a>syllableP</a>, but in X-SAMPA notation
syllableXSampaP :: MultiSegment t => Parser (Syllable t)


module Language.IPA.QQ

-- | Construct a compile-time <a>Syllable</a> using IPA notation
--   
--   <pre>
--   &gt;&gt;&gt; [syllable|ɣa˧˨|]
--   WithSuprasegmentalFeature (LexicalToneContour LowFalling)
--     (Syllable [ Consonant (Pulmonic Voiced Velar (Fricative NonSibilant))
--               , Vowel (Pure Open Front Unrounded)
--               ])
--   </pre>
syllable :: QuasiQuoter

-- | Construct a compile-time <a>Segment</a> using IPA notation
--   
--   <pre>
--   &gt;&gt;&gt; [segment|ɣ|]
--   Consonant (Pulmonic Voiced Velar (Fricative NonSibilant))
--   </pre>
segment :: QuasiQuoter

-- | Construct a compile-time <tt>[<a>Syllable</a>]</tt> using IPA notation
syllables :: QuasiQuoter

-- | Construct a compile-time <a>Segment</a> using X-SAMPA notation. This
--   may be more convenient than using text values - X-SAMPA inexplicably
--   chose to use backslashes as semantic tokens, which of course must be
--   escaped
--   
--   <pre>
--   &gt;&gt;&gt; [segmentXS|?\|]
--   Consonant (Pulmonic Voiced Pharyngeal (Fricative NonSibilant))
--   </pre>
segmentXS :: QuasiQuoter

-- | Construct a compile-time <a>Syllable</a> using X-SAMPA notation
syllableXS :: QuasiQuoter

-- | Construct a compile-time <tt>[<a>Syllable</a>]</tt> using X-SAMPA
--   notation
syllablesXS :: QuasiQuoter


-- | Typeclass for representing speech sounds in IPA/X-Sampa notation
module Language.IPA.Class

-- | Entities representable through IPA transcription
class ReprIPA a

-- | Produces an <a>IPA</a> transcription given a valid <a>Segment</a>; a
--   result of <tt>Nothing</tt> indicates either an unattested-yet-possible
--   segment, or one considered impossible
toIPA :: ReprIPA a => a -> Maybe IPA

-- | Parse text in IPA notation
parseIPA :: ReprIPA a => Text -> Either IPAException a

-- | Entities representable through X-SAMPA transcription, an ASCII subset
--   of the IPA
class ReprXSampa a

-- | Similar to <a>toIPA</a>; produces an <a>XSampa</a> transcription given
--   a valid <a>Segment</a>.
toXSampa :: ReprXSampa a => a -> Maybe XSampa

-- | Parse text in X-SAMPA notation
parseXSampa :: ReprXSampa a => Text -> Either IPAException a
instance Language.IPA.Types.MultiSegment t => Language.IPA.Class.ReprXSampa (Language.IPA.Types.Syllable t)
instance Language.IPA.Class.ReprXSampa Language.IPA.Types.Segment
instance Language.IPA.Types.MultiSegment t => Language.IPA.Class.ReprIPA (Language.IPA.Types.Syllable t)
instance Language.IPA.Class.ReprIPA Language.IPA.Types.Segment


-- | Working with IPA/X-SAMPA transcriptions and phonetic/phonemic values
module Language.IPA

-- | "Transcribe" an <a>IPA</a> value by wrapping it in a <a>Delimiter</a>
--   
--   <pre>
--   &gt;&gt;&gt; s = PulmonicConsonant Voiced Dental (Fricative NonSibilant)
--   
--   &gt;&gt;&gt; transcribe Phonemic &lt;$&gt; toIPA s
--   Just "/ð/"
--   </pre>
transcribe :: Delimiter -> IPA -> Text

-- | As <a>transcribe</a>, for <a>XSampa</a> values
transcribeXSampa :: Delimiter -> XSampa -> Text

-- | Convert an <a>IPA</a> value to its equivalent in <a>XSampa</a>; note
--   that several features and segments that can be transcribed in IPA
--   notation are missing from X-SAMPA
ipaToXSampa :: IPA -> Maybe XSampa

-- | Convert an <a>XSampa</a> value to its equivalent in <a>IPA</a>
xSampaToIpa :: XSampa -> Maybe IPA

-- | Partial function for creating an <a>IPA</a>. Useful if you are certain
--   that the sound in question is representable
toIPA' :: ReprIPA a => a -> IPA

-- | Partial function for creating an <a>XSampa</a>. NB: Certain segments
--   that have a defined <a>IPA</a> representation have no <a>XSampa</a>
--   equivalent
toXSampa' :: ReprXSampa a => a -> XSampa

-- | Does a text value in IPA notation represent a valid instance of
--   <a>ReprIPA</a>? Note that you will need <tt>-XTypeApplications</tt> to
--   use this, and that this just calls <a>parseIPA</a> to determine
--   validity
--   
--   <pre>
--   &gt;&gt;&gt; isValid @Segment "L"
--   False
--   
--   &gt;&gt;&gt; isValid @Segment "ʟ"
--   True
--   </pre>
isValid :: forall a. ReprIPA a => Text -> Bool

-- | Does a text value represent valid individual IPA <a>Segment</a>?
isValidSegment :: Text -> Bool

-- | Is a text value a valid IPA <a>Syllable</a>?
isValidSyllable :: Text -> Bool

-- | Tests if a <a>Segment</a> is obstruent, i.e. formed by obstructing
--   airflow
isObstruent :: Segment -> Bool

-- | Tests if <a>Segment</a> is sonorant, i.e. if it is created with an
--   uninterrupted flow of air
isSonorant :: Segment -> Bool

-- | Tests pulmonic <a>Consonant</a> membership in the labial category,
--   whose active articulator is one or both lips
isLabial :: Consonant -> Bool

-- | Tests pulmonic <a>Consonant</a> membership in the coronal class, whose
--   active articulator is the front of the tongue
isCoronal :: Consonant -> Bool

-- | Tests pulmonic <a>Consonant</a> membership in the dorsal class, whose
--   active articulator is the dorsum (back of the tongue)
isDorsal :: Consonant -> Bool

-- | Tests pulmonic <a>Consonant</a> membership in the laryngeal class,
--   whose active articulator is the larynx
isLaryngeal :: Consonant -> Bool

-- | Tests if <a>Consonant</a> is rhotic, a vague category of R-like sounds
--   typically represented lexicographically by some variant of the Latin
--   letter r
isRhotic :: Consonant -> Bool

-- | Tests if a <a>Consonant</a> is liquid, a category of rhotics and
--   voiced lateral approximants
isLiquid :: Consonant -> Bool