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


-- | Encoding character data
--   
--   The <a>Encode</a> library provides a unified interface for converting
--   strings from different encodings into a common representation, and
--   vice versa. This representation is isomorphic to the Unicode character
--   set, and the encodings can be both standard and user-defined. For this
--   purpose, the <a>Encode</a> module defines the <a>Encode.UPoint</a>
--   data type and the <a>Encode.Encoding</a> type class with the
--   <a>encode</a> and <a>decode</a> methods.
--   
--   The <a>Encode</a> library is being proposed as a Haskell analogy to
--   the <i>Encode</i> extension in Perl,
--   <a>http://search.cpan.org/dist/Encode/</a>.
--   
--   The <a>Main.Encode</a> and <a>Main.Decode</a> programs mimick the
--   function calls to <a>encode</a> and <a>decode</a>, respectively, with
--   the following usage:
--   
--   <pre>
--   decode ArabTeX &lt; decode.d | encode Buckwalter &gt; encode.d
--   
--   decode MacArabic &lt; data.MacArabic &gt; data.UTF8
--   
--   encode WinArabic &lt; data.UTF8 &gt; data.WinArabic
--   </pre>
--   
--   The installation instructions are given in <a>INSTALL</a>. For the
--   list of supported encoding schemes, please refer to <a>Encode</a> and
--   the source files of the programs. With the executables, the naming of
--   encodings is <i>case-insensitive</i> and some further options are
--   allowed:
--   
--   <pre>
--   encode|decode [--OPTIONS] [ENCODING]
--     -h       --help         show usage information
--     -l       --lines        use line-oriented mode
--     -p text  --prefix=text  prefix input with text
--     -s text  --suffix=text  suffix input with text
--     -v       --version      show program's version
--   </pre>
--   
--   The <a>PureFP</a> library is an edited excerpt from the <i>Functional
--   Parsing</i> library developed by Peter Ljunglöf in his licenciate
--   thesis <i>Pure Functional Parsing – an advanced tutorial</i>, Göteborg
--   University and Chalmers University of Technology, April 2002,
--   <a>http://code.google.com/p/haskell-functional-parsing/</a>.
--   
--   <a>Encode</a> <a>PureFP</a>
@package Encode
@version 1.3.8


