Copyright	© 2016-2017 George Steel and Peter Jurgec
License	GPL-2+
Maintainer	george.steel@gmail.com
Safe Haskell	None
Language	Haskell2010

Text.PhonotacticLearner.PhonotacticConstraints

Contents

Phonological Features
Natural Classes

Description

Data structures and functions for working with phonological features and natural classes.

Feature tables are designed work with strings reperesented as lists of SegRef indices into their internal segment lists, enabling processing with fast array lookups even with non-contiguous sets of segments.

Synopsis

Phonological Features

data FeatureState Source #

Enumeration for feature states (can be +,-,0)

Constructors

FOff
FPlus
FMinus

Instances

Enum FeatureState Source #
Methods succ :: FeatureState -> FeatureState # pred :: FeatureState -> FeatureState # toEnum :: Int -> FeatureState # fromEnum :: FeatureState -> Int # enumFrom :: FeatureState -> [FeatureState] # enumFromThen :: FeatureState -> FeatureState -> [FeatureState] # enumFromTo :: FeatureState -> FeatureState -> [FeatureState] # enumFromThenTo :: FeatureState -> FeatureState -> FeatureState -> [FeatureState] #
Eq FeatureState Source #
Methods (==) :: FeatureState -> FeatureState -> Bool # (/=) :: FeatureState -> FeatureState -> Bool #
Ord FeatureState Source #
Methods compare :: FeatureState -> FeatureState -> Ordering # (<) :: FeatureState -> FeatureState -> Bool # (<=) :: FeatureState -> FeatureState -> Bool # (>) :: FeatureState -> FeatureState -> Bool # (>=) :: FeatureState -> FeatureState -> Bool # max :: FeatureState -> FeatureState -> FeatureState # min :: FeatureState -> FeatureState -> FeatureState #
Read FeatureState Source #
Methods readsPrec :: Int -> ReadS FeatureState # readList :: ReadS [FeatureState] # readPrec :: ReadPrec FeatureState # readListPrec :: ReadPrec [FeatureState] #
Show FeatureState Source #
Methods showsPrec :: Int -> FeatureState -> ShowS # show :: FeatureState -> String # showList :: [FeatureState] -> ShowS #
NFData FeatureState Source #
Methods rnf :: FeatureState -> () #

newtype SegRef Source #

Indices for segment lookup table

Constructors

Seg Int

Instances

Eq SegRef Source #
Methods (==) :: SegRef -> SegRef -> Bool # (/=) :: SegRef -> SegRef -> Bool #
Ord SegRef Source #
Methods compare :: SegRef -> SegRef -> Ordering # (<) :: SegRef -> SegRef -> Bool # (<=) :: SegRef -> SegRef -> Bool # (>) :: SegRef -> SegRef -> Bool # (>=) :: SegRef -> SegRef -> Bool # max :: SegRef -> SegRef -> SegRef # min :: SegRef -> SegRef -> SegRef #
Read SegRef Source #
Methods readsPrec :: Int -> ReadS SegRef # readList :: ReadS [SegRef] # readPrec :: ReadPrec SegRef # readListPrec :: ReadPrec [SegRef] #
Show SegRef Source #
Methods showsPrec :: Int -> SegRef -> ShowS # show :: SegRef -> String # showList :: [SegRef] -> ShowS #
Ix SegRef Source #
Methods range :: (SegRef, SegRef) -> [SegRef] # index :: (SegRef, SegRef) -> SegRef -> Int # unsafeIndex :: (SegRef, SegRef) -> SegRef -> Int inRange :: (SegRef, SegRef) -> SegRef -> Bool # rangeSize :: (SegRef, SegRef) -> Int # unsafeRangeSize :: (SegRef, SegRef) -> Int
NFData SegRef Source #
Methods rnf :: SegRef -> () #

data FeatureTable sigma Source #

Type for phonological feature table. Segments and features are referred to by indices so this structure includes lookup tables for those.

Constructors

FeatureTable
Fields featTable :: Array (SegRef, Int) FeatureState featNames :: Array Int Text segNames :: Array SegRef sigma featLookup :: Map Text Int segLookup :: Map sigma SegRef

Instances

Eq sigma => Eq (FeatureTable sigma) Source #
Methods (==) :: FeatureTable sigma -> FeatureTable sigma -> Bool # (/=) :: FeatureTable sigma -> FeatureTable sigma -> Bool #
Show sigma => Show (FeatureTable sigma) Source #
Methods showsPrec :: Int -> FeatureTable sigma -> ShowS # show :: FeatureTable sigma -> String # showList :: [FeatureTable sigma] -> ShowS #
(Ord a, NFData a) => NFData (FeatureTable a) Source #
Methods rnf :: FeatureTable a -> () #

srBounds :: FeatureTable sigma -> (SegRef, SegRef) Source #

Bounds for segment references

ftlook :: FeatureTable sigma -> SegRef -> Int -> FeatureState Source #

Shortcut for feature table array access

segsToRefs :: Ord sigma => FeatureTable sigma -> [sigma] -> [SegRef] Source #

Convert a string of raw segments to a string of SegRefs. Skips unrecognisable segments.

refsToSegs :: FeatureTable sigma -> [SegRef] -> [sigma] Source #

Convert a string of SegRefs back to segments

csvToFeatureTable :: Ord sigma => (String -> sigma) -> String -> Maybe (FeatureTable sigma) Source #

Parse feature table from CSV.

To use a feature table other than the default IPA one, you may define it in CSV format (RFC 4180). The segment names are defined by the first row (they may be any strings as long as they are all distinct, i.e. no duplicate names) and the feature names are defined by the first column (they are not hard-coded). Data cells should contain +, -, or 0 for binary features and + or 0 for privative features (where we do not want a minus set that could form classes).

As a simple example, consider the following CSV file, defining three segments (a, n, and t), and two features (vowel and nasal).

     ,a,n,t
vowel,+,-,-
nasal,0,+,-

If a row contains a different number of cells (separated by commas) than the header line, is rejected as invalid and does not define a feature (and will not be dispayed in the formatted feature table). If the CSV which is entered has duplicate segment names, no segments, or no valid features, the entire table is rejected (indicated by a red border around the text area, green is normal) and the last valid table is used and displayed.

featureTableToCsv :: (sigma -> String) -> FeatureTable sigma -> String Source #

Cave a modified feature table to CSV format

Natural Classes

data NaturalClass Source #

Representation of a natural class as a list of features and their states. Can ahso handle inverted classes.

Constructors

NClass
Fields isInverted :: !Bool featureList :: [(FeatureState, Text)]

Instances

Eq NaturalClass Source #
Methods (==) :: NaturalClass -> NaturalClass -> Bool # (/=) :: NaturalClass -> NaturalClass -> Bool #
Ord NaturalClass Source #
Methods compare :: NaturalClass -> NaturalClass -> Ordering # (<) :: NaturalClass -> NaturalClass -> Bool # (<=) :: NaturalClass -> NaturalClass -> Bool # (>) :: NaturalClass -> NaturalClass -> Bool # (>=) :: NaturalClass -> NaturalClass -> Bool # max :: NaturalClass -> NaturalClass -> NaturalClass # min :: NaturalClass -> NaturalClass -> NaturalClass #
Read NaturalClass Source #
Methods readsPrec :: Int -> ReadS NaturalClass # readList :: ReadS [NaturalClass] # readPrec :: ReadPrec NaturalClass # readListPrec :: ReadPrec [NaturalClass] #
Show NaturalClass Source #	Uses SPE format
Methods showsPrec :: Int -> NaturalClass -> ShowS # show :: NaturalClass -> String # showList :: [NaturalClass] -> ShowS #
NFData NaturalClass Source #
Methods rnf :: NaturalClass -> () #

classToSeglist :: FeatureTable sigma -> NaturalClass -> SegSet SegRef Source #

Convert a class to a SegSet

data GlobReps Source #

Type for Glob quantifiers

Constructors

GSingle
GPlus
GStar

Instances

Enum GlobReps Source #
Methods succ :: GlobReps -> GlobReps # pred :: GlobReps -> GlobReps # toEnum :: Int -> GlobReps # fromEnum :: GlobReps -> Int # enumFrom :: GlobReps -> [GlobReps] # enumFromThen :: GlobReps -> GlobReps -> [GlobReps] # enumFromTo :: GlobReps -> GlobReps -> [GlobReps] # enumFromThenTo :: GlobReps -> GlobReps -> GlobReps -> [GlobReps] #
Eq GlobReps Source #
Methods (==) :: GlobReps -> GlobReps -> Bool # (/=) :: GlobReps -> GlobReps -> Bool #
Ord GlobReps Source #
Methods compare :: GlobReps -> GlobReps -> Ordering # (<) :: GlobReps -> GlobReps -> Bool # (<=) :: GlobReps -> GlobReps -> Bool # (>) :: GlobReps -> GlobReps -> Bool # (>=) :: GlobReps -> GlobReps -> Bool # max :: GlobReps -> GlobReps -> GlobReps # min :: GlobReps -> GlobReps -> GlobReps #
Read GlobReps Source #
Methods readsPrec :: Int -> ReadS GlobReps # readList :: ReadS [GlobReps] # readPrec :: ReadPrec GlobReps # readListPrec :: ReadPrec [GlobReps] #
Show GlobReps Source #
Methods showsPrec :: Int -> GlobReps -> ShowS # show :: GlobReps -> String # showList :: [GlobReps] -> ShowS #
NFData GlobReps Source #
Methods rnf :: GlobReps -> () #

data ClassGlob Source #

Globs using NaturalClass instead of SegSet

Constructors

ClassGlob !Bool !Bool [(GlobReps, NaturalClass)]

Instances

Eq ClassGlob Source #
Methods (==) :: ClassGlob -> ClassGlob -> Bool # (/=) :: ClassGlob -> ClassGlob -> Bool #
Ord ClassGlob Source #
Methods compare :: ClassGlob -> ClassGlob -> Ordering # (<) :: ClassGlob -> ClassGlob -> Bool # (<=) :: ClassGlob -> ClassGlob -> Bool # (>) :: ClassGlob -> ClassGlob -> Bool # (>=) :: ClassGlob -> ClassGlob -> Bool # max :: ClassGlob -> ClassGlob -> ClassGlob # min :: ClassGlob -> ClassGlob -> ClassGlob #
Read ClassGlob Source #
Methods readsPrec :: Int -> ReadS ClassGlob # readList :: ReadS [ClassGlob] # readPrec :: ReadPrec ClassGlob # readListPrec :: ReadPrec [ClassGlob] #
Show ClassGlob Source #	Uses SPE format
Methods showsPrec :: Int -> ClassGlob -> ShowS # show :: ClassGlob -> String # showList :: [ClassGlob] -> ShowS #
NFData ClassGlob Source #
Methods rnf :: ClassGlob -> () #

classesToLists :: FeatureTable sigma -> ClassGlob -> ListGlob SegRef Source #

Convert to a ListGlob

cgMatchCounter :: FeatureTable sigma -> ClassGlob -> ShortDFST SegRef Source #

Create a DFST which counts the matches of the glob.