-- | Chapter 1 and Appendix A of /Pure Functional Parsing – an advanced
--   tutorial/ by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
module PureFP.OrdSet
class OrdSet m where xs <++> ys = fst (plusMinus xs ys) xs <\\> ys = snd (plusMinus xs ys) plusMinus xs ys = (xs <++> ys, xs <\\> ys) union [] = emptySet union [xs] = xs union xyss = union xss <++> union yss where (xss, yss) = split xyss split (x : y : xyss) = let (xs, ys) = split xyss in (x : xs, y : ys) split xs = (xs, []) makeSet xs = union (map unitSet xs) limit more start = limit' (start, start) where limit' (old, new) | isEmpty new' = old | otherwise = limit' (plusMinus new' old) where new' = union (map more (elems new))
emptySet :: (OrdSet m, Ord a) => m a
unitSet :: (OrdSet m, Ord a) => a -> m a
isEmpty :: (OrdSet m, Ord a) => m a -> Bool
elemSet :: (OrdSet m, Ord a) => a -> m a -> Bool
(<++>) :: (OrdSet m, Ord a) => m a -> m a -> m a
(<\\>) :: (OrdSet m, Ord a) => m a -> m a -> m a
plusMinus :: (OrdSet m, Ord a) => m a -> m a -> (m a, m a)
union :: (OrdSet m, Ord a) => [m a] -> m a
makeSet :: (OrdSet m, Ord a) => [a] -> m a
elems :: (OrdSet m, Ord a) => m a -> [a]
ordSet :: (OrdSet m, Ord a) => [a] -> m a
limit :: (OrdSet m, Ord a) => (a -> m a) -> m a -> m a
data Set a
instance GHC.Classes.Eq a => GHC.Classes.Eq (PureFP.OrdSet.Set a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (PureFP.OrdSet.Set a)
instance GHC.Show.Show a => GHC.Show.Show (PureFP.OrdSet.Set a)
instance PureFP.OrdSet.OrdSet PureFP.OrdSet.Set


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
module PureFP.Parsers.Parser
class Parser m s | m -> s where parseFull p inp = [a | ([], a) <- parse p inp]
parse :: Parser m s => m a -> [s] -> [([s], a)]
parseFull :: Parser m s => m a -> [s] -> [a]
class Monoid' m where anyof = foldr (<+>) zero
zero :: Monoid' m => m a
(<+>) :: Monoid' m => m a -> m a -> m a
anyof :: Monoid' m => [m a] -> m a
class (Monad m, Functor m) => Sequence m where p </> q = p >>= \ f -> fmap f q p /> q = fmap (\ x y -> y) p </> q
(</>) :: Sequence m => m (a -> b) -> m a -> m b
(/>) :: Sequence m => m a -> m b -> m b
class Eq s => Symbol m s | m -> s where sym s = sat (s ==) skip = sat (\ x -> True)
sym :: Symbol m s => s -> m s
sat :: Symbol m s => (s -> Bool) -> m s
skip :: Symbol m s => m s
class Ord s => InputSymbol s
minSym :: InputSymbol s => s
maxSym :: InputSymbol s => s
symbols :: InputSymbol s => [s]
class Eq s => SymbolCont m s | m -> s
satCont :: SymbolCont m s => (s -> Bool) -> (s -> m a) -> m a
class Lookahead m s | m -> s
lookahead :: Lookahead m s => ([s] -> m a) -> m a
success :: Monad m => m ()
many0 :: (Monoid' m, Sequence m) => m a -> m ()
syms0 :: (Sequence m, Symbol m s) => [s] -> m ()
(<:>) :: Sequence m => m a -> m [a] -> m [a]
many :: (Monoid' m, Sequence m) => m a -> m [a]
syms :: (Sequence m, Symbol m s) => [s] -> m [s]
instance PureFP.Parsers.Parser.InputSymbol GHC.Types.Char
instance PureFP.Parsers.Parser.InputSymbol GHC.Types.Int


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
module PureFP.Parsers.Standard
newtype Standard s a
Std :: ([s] -> [([s], a)]) -> Standard s a
instance Control.Monad.State.Class.MonadState [s] (PureFP.Parsers.Standard.Standard s)
instance PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.Standard.Standard s)
instance GHC.Base.Applicative (PureFP.Parsers.Standard.Standard s)
instance GHC.Base.Monad (PureFP.Parsers.Standard.Standard s)
instance GHC.Base.Functor (PureFP.Parsers.Standard.Standard s)
instance PureFP.Parsers.Parser.Sequence (PureFP.Parsers.Standard.Standard s)
instance GHC.Classes.Eq s => PureFP.Parsers.Parser.Symbol (PureFP.Parsers.Standard.Standard s) s
instance GHC.Classes.Eq s => PureFP.Parsers.Parser.SymbolCont (PureFP.Parsers.Standard.Standard s) s
instance PureFP.Parsers.Parser.Parser (PureFP.Parsers.Standard.Standard s) s
instance PureFP.Parsers.Parser.Lookahead (PureFP.Parsers.Standard.Standard s) s


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
--   
--   <a>http://hackage.haskell.org/package/parsek</a>
--   
--   <a>Text.ParserCombinators.Parsek</a>
module PureFP.Parsers.Stream
data Stream s a
instance PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.Stream.Stream s)
instance GHC.Base.Applicative (PureFP.Parsers.Stream.Stream s)
instance GHC.Base.Monad (PureFP.Parsers.Stream.Stream s)
instance GHC.Base.Functor (PureFP.Parsers.Stream.Stream s)
instance PureFP.Parsers.Parser.Sequence (PureFP.Parsers.Stream.Stream s)
instance GHC.Classes.Eq s => PureFP.Parsers.Parser.Symbol (PureFP.Parsers.Stream.Stream s) s
instance GHC.Classes.Eq s => PureFP.Parsers.Parser.SymbolCont (PureFP.Parsers.Stream.Stream s) s
instance PureFP.Parsers.Parser.Parser (PureFP.Parsers.Stream.Stream s) s


-- | Chapter 1 and Appendix A of /Pure Functional Parsing – an advanced
--   tutorial/ by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
module PureFP.OrdMap
class OrdMap m where lookupWith z m s = case m ? s of { Just a -> a Nothing -> z } unionMapWith join = union where union [] = emptyMap union [xs] = xs union xyss = mergeWith join (union xss) (union yss) where (xss, yss) = split xyss split (x : y : xyss) = let (xs, ys) = split xyss in (x : xs, y : ys) split xs = (xs, [])
emptyMap :: (OrdMap m, Ord s) => m s a
(|->) :: (OrdMap m, Ord s) => s -> a -> m s a
isEmptyMap :: (OrdMap m, Ord s) => m s a -> Bool
(?) :: (OrdMap m, Ord s) => m s a -> s -> Maybe a
lookupWith :: (OrdMap m, Ord s) => a -> m s a -> s -> a
mergeWith :: (OrdMap m, Ord s) => (a -> a -> a) -> m s a -> m s a -> m s a
unionMapWith :: (OrdMap m, Ord s) => (a -> a -> a) -> [m s a] -> m s a
assocs :: (OrdMap m, Ord s) => m s a -> [(s, a)]
ordMap :: (OrdMap m, Ord s) => [(s, a)] -> m s a
mapMap :: (OrdMap m, Ord s) => (a -> b) -> m s a -> m s b
data Map s a
makeMapWith :: (Ord s, OrdMap m) => (a -> a -> a) -> [(s, a)] -> m s a
mapMapWithKey :: (s -> t -> a) -> Map s t -> Map s a
instance (GHC.Classes.Eq s, GHC.Classes.Eq a) => GHC.Classes.Eq (PureFP.OrdMap.Map s a)
instance (GHC.Show.Show s, GHC.Show.Show a) => GHC.Show.Show (PureFP.OrdMap.Map s a)
instance PureFP.OrdMap.OrdMap PureFP.OrdMap.Map


-- | <a>Encode.Extend</a>
module Encode.ExPlus
class ExtEnv e
initEnv :: ExtEnv e => e i
type Extend e s = StateT [e s] (Standard s)
inspectIList :: Extend e s [s]
returnIList :: [s] -> Extend e s [s]
inspectEList :: Extend e s [e s]
returnEList :: [e s] -> Extend e s [e s]
inspectEnv :: Extend e s (e s)
resetEnv :: (a -> e s -> e s) -> a -> Extend e s (e s)
oneof :: (Ord s, Symbol m s) => [Map s a] -> m s
lower :: (Ord s) => [s] -> [s] -> Extend e s [s]
upper :: (OrdMap m, Ord s) => [s] -> [m s [c]] -> Extend e d ([c] -> [c])
upperWith :: (s -> m -> e d -> [[c]]) -> [s] -> m -> Extend e d ([c] -> [c])
oneof' :: (Ord [s], Symbol m [s], Eq s, Monad m) => s -> [Map [s] a] -> m [s]
(<|>) :: Extend e s a -> Extend e s a -> Extend e s a
again :: Extend e s a -> Extend e s [a]
lookupList :: (OrdMap m, Ord s) => s -> [m s a] -> [a]
instance PureFP.Parsers.Parser.Monoid' (Encode.ExPlus.Extend e s)
instance PureFP.Parsers.Parser.Sequence (Encode.ExPlus.Extend e s)
instance GHC.Classes.Eq s => PureFP.Parsers.Parser.Symbol (Encode.ExPlus.Extend e s) s
instance Encode.ExPlus.ExtEnv e => PureFP.Parsers.Parser.Parser (Encode.ExPlus.Extend e s) s


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
module PureFP.Parsers.Trie
data Trie s a
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.Trie.Trie s)
instance GHC.Classes.Ord s => GHC.Base.Applicative (PureFP.Parsers.Trie.Trie s)
instance GHC.Classes.Ord s => GHC.Base.Monad (PureFP.Parsers.Trie.Trie s)
instance GHC.Classes.Ord s => GHC.Base.Functor (PureFP.Parsers.Trie.Trie s)
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Sequence (PureFP.Parsers.Trie.Trie s)
instance PureFP.Parsers.Parser.InputSymbol s => PureFP.Parsers.Parser.Symbol (PureFP.Parsers.Trie.Trie s) s
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Parser (PureFP.Parsers.Trie.Trie s) s


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
module PureFP.Parsers.AmbTrie
data AmbTrie s a
(:&:) :: [a] -> Map s (AmbTrie s a) -> AmbTrie s a
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.AmbTrie.AmbTrie s)
instance GHC.Classes.Ord s => GHC.Base.Applicative (PureFP.Parsers.AmbTrie.AmbTrie s)
instance GHC.Classes.Ord s => GHC.Base.Monad (PureFP.Parsers.AmbTrie.AmbTrie s)
instance GHC.Classes.Ord s => GHC.Base.Functor (PureFP.Parsers.AmbTrie.AmbTrie s)
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Sequence (PureFP.Parsers.AmbTrie.AmbTrie s)
instance PureFP.Parsers.Parser.InputSymbol s => PureFP.Parsers.Parser.Symbol (PureFP.Parsers.AmbTrie.AmbTrie s) s
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Parser (PureFP.Parsers.AmbTrie.AmbTrie s) s


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
module PureFP.Parsers.ExTrie
data ExTrie s a
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.ExTrie.ExTrie s)
instance GHC.Classes.Ord s => GHC.Base.Applicative (PureFP.Parsers.ExTrie.ExTrie s)
instance GHC.Classes.Ord s => GHC.Base.Monad (PureFP.Parsers.ExTrie.ExTrie s)
instance GHC.Classes.Ord s => GHC.Base.Functor (PureFP.Parsers.ExTrie.ExTrie s)
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Sequence (PureFP.Parsers.ExTrie.ExTrie s)
instance PureFP.Parsers.Parser.InputSymbol s => PureFP.Parsers.Parser.Symbol (PureFP.Parsers.ExTrie.ExTrie s) s
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Parser (PureFP.Parsers.ExTrie.ExTrie s) s


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
module PureFP.Parsers.AmbExTrie
data AmbExTrie s a
(:&:) :: [a] -> Map s (AmbExTrie s a) -> AmbExTrie s a
FMap :: (b -> a) -> (AmbExTrie s b) -> AmbExTrie s a
unfold :: Ord s => (a -> b) -> AmbExTrie s a -> AmbExTrie s b
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.AmbExTrie.AmbExTrie s)
instance GHC.Classes.Ord s => GHC.Base.Applicative (PureFP.Parsers.AmbExTrie.AmbExTrie s)
instance GHC.Classes.Ord s => GHC.Base.Monad (PureFP.Parsers.AmbExTrie.AmbExTrie s)
instance GHC.Classes.Ord s => GHC.Base.Functor (PureFP.Parsers.AmbExTrie.AmbExTrie s)
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Sequence (PureFP.Parsers.AmbExTrie.AmbExTrie s)
instance PureFP.Parsers.Parser.InputSymbol s => PureFP.Parsers.Parser.Symbol (PureFP.Parsers.AmbExTrie.AmbExTrie s) s
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Parser (PureFP.Parsers.AmbExTrie.AmbExTrie s) s


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
module PureFP.Parsers.PairTrie
data PairTrie m s a
data ParserTrie s a
instance (GHC.Classes.Ord s, PureFP.Parsers.Parser.Monoid' m, PureFP.Parsers.Parser.Lookahead m s) => PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.PairTrie.PairTrie m s)
instance (GHC.Classes.Ord s, GHC.Base.Monad m, GHC.Base.Applicative m) => GHC.Base.Applicative (PureFP.Parsers.PairTrie.PairTrie m s)
instance (GHC.Classes.Ord s, GHC.Base.Monad m, GHC.Base.Applicative m) => GHC.Base.Monad (PureFP.Parsers.PairTrie.PairTrie m s)
instance (GHC.Classes.Ord s, GHC.Base.Functor m) => GHC.Base.Functor (PureFP.Parsers.PairTrie.PairTrie m s)
instance (GHC.Classes.Ord s, PureFP.Parsers.Parser.Monoid' m, PureFP.Parsers.Parser.Sequence m, GHC.Base.Applicative m, PureFP.Parsers.Parser.Lookahead m s) => PureFP.Parsers.Parser.Sequence (PureFP.Parsers.PairTrie.PairTrie m s)
instance (PureFP.Parsers.Parser.InputSymbol s, PureFP.Parsers.Parser.Monoid' m, PureFP.Parsers.Parser.Symbol m s, PureFP.Parsers.Parser.Lookahead m s) => PureFP.Parsers.Parser.Symbol (PureFP.Parsers.PairTrie.PairTrie m s) s
instance (GHC.Classes.Ord s, PureFP.Parsers.Parser.Parser m s) => PureFP.Parsers.Parser.Parser (PureFP.Parsers.PairTrie.PairTrie m s) s
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Monoid' (PureFP.Parsers.PairTrie.ParserTrie s)
instance GHC.Classes.Ord s => GHC.Base.Functor (PureFP.Parsers.PairTrie.ParserTrie s)
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Parser (PureFP.Parsers.PairTrie.ParserTrie s) s


-- | Chapters 3 and 4 of <i>Pure Functional Parsing – an advanced
--   tutorial</i> by Peter Ljunglöf
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
--   
--   With this limited distribution, you can create only some of the
--   parsers described in the thesis. These include in particular:
--   
--   <ul>
--   <li><i><a>Standard</a> <tt>s</tt></i> <a>PureFP.Parsers.Standard</a>,
--   the standard parser, sec. 3.2</li>
--   <li><i><a>Stream</a> <tt>s</tt></i> <a>PureFP.Parsers.Stream</a>, the
--   stream processor parser, sec. 3.5.2</li>
--   <li><i><a>Trie</a> <tt>s</tt></i> <a>PureFP.Parsers.Trie</a>, the trie
--   parser, sec. 4.2.1</li>
--   <li><i><a>AmbTrie</a> <tt>s</tt></i> <a>PureFP.Parsers.AmbTrie</a>,
--   the ambiguous trie parser, sec. 4.2.2</li>
--   <li><i><a>ExTrie</a> <tt>s</tt></i> <a>PureFP.Parsers.ExTrie</a>, the
--   extended trie parser, sec. 4.3.3</li>
--   <li><i><a>AmbExTrie</a> <tt>s</tt></i>
--   <a>PureFP.Parsers.AmbExTrie</a>, the ambiguous extended trie parser,
--   sec. 4.3.4</li>
--   <li><i><a>PairTrie</a> <a>Standard</a> <tt>s</tt></i>
--   <a>PureFP.Parsers.PairTrie</a>, together with
--   <a>PureFP.Parsers.Standard</a>, the paired trie parser, sec. 4.4</li>
--   </ul>
--   
--   <a>PureFP.OrdMap</a> <a>PureFP.Parsers.Parser</a>
module PureFP.Parsers


-- | This library is an edited excerpt from the <i>Functional Parsing</i>
--   library developed by Peter Ljunglöf in his licenciate thesis /Pure
--   Functional Parsing – an advanced tutorial/, Göteborg University and
--   Chalmers University of Technology, April 2002:
--   
--   <a>http://www.ling.gu.se/~peb/pubs/p02-lic-thesis.pdf</a>
--   
--   <a>http://www.ling.gu.se/~peb/software.html</a>
--   
--   <a>http://www.ling.gu.se/~peb/software/functional-parsing/</a>
--   
--   Copyright (C) 2002 Peter Ljunglof (C) 2005-2011 Otakar Smrz
--   
--   This program is free software; you can redistribute it and/or modify
--   it under the terms of the GNU General Public License as published by
--   the Free Software Foundation; either version 2 of the License, or (at
--   your option) any later version.
--   
--   This program is distributed in the hope that it will be useful, but
--   WITHOUT ANY WARRANTY; without even the implied warranty of
--   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
--   General Public License for more details.
--   
--   You should have received a copy of the GNU General Public License
--   along with this program; if not, write to the Free Software
--   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
--   02110-1301 USA.
--   
--   <a>PureFP.OrdMap</a> <a>PureFP.OrdSet</a> <a>PureFP.Parsers</a>
module PureFP


-- | <a>Encode.Arabic.ArabTeX</a> <a>Encode.Arabic.ArabTeX.ZDMG</a>
module Encode.Extend
class ExtEnv e
initEnv :: ExtEnv e => e i
newtype Extend e s a
Ext :: (InE s e -> [(InE s e, a)]) -> Extend e s a
inspectIList :: Extend e s [s]
returnIList :: [s] -> Extend e s [s]
inspectEList :: Extend e s [e s]
returnEList :: [e s] -> Extend e s [e s]
inspectEnv :: Extend e s (e s)
resetEnv :: (a -> e s -> e s) -> a -> Extend e s (e s)
oneof :: (Ord s, Symbol m s) => [Map s a] -> m s
lower :: (Ord s) => [s] -> [s] -> Extend e s [s]
upper :: (OrdMap m, Ord s) => [s] -> [m s [c]] -> Extend e d ([c] -> [c])
upperWith :: (s -> m -> e d -> [[c]]) -> [s] -> m -> Extend e d ([c] -> [c])
oneof' :: (Ord [s], Symbol m [s], Eq s, Monad m) => s -> [Map [s] a] -> m [s]
(<|>) :: Extend e s a -> Extend e s a -> Extend e s a
again :: Extend e s a -> Extend e s [a]
lookupList :: (OrdMap m, Ord s) => s -> [m s a] -> [a]
instance PureFP.Parsers.Parser.Monoid' (Encode.Extend.Extend e s)
instance GHC.Base.Applicative (Encode.Extend.Extend e s)
instance GHC.Base.Monad (Encode.Extend.Extend e s)
instance GHC.Base.Functor (Encode.Extend.Extend e s)
instance PureFP.Parsers.Parser.Sequence (Encode.Extend.Extend e s)
instance GHC.Classes.Eq s => PureFP.Parsers.Parser.Symbol (Encode.Extend.Extend e s) s
instance GHC.Classes.Eq s => PureFP.Parsers.Parser.SymbolCont (Encode.Extend.Extend e s) s
instance Encode.Extend.ExtEnv e => PureFP.Parsers.Parser.Parser (Encode.Extend.Extend e s) s
instance PureFP.Parsers.Parser.Lookahead (Encode.Extend.Extend e s) s


-- | The Haskell version of <i>Encode::Mapper</i> originally written in
--   Perl: <a>http://search.cpan.org/dist/Encode-Mapper/</a>
--   
--   <a>Encode.Arabic.ArabTeX</a> <a>Encode.Arabic.ArabTeX.ZDMG</a>
module Encode.Mapper
data Mapper s a
type Quit s a = ([s], a)
parseLongest :: (Ord s, Eq a, Show a) => Mapper s (Quit s a) -> [s] -> [a]
parseLongestWith :: (Ord s, Eq b, Show b) => ([[[a]]] -> [b]) -> Mapper s (Quit s a) -> [s] -> [b]
parseLongestCheck :: (Ord s, Eq a, Show a) => Mapper s (Quit s a) -> [s] -> [a]
parseLongestCheckWith :: (Ord s, Eq b, Show b) => ([[[a]]] -> [b]) -> Mapper s (Quit s a) -> [s] -> [b]
parseLongestWide :: Ord s => Mapper s (Quit s a) -> [s] -> [a]
parseLongestWideWith :: Ord s => ([[[a]]] -> [b]) -> Mapper s (Quit s a) -> [s] -> [b]
parseWide :: Ord s => Mapper s (Quit s a) -> [ParseWide s a] -> [s] -> [ParseWide s a]
unParseWide :: Ord s => Mapper s (Quit s a) -> [ParseWide s a] -> [[[a]]]
initPW :: Ord s => Mapper s (Quit s a) -> ([a] -> [a]) -> ParseWide s a
lastPW :: Ord s => [ParseWide s a] -> ParseWide s a -> [ParseWide s a]
parseLongestDeep :: Ord s => Mapper s (Quit s a) -> [s] -> [a]
parseLongestDeepWith :: Ord s => ([[[a]]] -> [b]) -> Mapper s (Quit s a) -> [s] -> [b]
parseDeep :: Ord s => Mapper s (Quit s a) -> [ParseDeep s a] -> [s] -> [ParseDeep s a]
unParseDeep :: Ord s => Mapper s (Quit s a) -> [ParseDeep s a] -> [[[a]]]
initPD :: Ord s => Mapper s (Quit s a) -> ([a] -> [a]) -> ParseDeep s a
lastPD :: Ord s => [ParseDeep s a] -> ParseDeep s a -> [ParseDeep s a]
(|:|) :: InputSymbol s => (a -> Mapper s (Quit s a)) -> a -> Mapper s (Quit s a)
(|-|) :: InputSymbol s => [s] -> [s] -> a -> Mapper s (Quit s a)
(|.|) :: InputSymbol s => [s] -> a -> Mapper s (Quit s a)
(|+|) :: InputSymbol s => Mapper s a -> Mapper s a -> Mapper s a
others :: Ord s => Mapper s a -> (s -> Maybe (Mapper s a)) -> Mapper s a
some :: (Monoid' m, Sequence m) => m a -> m [a]
anySymbol :: (Monoid' m, Symbol m a) => [a] -> m a
(<->) :: (Monoid' m, Sequence m) => m a -> b -> m ([c], b)
(<.>) :: (Monoid' m, Sequence m) => m a -> m b -> m b
instance PureFP.OrdMap.OrdMap m => PureFP.OrdMap.OrdMap (Encode.Mapper.Next m)
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Monoid' (Encode.Mapper.Mapper s)
instance GHC.Classes.Ord s => GHC.Base.Applicative (Encode.Mapper.Mapper s)
instance GHC.Classes.Ord s => GHC.Base.Monad (Encode.Mapper.Mapper s)
instance GHC.Classes.Ord s => GHC.Base.Functor (Encode.Mapper.Mapper s)
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Sequence (Encode.Mapper.Mapper s)
instance PureFP.Parsers.Parser.InputSymbol s => PureFP.Parsers.Parser.Symbol (Encode.Mapper.Mapper s) s
instance GHC.Classes.Ord s => PureFP.Parsers.Parser.Parser (Encode.Mapper.Mapper s) s


-- | Exports the <a>version</a> of the <a>Encode</a> library and provides
--   support for working with the SVN/CVS revision keyword. The
--   <a>revised</a> method parses the '$Revision ... $' string supplied to
--   it. Results have the type <a>Version</a> of the <a>Data.Version</a>
--   module, which is exported, too.
module Encode.Version
showPretty :: Version -> String
revised :: String -> Version
version :: Version


-- | The Haskell analogy to the <i>Encode</i> module in Perl:
--   <a>http://search.cpan.org/dist/Encode/</a>
--   
--   <a>Encode.Arabic</a> <a>Encode.Mapper</a> <a>Encode.Unicode</a>
module Encode

-- | Encodings are represented as distinct datatypes of the <a>Encoding</a>
--   class, which defines two essential methods:
--   
--   <ul>
--   <li><i><a>encode</a></i> turning a list of 'internal code points' into
--   a <tt>String</tt>, and</li>
--   <li><i><a>decode</a></i> converting the lists in the opposite
--   direction.</li>
--   </ul>
--   
--   Developing a new encoding means to write a new module with a structure
--   similar to this:
--   
--   <pre>
--      module <i>MyEncModule</i> (<i>MyEncType</i> (..)) where
--   <i>  </i>
--      import <a>Encode</a>
--   <i>  </i>
--      data <i>MyEncType</i> = <i>MyEncName | MyEncAlias deriving (Enum, Show)</i>
--   <i>  </i>
--      instance <a>Encoding</a> <i>MyEncType</i> where
--   <i>  </i>
--          <a>encode</a> <i>enc data</i> = <i>show data</i>         <i>-- your choices ...</i>
--   <i>  </i>
--          <a>decode</a> <i>enc data</i> = <i>map (toEnum . fromEnum) data</i>
--   </pre>
--   
--   <a>Encode.Unicode.UTF8</a> is one concrete implementation that
--   realizes and illustrates this template.
--   <a>Encode.Arabic.Buckwalter</a> implements symmetric recoding using
--   finite maps, and <a>Encode.Arabic.ArabTeX</a> makes use of monadic
--   parsing and the <a>PureFP</a> library.
class Encoding e where encode _ = map (toEnum . fromEnum) decode _ = map (toEnum . fromEnum)
encode :: Encoding e => e -> [UPoint] -> [Char]
decode :: Encoding e => e -> [Char] -> [UPoint]

-- | The datatype introduced for the internal representation of Unicode
--   code points is currently defined as <tt>newtype <a>UPoint</a> = UPoint
--   CSpace</tt>. The shift to code points <tt>UPoint</tt> from characters
--   <tt>Char</tt> is intentional, as Unicode support in Haskell is not yet
--   fully implemented, and code points are, anyway, different entities.
--   Since the <a>UPoint</a> type is an instance of the <tt>Enum</tt>
--   class, the type's constructor and destructor functions are available
--   as <a>toEnum</a> and <a>fromEnum</a>, respectively.
--   
--   The <a>UPoint</a> datatype should be the transfer point on the way
--   from one encoding into another. It should not be the terminal stop,
--   though. The <a>encode</a> method should be used systematically, and
--   not <tt>show</tt>, even if it might temporarily produce somehow
--   appealing results.
data UPoint

-- | The <a>CSpace</a> type denotes the code space, and it is a synonym to
--   <a>Word</a>.
type CSpace = Word
instance GHC.Classes.Ord Encode.UPoint
instance GHC.Classes.Eq Encode.UPoint
instance GHC.Show.Show Encode.UPoint
instance GHC.Enum.Enum Encode.UPoint


-- | <i>Encode::Arabic::ArabTeX</i> in Perl:
--   <a>http://search.cpan.org/dist/Encode-Arabic/lib/Encode/Arabic/ArabTeX.pm</a>
--   
--   <a>Encode.Extend</a> <a>Encode.Mapper</a>
module Encode.Arabic.ArabTeX
data ArabTeX
ArabTeX :: ArabTeX
Lagally :: ArabTeX
TeX :: ArabTeX
tokens :: String -> [String]
events :: String -> [[String]]
instance GHC.Classes.Ord Encode.Arabic.ArabTeX.Mode
instance GHC.Classes.Eq Encode.Arabic.ArabTeX.Mode
instance GHC.Show.Show Encode.Arabic.ArabTeX.ArabTeX
instance GHC.Enum.Enum Encode.Arabic.ArabTeX.ArabTeX
instance Encode.Encoding Encode.Arabic.ArabTeX.ArabTeX
instance Encode.Extend.ExtEnv Encode.Arabic.ArabTeX.Env


-- | <i>Encode::Arabic::ArabTeX::ZDMG</i> in Perl:
--   <a>http://search.cpan.org/dist/Encode-Arabic/lib/Encode/Arabic/ArabTeX/ZDMG.pm</a>
--   
--   <a>Encode.Extend</a> <a>Encode.Mapper</a>
module Encode.Arabic.ArabTeX.ZDMG
data ZDMG
ZDMG :: ZDMG
ArabTeX_ZDMG :: ZDMG
instance GHC.Classes.Ord Encode.Arabic.ArabTeX.ZDMG.Mode
instance GHC.Classes.Eq Encode.Arabic.ArabTeX.ZDMG.Mode
instance GHC.Show.Show Encode.Arabic.ArabTeX.ZDMG.ZDMG
instance GHC.Enum.Enum Encode.Arabic.ArabTeX.ZDMG.ZDMG
instance Encode.Encoding Encode.Arabic.ArabTeX.ZDMG.ZDMG
instance Encode.Extend.ExtEnv Encode.Arabic.ArabTeX.ZDMG.Env


-- | Tim Buckwalter's notation is a one-to-one transliteration of the
--   graphemes of the Arabic script using lower ASCII characters only. This
--   system is very popular in Natural Language Processing, however, there
--   are limits to its applicability due to numerous non-alphabetic
--   characters involved.
--   
--   The XML-friendly variant of the notation replaces codes <tt>&gt;</tt>,
--   <tt>&amp;</tt>, <tt>&lt;</tt> with <tt>O</tt>, <tt>W</tt>, <tt>I</tt>,
--   respectively. In this implementation, the <a>decode</a> function
--   considers both of these conventions and converts from them, while the
--   <a>encode</a> function produces the XML-friendly notation only.
--   
--   <i>Encode::Arabic::Buckwalter</i> in Perl:
--   <a>http://search.cpan.org/dist/Encode-Arabic/lib/Encode/Arabic/Buckwalter.pm</a>
module Encode.Arabic.Buckwalter
data Buckwalter
Buckwalter :: Buckwalter
Tim :: Buckwalter
instance GHC.Show.Show Encode.Arabic.Buckwalter.Buckwalter
instance GHC.Enum.Enum Encode.Arabic.Buckwalter.Buckwalter
instance Encode.Encoding Encode.Arabic.Buckwalter.Buckwalter


-- | Dil Parkinson's notation is a one-to-one transliteration of the
--   graphemes of the Arabic script using lower ASCII characters only.
--   
--   <i>Encode::Arabic::Parkinson</i> in Perl:
--   <a>http://search.cpan.org/dist/Encode-Arabic/lib/Encode/Arabic/Parkinson.pm</a>
module Encode.Arabic.Parkinson
data Parkinson
Parkinson :: Parkinson
Dil :: Parkinson
instance GHC.Show.Show Encode.Arabic.Parkinson.Parkinson
instance GHC.Enum.Enum Encode.Arabic.Parkinson.Parkinson
instance Encode.Encoding Encode.Arabic.Parkinson.Parkinson


-- | Habash-Soudi-Buckwalter notation is a one-to-one transliteration of
--   the graphemes of the Arabic script into various symbols of Unicode
--   defined in
--   <a>http://scholar.google.com/scholar?q=habash+soudi+buckwalter</a>.
--   
--   <i>Encode::Arabic::Habash</i> in Perl:
--   <a>http://search.cpan.org/dist/Encode-Arabic/lib/Encode/Arabic/Habash.pm</a>
module Encode.Arabic.Habash
data Habash
Habash :: Habash
Soudi :: Habash
HSB :: Habash
instance GHC.Show.Show Encode.Arabic.Habash.Habash
instance GHC.Enum.Enum Encode.Arabic.Habash.Habash
instance Encode.Encoding Encode.Arabic.Habash.Habash


-- | <i>Encode::Byte</i> in Perl:
--   <a>http://search.cpan.org/dist/Encode/Byte/Byte.pm</a>
--   
--   <a>http://search.cpan.org/dist/Encode/lib/Encode/Supported.pod</a>
--   
--   <a>http://129.69.218.213/arabtex/doc/arabdoc.pdf</a>
module Encode.Arabic.Byte
data WinArabic
WinArabic :: WinArabic
CP1256 :: WinArabic
Windows_1256 :: WinArabic
data ISOArabic
ISOArabic :: ISOArabic
ISO_8859_6 :: ISOArabic
data MacArabic
MacArabic :: MacArabic
data MacFarsi
MacFarsi :: MacFarsi
data DOSArabic
DOSArabic :: DOSArabic
CP864 :: DOSArabic
data DOSFarsi
DOSFarsi :: DOSFarsi
CP1006 :: DOSFarsi
data ASMO449
ASMO449 :: ASMO449
data ISIRI3342
ISIRI3342 :: ISIRI3342
instance GHC.Show.Show Encode.Arabic.Byte.ISIRI3342
instance GHC.Enum.Enum Encode.Arabic.Byte.ISIRI3342
instance GHC.Show.Show Encode.Arabic.Byte.ASMO449
instance GHC.Enum.Enum Encode.Arabic.Byte.ASMO449
instance GHC.Show.Show Encode.Arabic.Byte.DOSFarsi
instance GHC.Enum.Enum Encode.Arabic.Byte.DOSFarsi
instance GHC.Show.Show Encode.Arabic.Byte.DOSArabic
instance GHC.Enum.Enum Encode.Arabic.Byte.DOSArabic
instance GHC.Show.Show Encode.Arabic.Byte.MacFarsi
instance GHC.Enum.Enum Encode.Arabic.Byte.MacFarsi
instance GHC.Show.Show Encode.Arabic.Byte.MacArabic
instance GHC.Enum.Enum Encode.Arabic.Byte.MacArabic
instance GHC.Show.Show Encode.Arabic.Byte.ISOArabic
instance GHC.Enum.Enum Encode.Arabic.Byte.ISOArabic
instance GHC.Show.Show Encode.Arabic.Byte.WinArabic
instance GHC.Enum.Enum Encode.Arabic.Byte.WinArabic
instance Encode.Encoding Encode.Arabic.Byte.WinArabic
instance Encode.Encoding Encode.Arabic.Byte.ISOArabic
instance Encode.Encoding Encode.Arabic.Byte.MacArabic
instance Encode.Encoding Encode.Arabic.Byte.MacFarsi
instance Encode.Encoding Encode.Arabic.Byte.DOSArabic
instance Encode.Encoding Encode.Arabic.Byte.DOSFarsi
instance Encode.Encoding Encode.Arabic.Byte.ASMO449
instance Encode.Encoding Encode.Arabic.Byte.ISIRI3342


-- | Modified version of John Meacham's
--   <a>http://repetae.net/repos/jhc/UTF8.hs</a>
module Encode.Unicode.UTF8
data UTF8
UTF8 :: UTF8
UTF :: UTF8
instance GHC.Show.Show Encode.Unicode.UTF8.UTF8
instance GHC.Enum.Enum Encode.Unicode.UTF8.UTF8
instance Encode.Encoding Encode.Unicode.UTF8.UTF8


-- | The Haskell analogy to the <i>Encode::Unicode</i> module in Perl:
--   <a>http://search.cpan.org/dist/Encode/</a>
--   
--   <a>Encode.Unicode.UTF8</a>
module Encode.Unicode
data Unicode
Unicode :: Unicode
UCS :: Unicode
instance GHC.Show.Show Encode.Unicode.Unicode
instance GHC.Enum.Enum Encode.Unicode.Unicode
instance Encode.Encoding Encode.Unicode.Unicode


-- | The Haskell version of <i>Encode::Arabic</i> originally written in
--   Perl: <a>http://search.cpan.org/dist/Encode-Arabic/</a>
--   
--   <a>Encode.Arabic.ArabTeX</a> <a>Encode.Arabic.ArabTeX.ZDMG</a>
--   <a>Encode.Arabic.Buckwalter</a> <a>Encode.Arabic.Parkinson</a>
--   <a>Encode.Arabic.Habash</a> <a>Encode.Arabic.Byte</a>
module Encode.Arabic