code
stringlengths 5
1.03M
| repo_name
stringlengths 5
90
| path
stringlengths 4
158
| license
stringclasses 15
values | size
int64 5
1.03M
| n_ast_errors
int64 0
53.9k
| ast_max_depth
int64 2
4.17k
| n_whitespaces
int64 0
365k
| n_ast_nodes
int64 3
317k
| n_ast_terminals
int64 1
171k
| n_ast_nonterminals
int64 1
146k
| loc
int64 -1
37.3k
| cycloplexity
int64 -1
1.31k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|
{-# LANGUAGE FlexibleInstances #-}
module Distribution.Server.Framework.MemSize (
MemSize(..),
memSizeMb, memSizeKb,
memSize0, memSize1, memSize2, memSize3, memSize4,
memSize5, memSize6, memSize7, memSize10,
memSizeUArray, memSizeUVector
) where
import Data.Word
import qualified Data.Map as Map
import Data.Map (Map)
import qualified Data.IntMap as IntMap
import Data.IntMap (IntMap)
import qualified Data.Set as Set
import Data.Set (Set)
import qualified Data.IntSet as IntSet
import Data.IntSet (IntSet)
import Data.Sequence (Seq)
import qualified Data.Foldable as Foldable
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as LBS
import qualified Data.Text as T
import Data.Time (UTCTime, Day)
import Data.Ix
import qualified Data.Array.Unboxed as A
import qualified Data.Vector as V
import qualified Data.Vector.Unboxed as V.U
import Distribution.Package (PackageIdentifier(..), PackageName(..))
import Distribution.PackageDescription (FlagName(..))
import Distribution.Version (Version(..), VersionRange, foldVersionRange')
import Distribution.System (Arch(..), OS(..))
import Distribution.Compiler (CompilerFlavor(..), CompilerId(..))
import qualified Data.Digest.Pure.SHA as SHA
-------------------------------------------------------------------------------
-- Mem size class and instances
--
memSizeMb, memSizeKb :: Int -> Int
memSizeMb w = wordSize * w `div` (1024 * 1024)
memSizeKb w = wordSize * w `div` 1024
wordSize :: Int
wordSize = 8
-- | Size in the heap of values, in words (so multiply by 4 or 8)
class MemSize a where
memSize :: a -> Int
memSize0 :: Int
memSize1 :: MemSize a => a -> Int
memSize2 :: (MemSize a1, MemSize a) => a -> a1 -> Int
memSize3 :: (MemSize a2, MemSize a1, MemSize a) => a -> a1 -> a2 -> Int
memSize4 :: (MemSize a3, MemSize a2, MemSize a1, MemSize a) => a -> a1 -> a2 -> a3 -> Int
memSize5 :: (MemSize a4, MemSize a3, MemSize a2, MemSize a1, MemSize a) => a -> a1 -> a2 -> a3 -> a4 -> Int
memSize6 :: (MemSize a5, MemSize a4, MemSize a3, MemSize a2, MemSize a1, MemSize a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> Int
memSize7 :: (MemSize a6, MemSize a5, MemSize a4, MemSize a3, MemSize a2, MemSize a1, MemSize a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> Int
memSize10 :: (MemSize a9, MemSize a8, MemSize a7, MemSize a6, MemSize a5, MemSize a4, MemSize a3, MemSize a2, MemSize a1, MemSize a) => a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> Int
memSize0 = 0
memSize1 a = 2 + memSize a
memSize2 a b = 3 + memSize a + memSize b
memSize3 a b c = 4 + memSize a + memSize b + memSize c
memSize4 a b c d = 5 + memSize a + memSize b + memSize c
+ memSize d
memSize5 a b c d e = 6 + memSize a + memSize b + memSize c
+ memSize d + memSize e
memSize6 a b c d e f = 7 + memSize a + memSize b + memSize c
+ memSize d + memSize e + memSize f
memSize7 a b c d e
f g = 8 + memSize a + memSize b + memSize c
+ memSize d + memSize e + memSize f
+ memSize g
memSize10 a b c d e
f g h i j = 11 + memSize a + memSize b + memSize c
+ memSize d + memSize e + memSize f
+ memSize g + memSize h + memSize i
+ memSize j
instance MemSize (a -> b) where
memSize _ = 0
instance MemSize Int where
memSize _ = 2
instance MemSize Word where
memSize _ = 2
instance MemSize Word32 where
memSize _ = 2
instance MemSize Char where
memSize _ = 0
instance MemSize Bool where
memSize _ = 0
instance MemSize Integer where
memSize _ = 2
instance MemSize Float where
memSize _ = 2
instance MemSize UTCTime where
memSize _ = 7
instance MemSize Day where
memSize _ = 2
instance MemSize a => MemSize [a] where
memSize [] = memSize0
memSize (x:xs) = memSize2 x xs
-- memSize xs = 2 + length xs + sum (map memSize xs)
instance (MemSize a, MemSize b) => MemSize (a,b) where
memSize (a,b) = memSize2 a b
instance (MemSize a, MemSize b, MemSize c) => MemSize (a,b,c) where
memSize (a,b,c) = memSize3 a b c
instance (MemSize a, MemSize b, MemSize c, MemSize d) => MemSize (a,b,c,d) where
memSize (a,b,c,d) = memSize4 a b c d
instance MemSize a => MemSize (Maybe a) where
memSize Nothing = memSize0
memSize (Just a) = memSize1 a
instance (MemSize a, MemSize b) => MemSize (Either a b) where
memSize (Left a) = memSize1 a
memSize (Right b) = memSize1 b
instance (MemSize a, MemSize b) => MemSize (Map a b) where
memSize m = sum [ 6 + memSize k + memSize v | (k,v) <- Map.toList m ]
instance MemSize a => MemSize (IntMap a) where
memSize m = sum [ 8 + memSize v | v <- IntMap.elems m ]
instance MemSize a => MemSize (Set a) where
memSize m = sum [ 5 + memSize v | v <- Set.elems m ]
instance MemSize IntSet where
memSize s = 4 * IntSet.size s --estimate
instance MemSize a => MemSize (Seq a) where
memSize s = sum [ 5 + memSize v | v <- Foldable.toList s ] --estimate
instance MemSize BS.ByteString where
memSize s = let (w,t) = divMod (BS.length s) wordSize
in 5 + w + signum t
instance MemSize LBS.ByteString where
memSize s = sum [ 1 + memSize c | c <- LBS.toChunks s ]
instance MemSize T.Text where
memSize s = let (w,t) = divMod (T.length s) (wordSize `div` 2)
in 5 + w + signum t
memSizeUArray :: (Ix i, A.IArray a e) => Int -> a i e -> Int
memSizeUArray sz a = 13 + (rangeSize (A.bounds a) * sz) `div` wordSize
instance MemSize e => MemSize (V.Vector e) where
memSize a = 5 + V.length a + V.foldl' (\s e -> s + memSize e) 0 a
memSizeUVector :: V.U.Unbox e => Int -> V.U.Vector e -> Int
memSizeUVector sz a = 5 + (V.U.length a * sz) `div` wordSize
----
instance MemSize PackageName where
memSize (PackageName n) = memSize n
instance MemSize Version where
memSize (Version a b) = memSize2 a b
instance MemSize VersionRange where
memSize =
foldVersionRange' memSize0 -- any
memSize1 -- == v
memSize1 -- > v
memSize1 -- < v
(\v -> 7 + 2 * memSize v) -- >= v
(\v -> 7 + 2 * memSize v) -- <= v
(\v _v' -> memSize1 v) -- == v.*
memSize2 -- _ || _
memSize2 -- _ && _
memSize1 -- (_)
instance MemSize PackageIdentifier where
memSize (PackageIdentifier a b) = memSize2 a b
instance MemSize Arch where
memSize _ = memSize0
instance MemSize OS where
memSize _ = memSize0
instance MemSize FlagName where
memSize (FlagName n) = memSize n
instance MemSize CompilerFlavor where
memSize _ = memSize0
instance MemSize CompilerId where
memSize (CompilerId a b) = memSize2 a b
instance MemSize (SHA.Digest SHA.SHA256State) where
memSize _ = memSize (undefined :: SHA.SHA256State) -- TODO: Verify
instance MemSize (SHA.SHA256State) where
memSize _ = 8 * memSize (undefined :: Word32)
|
ocharles/hackage-server
|
Distribution/Server/Framework/MemSize.hs
|
bsd-3-clause
| 7,226 | 0 | 15 | 2,011 | 2,774 | 1,455 | 1,319 | 158 | 1 |
import StackTest
main :: IO ()
main = do
-- Newer Cabal: dry run and building should succeed, because they'll
-- both ignore the do-not-build
writeFile "stack.yaml" "resolver: ghc-8.0.2"
stack ["build", "--dry-run"]
stack ["build"]
-- Older Cabal: both should fail, because they'll both try to
-- include the non-buildable component. If there's a regression, the
-- dry run will succeed (because Stack will use the proper logic)
-- and build will fail (because Cabal will be using its broken
-- logic).
writeFile "stack.yaml" "resolver: ghc-7.10.3"
stackErr ["build"]
stackErr ["build", "--dry-run"]
|
anton-dessiatov/stack
|
test/integration/tests/cabal-non-buildable-bug/Main.hs
|
bsd-3-clause
| 628 | 0 | 8 | 118 | 84 | 43 | 41 | 9 | 1 |
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE helpset PUBLIC "-//Sun Microsystems Inc.//DTD JavaHelp HelpSet Version 2.0//EN" "http://java.sun.com/products/javahelp/helpset_2_0.dtd">
<helpset version="2.0" xml:lang="es-ES">
<title>Report Generation</title>
<maps>
<homeID>reports</homeID>
<mapref location="map.jhm"/>
</maps>
<view>
<name>TOC</name>
<label>Contents</label>
<type>org.zaproxy.zap.extension.help.ZapTocView</type>
<data>toc.xml</data>
</view>
<view>
<name>Index</name>
<label>Index</label>
<type>javax.help.IndexView</type>
<data>index.xml</data>
</view>
<view>
<name>Search</name>
<label>Search</label>
<type>javax.help.SearchView</type>
<data engine="com.sun.java.help.search.DefaultSearchEngine">
JavaHelpSearch
</data>
</view>
<view>
<name>Favorites</name>
<label>Favorites</label>
<type>javax.help.FavoritesView</type>
</view>
</helpset>
|
kingthorin/zap-extensions
|
addOns/reports/src/main/javahelp/org/zaproxy/addon/reports/resources/help_es_ES/helpset_es_ES.hs
|
apache-2.0
| 966 | 82 | 52 | 156 | 390 | 206 | 184 | -1 | -1 |
{-# LANGUAGE OverloadedStrings #-}
module Lamdu.GUI.ExpressionEdit.HoleEdit.Open
( make
) where
import Control.Applicative (Applicative(..), (<$>), (<$), (<|>))
import Control.Lens.Operators
import Control.Monad (guard, msum, when)
import Control.MonadA (MonadA)
import Data.List.Lens (suffixed)
import Data.Maybe (isJust, maybeToList, fromMaybe)
import Data.Monoid (Monoid(..))
import Data.Store.Guid (Guid)
import Data.Traversable (traverse, sequenceA)
import Data.Vector.Vector2 (Vector2(..))
import Graphics.UI.Bottle.Animation (AnimId)
import Graphics.UI.Bottle.Widget (Widget)
import Lamdu.GUI.ExpressionEdit.HoleEdit.Common (makeBackground)
import Lamdu.GUI.ExpressionEdit.HoleEdit.Info (HoleInfo(..))
import Lamdu.GUI.ExpressionEdit.HoleEdit.Open.ShownResult (ShownResult(..), srPick)
import Lamdu.GUI.ExpressionEdit.HoleEdit.Results (ResultsList(..), Result(..), HaveHiddenResults(..))
import Lamdu.GUI.ExpressionGui (ExpressionGui(..))
import Lamdu.GUI.ExpressionGui.Monad (ExprGuiM, WidgetT)
import qualified Control.Lens as Lens
import qualified Data.Map as Map
import qualified Data.Monoid as Monoid
import qualified Data.Store.Property as Property
import qualified Data.Store.Transaction as Transaction
import qualified Graphics.UI.Bottle.Animation as Anim
import qualified Graphics.UI.Bottle.Widget as Widget
import qualified Graphics.UI.Bottle.Widgets.Box as Box
import qualified Graphics.UI.Bottle.Widgets.Grid as Grid
import qualified Graphics.UI.Bottle.Widgets.Spacer as Spacer
import qualified Lamdu.Config as Config
import qualified Lamdu.GUI.BottleWidgets as BWidgets
import qualified Lamdu.GUI.ExpressionEdit.HoleEdit.Info as HoleInfo
import qualified Lamdu.GUI.ExpressionEdit.HoleEdit.Open.EventMap as OpenEventMap
import qualified Lamdu.GUI.ExpressionEdit.HoleEdit.Results as HoleResults
import qualified Lamdu.GUI.ExpressionEdit.HoleEdit.State as HoleState
import qualified Lamdu.GUI.ExpressionGui as ExpressionGui
import qualified Lamdu.GUI.ExpressionGui.Monad as ExprGuiM
import qualified Lamdu.GUI.WidgetEnvT as WE
import qualified Lamdu.GUI.WidgetIds as WidgetIds
import qualified Lamdu.Sugar.RemoveTypes as SugarRemoveTypes
import qualified Lamdu.Sugar.Types as Sugar
type T = Transaction.Transaction
extraSymbol :: String
extraSymbol = "▷"
extraSymbolScaleFactor :: Fractional a => a
extraSymbolScaleFactor = 0.5
eventResultOfPickedResult :: Sugar.PickedResult -> (Maybe Guid, Widget.EventResult)
eventResultOfPickedResult pr =
( pr ^. Sugar.prMJumpTo
, Widget.EventResult
{ Widget._eCursor = Monoid.Last $ WidgetIds.fromGuid <$> pr ^. Sugar.prMJumpTo
, Widget._eAnimIdMapping =
Monoid.Endo $ pickedResultAnimIdTranslation (pr ^. Sugar.prIdTranslation)
}
)
where
pickedResultAnimIdTranslation idTranslations =
-- Map only the first anim id component
Lens.ix 0 %~ \x -> fromMaybe x $ Map.lookup x idMap
where
idMap =
idTranslations
& Lens.traversed . Lens.both %~ head . Widget.toAnimId . WidgetIds.fromGuid
& Map.fromList
resultSuffix :: Lens.Prism' AnimId AnimId
resultSuffix = suffixed ["result suffix"]
afterPick :: Monad m => HoleInfo m -> Widget.Id -> Sugar.PickedResult -> T m (Maybe Guid, Widget.EventResult)
afterPick holeInfo resultId pr = do
Property.set (hiState holeInfo) HoleState.emptyState
eventResultOfPickedResult pr
& Lens._2 . Widget.eCursor %~
(mappend . Monoid.Last . Just .
WidgetIds.fromGuid . hiStoredGuid) holeInfo
& Lens._2 . Widget.eAnimIdMapping %~
(mappend . Monoid.Endo) obliterateOtherResults
& return
where
obliterateOtherResults animId =
case animId ^? resultSuffix of
Nothing -> animId
Just unsuffixed
| Lens.has (suffixed (Widget.toAnimId resultId)) unsuffixed -> animId
| otherwise -> "obliterated" : animId
makePaddedResult :: MonadA m => Result m -> ExprGuiM m (WidgetT m)
makePaddedResult res = do
config <- ExprGuiM.widgetEnv WE.readConfig
mkWidget (rId res) (rHoleResult res)
<&> (Widget.pad . fmap realToFrac . Config.holeResultPadding) config
where
mkWidget =
case rInfo res of
HoleResults.ResultInfoNewTag -> makeNewTagResultWidget
HoleResults.ResultInfoNormal -> makeHoleResultWidget
makeShownResult ::
MonadA m => HoleInfo m -> Result m -> ExprGuiM m (Widget (T m), ShownResult m)
makeShownResult holeInfo result = do
widget <- makePaddedResult result
return
( widget & Widget.wEventMap .~ mempty
, ShownResult
{ srEventMap = widget ^. Widget.wEventMap
, srHoleResult = rHoleResult result
, srPickTo =
afterPick holeInfo (rId result) =<< rHoleResult result ^. Sugar.holeResultPick
}
)
makeResultGroup ::
MonadA m =>
HoleInfo m ->
ResultsList m ->
ExprGuiM m
( ShownResult m
, [WidgetT m]
, Maybe (ShownResult m)
)
makeResultGroup holeInfo results = do
config <- ExprGuiM.widgetEnv WE.readConfig
(mainResultWidget, shownMainResult) <- makeShownResult holeInfo mainResult
extraSymbolWidget <-
if Lens.has (HoleResults.rlExtra . traverse) results
then
BWidgets.hboxCenteredSpaced . (Spacer.empty :) . (: []) .
Widget.scale extraSymbolScaleFactor <$>
ExprGuiM.widgetEnv
(BWidgets.makeLabel extraSymbol (Widget.toAnimId (rId mainResult)))
else pure Spacer.empty
let
makeExtra =
makeExtraResultsWidget holeInfo
(mainResultWidget ^. Widget.wSize . Lens._2)
(results ^. HoleResults.rlExtra)
(mResult, extraResWidget) <-
if mainResultWidget ^. Widget.wIsFocused
then do
widget <- snd <$> makeExtra
return (Just shownMainResult, widget)
else do
cursorOnExtra <-
ExprGuiM.widgetEnv . WE.isSubCursor $ results ^. HoleResults.rlExtraResultsPrefixId
if cursorOnExtra
then makeExtra
else
(,) Nothing <$>
makeExtraResultsPlaceholderWidget (results ^. HoleResults.rlExtra)
let
onExtraSymbol =
case mResult of
Nothing -> Widget.tint $ Config.holeInactiveExtraSymbolColor config
Just _ -> id
return (shownMainResult, [mainResultWidget, onExtraSymbol extraSymbolWidget, extraResWidget], mResult)
where
mainResult = results ^. HoleResults.rlMain
makeExtraResultsPlaceholderWidget ::
MonadA m => [Result m] -> ExprGuiM m (WidgetT m)
makeExtraResultsPlaceholderWidget [] = return Spacer.empty
makeExtraResultsPlaceholderWidget (result:_) =
makeFocusable (rId result) Spacer.empty
makeExtraResultsWidget ::
MonadA m => HoleInfo m -> Anim.R -> [Result m] ->
ExprGuiM m (Maybe (ShownResult m), WidgetT m)
makeExtraResultsWidget _ _ [] = return (Nothing, Spacer.empty)
makeExtraResultsWidget holeInfo mainResultHeight extraResults@(firstResult:_) = do
config <- ExprGuiM.widgetEnv WE.readConfig
let
mkResWidget result = do
isOnResult <- ExprGuiM.widgetEnv $ WE.isSubCursor (rId result)
(widget, shownResult) <- makeShownResult holeInfo result
return
( shownResult <$ guard isOnResult
, widget
)
(mResults, widgets) <-
unzip <$> traverse mkResWidget extraResults
let
headHeight = head widgets ^. Widget.wSize . Lens._2
height = min mainResultHeight headHeight
return
( msum mResults
, Box.vboxAlign 0 widgets
& makeBackground (rId firstResult)
(Config.layerMax (Config.layers config))
(Config.activeHoleBackgroundColor config)
& Widget.wSize .~ Vector2 0 height
& Widget.translate (Vector2 0 (0.5 * (height - headHeight)))
)
makeFocusable :: (MonadA m, Applicative f) => Widget.Id -> Widget f -> ExprGuiM m (Widget f)
makeFocusable wId = ExprGuiM.widgetEnv . BWidgets.makeFocusableView wId
makeHoleResultWidget ::
MonadA m => Widget.Id ->
Sugar.HoleResult Sugar.Name m HoleResults.SugarExprPl -> ExprGuiM m (WidgetT m)
makeHoleResultWidget resultId holeResult = do
config <- ExprGuiM.widgetEnv WE.readConfig
resultGui <-
ExprGuiM.makeSubexpression 0 .
SugarRemoveTypes.holeResultTypes .
postProcessSugar $ holeResult ^. Sugar.holeResultConverted
resultGui ^. ExpressionGui.egWidget
& Widget.wFrame %~ Anim.mapIdentities (`mappend` (resultSuffix # Widget.toAnimId resultId))
& Widget.scale (realToFrac <$> Config.holeResultScaleFactor config)
& makeFocusable resultId
postProcessSugar ::
MonadA m =>
Sugar.ExpressionN m HoleResults.SugarExprPl ->
Sugar.ExpressionN m ExprGuiM.Payload
postProcessSugar expr =
expr
& Lens.mapped . Lens.mapped %~ toPayload
-- Remove the top-level result's actions so that we can safely use
-- the special events from the result's event map (e.g: add list
-- item) without also getting unwanted handlers like "delete".
& Sugar.rPayload . Sugar.plData . ExprGuiM.plHoleGuids .~ ExprGuiM.emptyHoleGuids
& Sugar.rPayload . Sugar.plActions .~ Nothing
toPayload :: HoleResults.SugarExprPl -> ExprGuiM.Payload
toPayload (ExprGuiM.StoredGuids guids, ExprGuiM.Injected injected) =
ExprGuiM.Payload
{ ExprGuiM._plStoredGuids = guids
, ExprGuiM._plInjected = injected
-- filled by AddNextHoles above
, ExprGuiM._plHoleGuids = ExprGuiM.emptyHoleGuids
}
asNewLabelScaleFactor :: Fractional a => a
asNewLabelScaleFactor = 0.5
makeNewTagResultWidget ::
MonadA m =>
Widget.Id -> Sugar.HoleResult Sugar.Name m HoleResults.SugarExprPl ->
ExprGuiM m (WidgetT m)
makeNewTagResultWidget resultId holeResult = do
widget <- makeHoleResultWidget resultId holeResult
ExprGuiM.widgetEnv $ do
label <-
fmap (Widget.scale asNewLabelScaleFactor) .
BWidgets.makeLabel " (as new tag)" $ Widget.toAnimId resultId
return $ Box.hboxAlign 0.5 [widget, label]
makeNoResults :: MonadA m => HoleInfo m -> AnimId -> ExprGuiM m (WidgetT m)
makeNoResults holeInfo myId =
(^. ExpressionGui.egWidget) <$>
case hiMArgument holeInfo ^? Lens._Just . Sugar.haExpr of
Nothing -> label "(No results)"
Just arg ->
ExpressionGui.hbox <$> sequenceA
[ label "(No results: "
, ExprGuiM.makeSubexpression 0 arg <&>
ExpressionGui.egWidget %~ Widget.doesntTakeFocus
, label ")"
]
where
label str =
ExpressionGui.fromValueWidget <$> ExprGuiM.widgetEnv (BWidgets.makeLabel str myId)
hiSearchTermId :: HoleInfo m -> Widget.Id
hiSearchTermId holeInfo = WidgetIds.searchTermId $ HoleInfo.hiActiveId holeInfo
makeHiddenResultsMWidget :: MonadA m => HaveHiddenResults -> Widget.Id -> ExprGuiM m (Maybe (Widget f))
makeHiddenResultsMWidget HaveHiddenResults myId =
fmap Just . ExprGuiM.widgetEnv . BWidgets.makeLabel "..." $
Widget.toAnimId myId
makeHiddenResultsMWidget NoHiddenResults _ = return Nothing
addMResultPicker :: MonadA m => Maybe (ShownResult m) -> ExprGuiM m ()
addMResultPicker mSelectedResult =
case mSelectedResult of
Nothing -> return ()
Just res -> ExprGuiM.addResultPicker $ srPick res
makeResultsWidget ::
MonadA m => HoleInfo m ->
[ResultsList m] -> HaveHiddenResults ->
ExprGuiM m (Maybe (ShownResult m), WidgetT m)
makeResultsWidget holeInfo shownResultsLists hiddenResults = do
(mainResults, rows, mResults) <- unzip3 <$> traverse (makeResultGroup holeInfo) shownResultsLists
let
mSelectedResult = mResults ^? Lens.traversed . Lens._Just
mFirstResult = mainResults ^? Lens.traversed
mResult = mSelectedResult <|> mFirstResult
addMResultPicker mResult
hiddenResultsWidgets <- maybeToList <$> makeHiddenResultsMWidget hiddenResults myId
widget <-
if null rows
then makeNoResults holeInfo (Widget.toAnimId myId)
else
return .
Box.vboxCentered $
( OpenEventMap.blockDownEvents .
Grid.toWidget . Grid.make
. (map . map) ((,) (Vector2 0 0.5))
) rows :
hiddenResultsWidgets
return (mResult, widget)
where
myId = HoleInfo.hiActiveId holeInfo
assignHoleEditCursor ::
MonadA m =>
HoleInfo m -> [Widget.Id] -> [Widget.Id] -> Widget.Id ->
ExprGuiM m a ->
ExprGuiM m a
assignHoleEditCursor holeInfo shownMainResultsIds allShownResultIds searchTermId action = do
cursor <- ExprGuiM.widgetEnv WE.readCursor
let
sub = isJust . flip Widget.subId cursor
shouldBeOnResult = sub $ HoleResults.prefixId holeInfo
isOnResult = any sub allShownResultIds
assignSource
| shouldBeOnResult && not isOnResult = cursor
| otherwise = HoleInfo.hiActiveId holeInfo
destId
| null (HoleInfo.hiSearchTerm holeInfo) = searchTermId
| otherwise = head (shownMainResultsIds ++ [searchTermId])
ExprGuiM.assignCursor assignSource destId action
make ::
MonadA m =>
Sugar.Payload Sugar.Name m ExprGuiM.Payload -> HoleInfo m ->
ExprGuiM m (ExpressionGui m)
make pl holeInfo = do
config <- ExprGuiM.widgetEnv WE.readConfig
(shownResultsLists, hasHiddenResults) <- HoleResults.makeAll config holeInfo
let
shownMainResultsIds = rId . (^. HoleResults.rlMain) <$> shownResultsLists
allShownResultIds = [rId . (^. HoleResults.rlMain), (^. HoleResults.rlExtraResultsPrefixId)] <*> shownResultsLists
assignHoleEditCursor
holeInfo shownMainResultsIds allShownResultIds (hiSearchTermId holeInfo) $ do
(mShownResult, resultsWidget) <-
makeResultsWidget holeInfo shownResultsLists hasHiddenResults
(searchTermEventMap, resultsEventMap) <-
OpenEventMap.make pl holeInfo mShownResult
searchTermGui <-
makeSearchTermGui holeInfo
<&> ExpressionGui.egWidget %~
Widget.weakerEvents searchTermEventMap
let
layers = Config.layers config
layerDiff = Config.layerHoleBG layers - Config.layerMax layers
searchTermGui
& ExpressionGui.addBelow 0.5
[(0.5, Widget.strongerEvents resultsEventMap resultsWidget)]
& ExpressionGui.egWidget %~
makeBackground (HoleInfo.hiActiveId holeInfo)
(Config.layerMax (Config.layers config))
(Config.activeHoleBackgroundColor config)
& ExpressionGui.addInferredTypes pl
<&> ExpressionGui.egWidget . Widget.wFrame %~ Anim.onDepth (+ layerDiff)
makeSearchTermGui ::
MonadA m => HoleInfo m ->
ExprGuiM m (ExpressionGui m)
makeSearchTermGui holeInfo = do
config <- ExprGuiM.widgetEnv WE.readConfig
ExprGuiM.widgetEnv $
(ExpressionGui.scaleFromTop (realToFrac <$> Config.holeSearchTermScaleFactor config) .
ExpressionGui.fromValueWidget .
(Widget.wEventMap %~ OpenEventMap.disallowChars searchTerm) .
Widget.atEvents setter) <$>
BWidgets.makeTextEdit searchTerm (hiSearchTermId holeInfo)
where
searchTermProp = HoleInfo.hiSearchTermProperty holeInfo
searchTerm = Property.value searchTermProp
setter (newSearchTerm, eventRes) = do
when (newSearchTerm /= searchTerm) $ Property.set searchTermProp newSearchTerm
return $
eventRes &
-- When first letter is typed in search term, jump to the
-- results, which will go to first result:
if null searchTerm && (not . null) newSearchTerm
then Widget.eCursor .~ (Monoid.Last . Just . HoleResults.prefixId) holeInfo
else id
|
schell/lamdu
|
Lamdu/GUI/ExpressionEdit/HoleEdit/Open.hs
|
gpl-3.0
| 15,058 | 0 | 21 | 2,768 | 4,152 | 2,155 | 1,997 | -1 | -1 |
module Hidden1 where
import Control.Parallel.Strategies hiding (rdeepseq)
fib t n
| n <= 1 = 1
| otherwise = n1_2 + n2_2 + 1
where
n1 = fib 20 (n-1)
n2 = fib 20 (n-2)
(n1_2, n2_2)
=
runEval
(do n1_2 <- rpar_abs_1 n1
n2_2 <- rpar_abs_1 n2
return (n1_2, n2_2))
where
rpar_abs_1
| n > t = rpar
| otherwise = rseq
n1_2 = fib 20 42
|
RefactoringTools/HaRe
|
old/testing/introDeepSeq/Hidden1_TokOut.hs
|
bsd-3-clause
| 515 | 0 | 12 | 256 | 175 | 88 | 87 | 17 | 1 |
module GitHub.Gists.Comments where
import GitHub.Internal
gistComments i = "/gists/" <> i <> "/comments"
gistComment gi ci = gistComments gi <> "/" <> ci
--| GET /gists/:gist_id/comments
listGistComments ::
Int ->
GitHub GistCommentsData
listGistComments = ghGet . gistComments
--| GET /gists/:gist_id/comments/:id
getGistComment ::
Int ->
Int ->
GitHub GistCommentData
getGistComment gi ci = ghGet $ gistComment gi ci
--| POST /gists/:gist_id/comments
createGistComment ::
Int ->
NewGistComment ->
GitHub GistCommentData
createGistComment i = ghPost (gistComments i)
--| PATCH /gists/:gist_id/comments/:id
editGistComment ::
Int ->
Int ->
GistCommentPatch ->
GitHub GistCommentData
editGistComment gi ci = ghPatch $ gistComment gi ci
--| DELETE /gists/:gist_id/comments/:id
deleteGistComment ::
Int ->
Int ->
GitHub ()
deleteGistComment gi ci = ghDelete $ gistComment gi ci
|
SaneApp/github-api
|
src/GitHub/Gists/Comments.hs
|
mit
| 895 | 30 | 10 | 136 | 361 | 178 | 183 | -1 | -1 |
{-# LANGUAGE OverloadedStrings #-}
module Codec.Soten.Importer.StlImporterTest where
import Test.Hspec
import Codec.Soten.BaseImporter
import Codec.Soten.Importer.StlImporter
import Codec.Soten.Util
stlImporterTest :: Spec
stlImporterTest = do
describe "STL Importer" $ do
context "CanImport" $ do
it "Checks extension of ascii file" $ do
status <- canImport StlImporter "models/stl/block_ascii.stl" CheckExtension
status `shouldBe` True
it "Checks header of ascii file" $ do
status <- canImport StlImporter "models/stl/block_ascii.stl" CheckHeader
status `shouldBe` True
it "Checks extension of binary file" $ do
status <- canImport StlImporter "models/stl/block_bin.stl" CheckExtension
status `shouldBe` True
it "Checks header of binary file" $ do
status <- canImport StlImporter "models/stl/block_bin.stl" CheckHeader
status `shouldBe` True
|
triplepointfive/soten
|
test/Codec/Soten/Importer/StlImporterTest.hs
|
mit
| 941 | 0 | 17 | 195 | 195 | 97 | 98 | 22 | 1 |
{-# LANGUAGE PatternSynonyms, ForeignFunctionInterface, JavaScriptFFI #-}
module GHCJS.DOM.JSFFI.Generated.CryptoKey
(js_getType, getType, js_getExtractable, getExtractable,
js_getAlgorithm, getAlgorithm, js_getUsages, getUsages, CryptoKey,
castToCryptoKey, gTypeCryptoKey)
where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
import Data.Typeable (Typeable)
import GHCJS.Types (JSVal(..), JSString)
import GHCJS.Foreign (jsNull)
import GHCJS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
import Control.Monad.IO.Class (MonadIO(..))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import GHCJS.DOM.Types
import Control.Applicative ((<$>))
import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName)
import GHCJS.DOM.JSFFI.Generated.Enums
foreign import javascript unsafe "$1[\"type\"]" js_getType ::
CryptoKey -> IO JSVal
-- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey.type Mozilla CryptoKey.type documentation>
getType :: (MonadIO m) => CryptoKey -> m KeyType
getType self = liftIO ((js_getType (self)) >>= fromJSValUnchecked)
foreign import javascript unsafe "($1[\"extractable\"] ? 1 : 0)"
js_getExtractable :: CryptoKey -> IO Bool
-- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey.extractable Mozilla CryptoKey.extractable documentation>
getExtractable :: (MonadIO m) => CryptoKey -> m Bool
getExtractable self = liftIO (js_getExtractable (self))
foreign import javascript unsafe "$1[\"algorithm\"]"
js_getAlgorithm :: CryptoKey -> IO (Nullable Algorithm)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey.algorithm Mozilla CryptoKey.algorithm documentation>
getAlgorithm :: (MonadIO m) => CryptoKey -> m (Maybe Algorithm)
getAlgorithm self
= liftIO (nullableToMaybe <$> (js_getAlgorithm (self)))
foreign import javascript unsafe "$1[\"usages\"]" js_getUsages ::
CryptoKey -> IO JSVal
-- | <https://developer.mozilla.org/en-US/docs/Web/API/CryptoKey.usages Mozilla CryptoKey.usages documentation>
getUsages :: (MonadIO m) => CryptoKey -> m [KeyUsage]
getUsages self
= liftIO ((js_getUsages (self)) >>= fromJSValUnchecked)
|
manyoo/ghcjs-dom
|
ghcjs-dom-jsffi/src/GHCJS/DOM/JSFFI/Generated/CryptoKey.hs
|
mit
| 2,445 | 24 | 10 | 309 | 598 | 357 | 241 | 37 | 1 |
{-# LANGUAGE DeriveFunctor, FlexibleContexts, MultiParamTypeClasses, TupleSections, TypeOperators #-}
{-| An effect for logging -}
module Hevents.Eff.Log where
import Control.Arrow (second)
import Control.Eff
import Control.Eff.Lift (Lift, lift)
import Data.Typeable
-- |The type of effect for logging entries of type `entry`
data Log l a = Log { entry :: l, next :: a }
deriving (Functor, Typeable)
-- | a monadic action that does the real logging
type Logger m l = l -> m ()
-- | Log something.
logE :: (Typeable l, Member (Log l) r)
=> l -> Eff r ()
logE line = send $ inj $ Log line ()
-- | Collect log messages in a list
-- This is somewhat similar to <Writer https://hackage.haskell.org/package/extensible-effects-1.11.0.4/docs/src/Control-Eff-Writer-Lazy.html> effect
runLogPure :: (Typeable l)
=> Eff (Log l :> r) a -> Eff r (a, [l])
runLogPure = freeMap (return . (,[])) (\ u -> handleRelay u runLogPure performLog)
where
performLog (Log l k) = second (l:) <$> runLogPure k
-- | Run the 'Logger' action in the base monad for every log line.
runLog :: (Typeable l, Typeable m, SetMember Lift (Lift m) (Log l :> r))
=> Logger m l -> Eff (Log l :> r) a -> Eff r a
runLog logger = freeMap return (\ u -> handleRelay u (runLog logger) (runLog logger . performLog))
where
performLog (Log e k) = lift (logger e) >> k
|
abailly/hevents
|
src/Hevents/Eff/Log.hs
|
mit
| 1,410 | 0 | 11 | 321 | 433 | 234 | 199 | 20 | 1 |
module XMonad.Javran.Config.Workspace
( workspaceIds
, workspaceName
) where
import Data.Maybe (fromMaybe)
import XMonad.Core hiding (workspaces)
workspaceIds :: [WorkspaceId]
workspaceIds = fst <$> workspaceItems
workspaceItems :: [(WorkspaceId, String)]
workspaceItems = zip (show <$> [1 :: Int ..]) $ words "any1 any2 msg1 ext1 ext2"
workspaceName :: String -> String
workspaceName n = fromMaybe "???" $ lookup n workspaceItems
|
Javran/xmonad-javran
|
src/XMonad/Javran/Config/Workspace.hs
|
mit
| 441 | 0 | 9 | 67 | 126 | 73 | 53 | 11 | 1 |
module System.USB.WMRX00 ( WMRMessage(..)
, WeatherForecast(..)
, WindDirection(..)
, feedWMRMessageChan
) where
import Control.Monad
import Control.Monad.IO.Class
import System.USB.HID
import qualified Data.ByteString as B
import qualified Data.Conduit as C
import Data.Conduit.Binary hiding (take)
import qualified Data.Conduit.List as L (foldM)
import Control.Monad.IO.Class (liftIO)
import Text.Parsec.Prim
import Text.Parsec.Char
import Text.Parsec.ByteString
import Text.Parsec.Combinator
import Data.DateTime
import Data.Bits
import Data.Word
import Control.Concurrent.Chan
import Numeric
data WeatherForecast = PartlyCloudy | Rainy | Cloudy | Sunny | ClearNight | Snowy | PartlyCloudyNight
deriving (Show, Eq, Enum)
data WindDirection = N | NNE | NE | ENE
| E | ESE | SE | SSE
| S | SSW | SW | WSW
| W | WNW | NW | NNW
deriving (Show, Eq, Enum)
data WMRMessage = DateTimeMsg { unDateTime :: DateTime }
| BarometerMsg { forecast :: WeatherForecast
, pressure :: Integer
}
| TempHumidityMsg { sensor :: Int
, temp :: Int
, humidity :: Int
}
| AnenometerMsg { direction :: WindDirection
, gustSpeed :: Int
, averageSpeed :: Int
}
deriving (Show, Eq)
dateTimeP :: Parser WMRMessage
dateTimeP = do char $ toEnum 0x60
count 2 $ char $ toEnum 0
m <- fmap fromEnum anyChar
h <- fmap fromEnum anyChar
d <- fmap fromEnum anyChar
mo <- fmap fromEnum anyChar
y <- fmap ((+ 2000) . fromEnum) anyChar
cs <- fmap fromEnum anyChar
return $ DateTimeMsg $ fromGregorian (fromIntegral y) mo d h m 0
barometerP :: Parser WMRMessage
barometerP = do char $ toEnum 0x46
anyChar
fcast <- fmap (toEnum . (`shiftR` 4) . fromEnum) anyChar
lsb <- fmap fromEnum anyChar
msb <- fmap ((`shiftL` 8) . (.&. 15) . fromEnum) anyChar
return $ BarometerMsg fcast $ fromIntegral (msb+lsb)
tempHumidityP :: Parser WMRMessage
tempHumidityP = do char $ toEnum 0x42
sensor <- fmap ((.&. 15) . fromEnum) anyChar
lsb <- fmap fromEnum anyChar
msb <- fmap fromEnum anyChar
let abs = shiftL (msb .&. 127) 8 + lsb
sg = if msb .&. 128 /= 0 then -1 else 1
temp = sg*abs
hum <- fmap fromEnum anyChar
_ <- count 4 anyChar
return $ TempHumidityMsg sensor temp hum
anenometerP :: Parser WMRMessage
anenometerP = do char $ toEnum 0x48
dir <- fmap (toEnum . fromEnum) anyChar
_ <- anyChar
gust <- fmap fromEnum anyChar
avgl <- fmap ((`shiftR` 4) . fromEnum) anyChar
avgm <- fmap ((`shiftL` 4) . (.&. 15) . fromEnum) anyChar
count 2 anyChar
let avg = avgl + avgm
return $ AnenometerMsg dir gust avg
msgParser :: Parser WMRMessage
msgParser = do anyChar
dateTimeP <|> barometerP <|> tempHumidityP <|> anenometerP
computeCheckSum :: B.ByteString -> Word8
computeCheckSum msg = fromInteger $ B.foldl (\a c -> a + fromIntegral (fromEnum c)) 0 msg .&. 255
usbPackets :: MonadIO m => HidDevice -> C.GSource m B.ByteString
usbPackets dev = loop
where loop = do packet <- liftIO (hidRead dev 8)
C.yield packet >> loop
processMessage :: Chan WMRMessage -> B.ByteString -> IO ()
processMessage msgChan str = let (msg', msg, cs) = (B.init str, B.init msg', B.last msg') in
if computeCheckSum msg /= cs then putStrLn "Error: Invalid CheckSum."
else case parse msgParser "" msg of
Left err -> print err
Right m -> do print m
writeChan msgChan m
data ParseState = SYNC | FIRST | READY [Word8]
feedWMRMessageChan :: Chan WMRMessage -> IO ()
feedWMRMessageChan chan = do dev <- hidOpen 0x0fde 0xca01
usbPackets dev C.$$ sinkUsb
return ()
where sinkUsb = L.foldM iter SYNC
iter s p = if p == B.empty then return s
else let (hd:tl) = B.unpack p in
foldM step s $ take (fromIntegral hd) tl
step state c =
case state of
SYNC -> return $ if c == 0xff then FIRST else state
FIRST -> return $ if c == 0xff then READY [] else SYNC
READY acc -> if c == 0xff then do processMessage chan $ B.pack $ reverse acc
return SYNC
else return $ READY $ c:acc
|
gaeldeest/himinn
|
System/USB/WMRX00.hs
|
mit
| 5,371 | 0 | 15 | 2,245 | 1,528 | 795 | 733 | 108 | 7 |
module HW1 where
import Prelude hiding (Enum(..), sum)
import Data.List hiding (sum)
-- Name: Brandon Burgess
--
-- * Part 1: Natural numbers
--
-- | The natural numbers.
data Nat = Zero
| Succ Nat
deriving (Eq,Show)
-- | The number 0.
zero :: Nat
zero = Zero
-- | The number 1.
one :: Nat
one = Succ zero
-- | The number 2.
two :: Nat
two = Succ one
-- | The number 3.
three :: Nat
three = Succ two
-- | The number 4.
four :: Nat
four = Succ three
-- | The predecessor of a natural number.
--
-- >>> pred zero
-- Zero
--
-- >>> pred three
-- Succ (Succ Zero)
--
pred :: Nat -> Nat
pred Zero = Zero
pred (Succ x) = x
-- | True if the given value is zero.
--
-- >>> isZero zero
-- True
--
-- >>> isZero two
-- False
--
isZero :: Nat -> Bool
isZero Zero = True
isZero _ = False
-- | Convert a natural number to an integer.
--
-- >>> toInt zero
-- 0
--
-- >>> toInt three
-- 3
--
toInt :: Nat -> Int
--toInt x xs = x
toInt Zero = 0
toInt (Succ n) = 1 + toInt n
-- | Add two natural numbers.
--
-- >>> add one two
-- Succ (Succ (Succ Zero))
--
-- >>> add zero one == one
-- True
--
-- >>> add two two == four
-- True
--
-- >>> add two three == add three two
-- True
--
add :: Nat -> Nat -> Nat
add Zero m = m
add (Succ n) m = Succ (add n m)
-- | Subtract the second natural number from the first. Return zero
-- if the second number is bigger.
--
-- >>> sub two one
-- Succ Zero
--
-- >>> sub three one
-- Succ (Succ Zero)
--
-- >>> sub one one
-- Zero
--
-- >>> sub one three
-- Zero
--
sub :: Nat -> Nat -> Nat
sub Zero _ = Zero
sub n Zero = n
sub n m = sub (pred n) (pred m)
-- Extracurricular function writing
-- Equals
eq :: Nat -> Nat -> Bool
eq Zero Zero = True
eq (Succ n) (Succ m) = eq n m
eq _ _ = False
-- | Is the left value greater than the right?
--
-- >>> gt one two
-- False
--
-- >>> gt two one
-- True
--
-- >>> gt two two
-- False
--
gt :: Nat -> Nat -> Bool
gt Zero _ = False
gt _ Zero = True
gt n m = gt (pred n) (pred m)
-- | Multiply two natural numbers.
--
-- >>> mult two zero
-- Zero
--
-- >>> mult zero three
-- Zero
--
-- >>> toInt (mult two three)
-- 6
--
-- >>> toInt (mult three three)
-- 9
--
mult :: Nat -> Nat -> Nat
mult Zero _ = Zero
mult _ Zero = Zero
mult m n = if n == Succ Zero then add m Zero
else add m (mult m (pred n))
-- | Compute the sum of a list of natural numbers.
--
-- >>> sum []
-- Zero
--
-- >>> sum [one,zero,two]
-- Succ (Succ (Succ Zero))
--
-- >>> toInt (sum [one,two,three])
-- 6
--
sum :: [Nat] -> Nat
sum [] = Zero
sum (x:xs) = add x (sum xs)
-- | An infinite list of all of the *odd* natural numbers, in order.
--
-- >>> map toInt (take 5 odds)
-- [1,3,5,7,9]
--
-- >>> toInt (sum (take 100 odds))
-- 10000
--
odds :: [Nat] -> [Nat]
odds = undefined
--
-- * Part 2: Run-length lists
--
-- | Convert a regular list into a run-length list.
--
-- >>> compress [1,1,1,2,3,3,3,1,2,2,2,2]
-- [(3,1),(1,2),(3,3),(1,1),(4,2)]
--
-- >>> compress "Mississippi"
-- [(1,'M'),(1,'i'),(2,'s'),(1,'i'),(2,'s'),(1,'i'),(2,'p'),(1,'i')]
--
compress :: Eq a => [a] -> [(Int,a)]
compress = map (\x -> (length x, head x)) . group
-- | Convert a run-length list back into a regular list.
--
-- >>> decompress [(5,'a'),(3,'b'),(4,'c'),(1,'a'),(2,'b')]
-- "aaaaabbbccccabb"
--
decompress :: [(Int,a)] -> [a]
decompress = concatMap (uncurry replicate)
|
siphayne/CS381
|
HW1/hw1.hs
|
mit
| 3,462 | 0 | 10 | 896 | 811 | 488 | 323 | 54 | 2 |
-- |Netrium is Copyright Anthony Waite, Dave Hewett, Shaun Laurens & Contributors 2009-2018, and files herein are licensed
-- |under the MIT license, the text of which can be found in license.txt
--
-- Date functions that are sensitive to various kinds of calendars.
--
-- A 'Calendar' type is provided which allows us to define various kinds of
-- calendars including business days, working days, delivery schedules etc.
--
{-# LANGUAGE BangPatterns, Rank2Types #-}
module Calendar (
-- * Calendar type
Calendar,
-- ** Date adjustment functions
calendarDayFirst,
calendarDayNext,
calendarDayPrevious,
calendarDaysEarlier,
calendarDaysLater,
-- ** Other utilities
dayInCalendar,
calendarDaysInPeriod,
calendarFirstDay,
calendarLastDay,
-- ** Constructing calendars
getBusinessDayCalendar,
newCalendar,
DayType(..),
-- ** Deprecated
firstWorkingDay,
nextWorkingDay,
previousWorkingDay,
workingDaysEarlier,
workingDaysLater,
isWorkingDay,
workingDaysInPeriod,
getCalendar,
) where
import Common
import Data.Time
import Data.Array.Unboxed
-- * Calendar types
-- | A calendar is a set of days.
--
-- For example a working days calendar is a set of working days. This lets
-- us do date calculations that are sensitive to holidays etc.
--
-- We can also define or calculate calendars for special purposes, like
-- all the delivery days in a contract delivery schedule.
--
-- Note that calendars are not contigious sets of days, that is they are not
-- date ranges, they usually do contain gaps. Calendars are finite, that is
-- there is a first and a last day that are listed in the calendar.
--
data Calendar = Calendar !String -- calendar name (for error messages)
!(UArray Day Bool) -- bitmap of day -> workday
-- very compact: 46 bytes per year
-- In future we might want infinte calendars to allow for weekday or weekend,
-- or monthly calendars. These would be useful in calculations, if not directly
-- on their own. But then these would not be suitable for use as delivery
-- schedules. We might need to distinguish finite range calendars. Or just make
-- it a runtime error.
calendarRange :: Calendar -> (Day, Day)
calendarRange (Calendar _ daybitmap) = bounds daybitmap
-- | The first day that is listed in the calendar.
--
calendarFirstDay :: Calendar -> DateTime
calendarFirstDay cal = UTCTime first 0 where (first, _) = calendarRange cal
-- | The last day that is listed in the calendar.
--
calendarLastDay :: Calendar -> DateTime
calendarLastDay cal = UTCTime first 0 where (first, _) = calendarRange cal
-- | Is the given date listed in the given calendar.
--
dayInCalendar :: Calendar -> DateTime -> Bool
dayInCalendar cal@(Calendar _ daybitmap) (UTCTime day _)
| inRange (calendarRange cal) day = daybitmap ! day
| otherwise = False
-- | The days within the given time period that are listed in the calendar.
--
calendarDaysInPeriod :: Calendar
-> (DateTime, DateTime) -- ^ @(start, end)@ datetimes
-> [DateTime]
calendarDaysInPeriod (Calendar _ daybitmap)
(UTCTime rangeStart _, UTCTime rangeEnd _) =
[ UTCTime day 0 | day <- [start..end], daybitmap ! day ]
where
start = max calStart rangeStart
end = min calEnd rangeEnd
(calStart, calEnd) = bounds daybitmap
-- | A date change: a number of calendar days later. Days that are not listed
-- in the calendar are skipped.
--
-- For example, for a working day calendar, @calendarDaysLater cal 2@ is the
-- 2nd working day, not including the current day and taking into account
-- weekends and holidays. This works because a working day calendar lists only
-- working days, and omits the weekends and holidays.
--
calendarDaysLater :: Calendar -> Int -> DiffDateTime
calendarDaysLater _ n0 | n0 < 0 = error "calendarDaysLater: negative days are invalid"
calendarDaysLater cal n0 =
modifyDate $ \day0 ->
let dayError = dateError ("calendarDaysLater" ++ show (day0,n0)) cal
in succCalendarDays dayError cal n0 day0
-- | A date change: a number of calendar days previous. Days that are not listed
-- in the calendar are skipped.
--
-- For example, for a working day calendar, @calendarDaysEarlier cal 1@ is the
-- previous working day, taking into account weekends and holidays (as
-- specified by the given calendar).
--
calendarDaysEarlier :: Calendar -> Int -> DiffDateTime
calendarDaysEarlier _ n0 | n0 < 0 = error "calendarDaysEarlier: negative days are invalid"
calendarDaysEarlier cal n0 =
modifyDate $ \day0 ->
let dayError = dateError ("calendarDaysEarlier" ++ show (day0,n0)) cal
in predCalendarDays dayError cal n0 day0
-- | A date change: the first of the subsequent days that is listed in the
-- calendar. That is, the current day is not included.
--
-- This is the same as @calendarDaysLater cal 1@
--
calendarDayNext :: Calendar -> DiffDateTime
calendarDayNext cal =
modifyDate $ \day0 ->
let dayError = dateError ("calendarDayNext(" ++ show day0 ++ ")") cal
in succCalendarDays dayError cal 1 day0
-- | A date change: the first of the current or subsequent days that is a
-- listed in the calendar day. This is the current day if the current day is
-- listed in the calendar.
--
-- This is the same as @calendarDaysLater cal 0@
--
-- Example (for a workday calendar): first working day of the year:
--
-- > inMonth 1 <> onDayOfMonth 1 <> calendarDayFirst cal
--
-- Example (for a workday calendar): first working day in a month's time:
--
-- > monthsLater 1 <> calendarDayFirst cal
--
calendarDayFirst :: Calendar -> DiffDateTime
calendarDayFirst cal =
modifyDate $ \day0 ->
let dayError = dateError ("calendarDayFirst(" ++ show day0 ++ ")") cal
in succCalendarDays dayError cal 0 day0
-- | A date change: the first of the previous days that is listed in the
-- calendar.
--
-- That is, the current day is not included.
--
-- This is the same as @calendarDaysEarlier cal 1@
--
calendarDayPrevious :: Calendar -> DiffDateTime
calendarDayPrevious cal =
modifyDate $ \day0 ->
let dayError = dateError ("calendarDayPrevious(" ++ show day0 ++ ")") cal
in predCalendarDays dayError cal 1 day0
-- internal worker & helper functions:
badDay :: Calendar -> Day -> Bool
badDay (Calendar _ daybitmap) = not . inRange (bounds daybitmap)
dateError :: String -> Calendar -> Day -> a
dateError fname (Calendar name daybitmap) day =
error $ fname ++ ": " ++ "the date " ++ show day
++ " is out of range for the calendar " ++ name
++ " " ++ show (bounds daybitmap)
succCalendarDays :: (forall a. Day -> a) -> Calendar -> Int -> Day -> Day
succCalendarDays dayError cal@(Calendar _ daybitmap) = later
where
later _ !day | badDay cal day = dayError day
later !0 !day | daybitmap ! day = day
| otherwise = succCalendarDay day
later !1 !day = succCalendarDay day
later !n !day = later (n-1) (succCalendarDay day)
succCalendarDay = go . succ
where
go !day | badDay cal day = dayError day
| daybitmap ! day = day
| otherwise = go (succ day)
predCalendarDays :: (forall a. Day -> a) -> Calendar -> Int -> Day -> Day
predCalendarDays dayError cal@(Calendar _ daybitmap) = earlier
where
earlier _ !day | badDay cal day = dayError day
earlier !0 !day | daybitmap ! day = day
| otherwise = predCalendarDay day
earlier !1 !day = predCalendarDay day
earlier !n !day = earlier (n-1) (predCalendarDay day)
predCalendarDay = go . pred
where
go !day | badDay cal day = dayError day
| daybitmap ! day = day
| otherwise = go (pred day)
---------------
-- Deprecated
--
{-# DEPRECATED firstWorkingDay "Use calendarDayFirst instead" #-}
{-# DEPRECATED nextWorkingDay "Use calendarDayNext instead" #-}
{-# DEPRECATED previousWorkingDay "Use calendarDayPrevious instead" #-}
{-# DEPRECATED workingDaysEarlier "Use calendarDaysEarlier instead" #-}
{-# DEPRECATED workingDaysLater "Use calendarDaysLater instead" #-}
{-# DEPRECATED isWorkingDay "Use dayInCalendar instead" #-}
{-# DEPRECATED workingDaysInPeriod "Use calendarDaysInPeriod instead" #-}
{-# DEPRECATED getCalendar "Use getBusinessDayCalendar instead" #-}
firstWorkingDay = calendarDayFirst
nextWorkingDay = calendarDayNext
previousWorkingDay = calendarDayPrevious
workingDaysEarlier = calendarDaysEarlier
workingDaysLater = calendarDaysLater
isWorkingDay = dayInCalendar
workingDaysInPeriod = calendarDaysInPeriod
getCalendar = getBusinessDayCalendar
---------------------------
-- Constructing calendars
--
newCalendar :: String -> [(DateTime, DayType)] -> Calendar
newCalendar name days = Calendar name daybitmap
where
daybitmap :: UArray Day Bool
daybitmap = array (lbound, ubound)
[ (day, isBusinessDay daytype)
| (UTCTime day _, daytype) <- days ]
UTCTime lbound _ = minimum [ day | (day,_) <- days]
UTCTime ubound _ = maximum [ day | (day,_) <- days]
-- | Day types
data DayType = BusinessDay -- ^ a normal working weekday
| Holiday -- ^ a weekday that is a non-working day, e.g. holiday
| Weekend -- ^ a weekend
deriving (Show, Eq)
isBusinessDay :: DayType -> Bool
isBusinessDay BusinessDay = True
isBusinessDay _ = False
-- * Calendar instances
-- | Get a given business day calendar. For now, calendars are manually
-- populated here. Ideally this will done using a service and parsed here.
getBusinessDayCalendar :: String -> Calendar
getBusinessDayCalendar "EEX Power" = eexPower
getBusinessDayCalendar name = error $ "getCalendar: unknown calendar " ++ show name
eexPower :: Calendar
eexPower = newCalendar "EEX Power"
[(date 2010 12 25, Weekend)
,(date 2010 12 26, Weekend)
,(date 2010 12 27, BusinessDay)
,(date 2010 12 28, BusinessDay)
,(date 2010 12 29, BusinessDay)
,(date 2010 12 30, BusinessDay)
,(date 2010 12 31, BusinessDay)
,(date 2011 01 01, Weekend)
,(date 2011 01 02, Weekend)
,(date 2011 01 03, BusinessDay)
,(date 2011 01 04, BusinessDay)
,(date 2011 01 05, BusinessDay)
,(date 2011 01 06, BusinessDay)
,(date 2011 01 07, BusinessDay)
,(date 2011 01 08, Weekend)
,(date 2011 01 09, Weekend)
,(date 2011 01 10, BusinessDay)
,(date 2011 01 11, BusinessDay)
,(date 2011 01 12, BusinessDay)
,(date 2011 01 13, BusinessDay)
,(date 2011 01 14, BusinessDay)
,(date 2011 01 15, Weekend)
,(date 2011 01 16, Weekend)
,(date 2011 01 17, BusinessDay)
,(date 2011 01 18, BusinessDay)
,(date 2011 01 19, BusinessDay)
,(date 2011 01 20, BusinessDay)
,(date 2011 01 21, BusinessDay)
,(date 2011 01 22, Weekend)
,(date 2011 01 23, Weekend)
,(date 2011 01 24, BusinessDay)
,(date 2011 01 25, BusinessDay)
,(date 2011 01 26, BusinessDay)
,(date 2011 01 27, BusinessDay)
,(date 2011 01 28, BusinessDay)
,(date 2011 01 29, Weekend)
,(date 2011 01 30, Weekend)
,(date 2011 01 31, BusinessDay)
,(date 2011 02 01, BusinessDay)
,(date 2011 02 02, BusinessDay)
,(date 2011 02 03, BusinessDay)
,(date 2011 02 04, BusinessDay)
,(date 2011 02 05, Weekend)
,(date 2011 02 06, Weekend)
,(date 2011 02 07, BusinessDay)
,(date 2011 02 08, BusinessDay)
,(date 2011 02 09, BusinessDay)
,(date 2011 02 10, BusinessDay)
,(date 2011 02 11, BusinessDay)
,(date 2011 02 12, Weekend)
,(date 2011 02 13, Weekend)
,(date 2011 02 14, BusinessDay)
,(date 2011 02 15, BusinessDay)
,(date 2011 02 16, BusinessDay)
,(date 2011 02 17, BusinessDay)
,(date 2011 02 18, BusinessDay)
,(date 2011 02 19, Weekend)
,(date 2011 02 20, Weekend)
,(date 2011 02 21, BusinessDay)
,(date 2011 02 22, BusinessDay)
,(date 2011 02 23, BusinessDay)
,(date 2011 02 24, BusinessDay)
,(date 2011 02 25, BusinessDay)
,(date 2011 02 26, Weekend)
,(date 2011 02 27, Weekend)
,(date 2011 02 28, BusinessDay)
,(date 2011 03 01, BusinessDay)
,(date 2011 03 02, BusinessDay)
,(date 2011 03 03, BusinessDay)
,(date 2011 03 04, BusinessDay)
,(date 2011 03 05, Weekend)
,(date 2011 03 06, Weekend)
,(date 2011 03 07, BusinessDay)
,(date 2011 03 08, BusinessDay)
,(date 2011 03 09, BusinessDay)
,(date 2011 03 10, BusinessDay)
,(date 2011 03 11, BusinessDay)
,(date 2011 03 12, Weekend)
,(date 2011 03 13, Weekend)
,(date 2011 03 14, BusinessDay)
,(date 2011 03 15, BusinessDay)
,(date 2011 03 16, BusinessDay)
,(date 2011 03 17, BusinessDay)
,(date 2011 03 18, BusinessDay)
,(date 2011 03 19, Weekend)
,(date 2011 03 20, Weekend)
,(date 2011 03 21, BusinessDay)
,(date 2011 03 22, BusinessDay)
,(date 2011 03 23, BusinessDay)
,(date 2011 03 24, BusinessDay)
,(date 2011 03 25, BusinessDay)
,(date 2011 03 26, Weekend)
,(date 2011 03 27, Weekend)
,(date 2011 03 28, BusinessDay)
,(date 2011 03 29, BusinessDay)
,(date 2011 03 30, BusinessDay)
,(date 2011 03 31, BusinessDay)
,(date 2011 04 01, BusinessDay)
,(date 2011 04 02, Weekend)
,(date 2011 04 03, Weekend)
,(date 2011 04 04, BusinessDay)
,(date 2011 04 05, BusinessDay)
,(date 2011 04 06, BusinessDay)
,(date 2011 04 07, BusinessDay)
,(date 2011 04 08, BusinessDay)
,(date 2011 04 09, Weekend)
,(date 2011 04 10, Weekend)
,(date 2011 04 11, BusinessDay)
,(date 2011 04 12, BusinessDay)
,(date 2011 04 13, BusinessDay)
,(date 2011 04 14, BusinessDay)
,(date 2011 04 15, BusinessDay)
,(date 2011 04 16, Weekend)
,(date 2011 04 17, Weekend)
,(date 2011 04 18, BusinessDay)
,(date 2011 04 19, BusinessDay)
,(date 2011 04 20, BusinessDay)
,(date 2011 04 21, BusinessDay)
,(date 2011 04 22, Holiday)
,(date 2011 04 23, Weekend)
,(date 2011 04 24, Weekend)
,(date 2011 04 25, Holiday)
,(date 2011 04 26, BusinessDay)
,(date 2011 04 27, BusinessDay)
,(date 2011 04 28, BusinessDay)
,(date 2011 04 29, BusinessDay)
,(date 2011 04 30, Weekend)
,(date 2011 05 01, Weekend)
,(date 2011 05 02, BusinessDay)
,(date 2011 05 03, BusinessDay)
,(date 2011 05 04, BusinessDay)
,(date 2011 05 05, BusinessDay)
,(date 2011 05 06, BusinessDay)
,(date 2011 05 07, Weekend)
,(date 2011 05 08, Weekend)
,(date 2011 05 09, BusinessDay)
,(date 2011 05 10, BusinessDay)
,(date 2011 05 11, BusinessDay)
,(date 2011 05 12, BusinessDay)
,(date 2011 05 13, BusinessDay)
,(date 2011 05 14, Weekend)
,(date 2011 05 15, Weekend)
,(date 2011 05 16, BusinessDay)
,(date 2011 05 17, BusinessDay)
,(date 2011 05 18, BusinessDay)
,(date 2011 05 19, BusinessDay)
,(date 2011 05 20, BusinessDay)
,(date 2011 05 21, Weekend)
,(date 2011 05 22, Weekend)
,(date 2011 05 23, BusinessDay)
,(date 2011 05 24, BusinessDay)
,(date 2011 05 25, BusinessDay)
,(date 2011 05 26, BusinessDay)
,(date 2011 05 27, BusinessDay)
,(date 2011 05 28, Weekend)
,(date 2011 05 29, Weekend)
,(date 2011 05 30, BusinessDay)
,(date 2011 05 31, BusinessDay)
,(date 2011 06 01, BusinessDay)
,(date 2011 06 02, Holiday)
,(date 2011 06 03, BusinessDay)
,(date 2011 06 04, Weekend)
,(date 2011 06 05, Weekend)
,(date 2011 06 06, BusinessDay)
,(date 2011 06 07, BusinessDay)
,(date 2011 06 08, BusinessDay)
,(date 2011 06 09, BusinessDay)
,(date 2011 06 10, BusinessDay)
,(date 2011 06 11, Weekend)
,(date 2011 06 12, Weekend)
,(date 2011 06 13, Holiday)
,(date 2011 06 14, BusinessDay)
,(date 2011 06 15, BusinessDay)
,(date 2011 06 16, BusinessDay)
,(date 2011 06 17, BusinessDay)
,(date 2011 06 18, Weekend)
,(date 2011 06 19, Weekend)
,(date 2011 06 20, BusinessDay)
,(date 2011 06 21, BusinessDay)
,(date 2011 06 22, BusinessDay)
,(date 2011 06 23, BusinessDay)
,(date 2011 06 24, BusinessDay)
,(date 2011 06 25, Weekend)
,(date 2011 06 26, Weekend)
,(date 2011 06 27, BusinessDay)
,(date 2011 06 28, BusinessDay)
,(date 2011 06 29, BusinessDay)
,(date 2011 06 30, BusinessDay)
,(date 2011 07 01, BusinessDay)
,(date 2011 07 02, Weekend)
,(date 2011 07 03, Weekend)
,(date 2011 07 04, BusinessDay)
,(date 2011 07 05, BusinessDay)
,(date 2011 07 06, BusinessDay)
,(date 2011 07 07, BusinessDay)
,(date 2011 07 08, BusinessDay)
,(date 2011 07 09, Weekend)
,(date 2011 07 10, Weekend)
,(date 2011 07 11, BusinessDay)
,(date 2011 07 12, BusinessDay)
,(date 2011 07 13, BusinessDay)
,(date 2011 07 14, BusinessDay)
,(date 2011 07 15, BusinessDay)
,(date 2011 07 16, Weekend)
,(date 2011 07 17, Weekend)
,(date 2011 07 18, BusinessDay)
,(date 2011 07 19, BusinessDay)
,(date 2011 07 20, BusinessDay)
,(date 2011 07 21, BusinessDay)
,(date 2011 07 22, BusinessDay)
,(date 2011 07 23, Weekend)
,(date 2011 07 24, Weekend)
,(date 2011 07 25, BusinessDay)
,(date 2011 07 26, BusinessDay)
,(date 2011 07 27, BusinessDay)
,(date 2011 07 28, BusinessDay)
,(date 2011 07 29, BusinessDay)
,(date 2011 07 30, Weekend)
,(date 2011 07 31, Weekend)
,(date 2011 08 01, BusinessDay)
,(date 2011 08 02, BusinessDay)
,(date 2011 08 03, BusinessDay)
,(date 2011 08 04, BusinessDay)
,(date 2011 08 05, BusinessDay)
,(date 2011 08 06, Weekend)
,(date 2011 08 07, Weekend)
,(date 2011 08 08, BusinessDay)
,(date 2011 08 09, BusinessDay)
,(date 2011 08 10, BusinessDay)
,(date 2011 08 11, BusinessDay)
,(date 2011 08 12, BusinessDay)
,(date 2011 08 13, Weekend)
,(date 2011 08 14, Weekend)
,(date 2011 08 15, BusinessDay)
,(date 2011 08 16, BusinessDay)
,(date 2011 08 17, BusinessDay)
,(date 2011 08 18, BusinessDay)
,(date 2011 08 19, BusinessDay)
,(date 2011 08 20, Weekend)
,(date 2011 08 21, Weekend)
,(date 2011 08 22, BusinessDay)
,(date 2011 08 23, BusinessDay)
,(date 2011 08 24, BusinessDay)
,(date 2011 08 25, BusinessDay)
,(date 2011 08 26, BusinessDay)
,(date 2011 08 27, Weekend)
,(date 2011 08 28, Weekend)
,(date 2011 08 29, BusinessDay)
,(date 2011 08 30, BusinessDay)
,(date 2011 08 31, BusinessDay)
,(date 2011 09 01, BusinessDay)
,(date 2011 09 02, BusinessDay)
,(date 2011 09 03, Weekend)
,(date 2011 09 04, Weekend)
,(date 2011 09 05, BusinessDay)
,(date 2011 09 06, BusinessDay)
,(date 2011 09 07, BusinessDay)
,(date 2011 09 08, BusinessDay)
,(date 2011 09 09, BusinessDay)
,(date 2011 09 10, Weekend)
,(date 2011 09 11, Weekend)
,(date 2011 09 12, BusinessDay)
,(date 2011 09 13, BusinessDay)
,(date 2011 09 14, BusinessDay)
,(date 2011 09 15, BusinessDay)
,(date 2011 09 16, BusinessDay)
,(date 2011 09 17, Weekend)
,(date 2011 09 18, Weekend)
,(date 2011 09 19, BusinessDay)
,(date 2011 09 20, BusinessDay)
,(date 2011 09 21, BusinessDay)
,(date 2011 09 22, BusinessDay)
,(date 2011 09 23, BusinessDay)
,(date 2011 09 24, Weekend)
,(date 2011 09 25, Weekend)
,(date 2011 09 26, BusinessDay)
,(date 2011 09 27, BusinessDay)
,(date 2011 09 28, BusinessDay)
,(date 2011 09 29, BusinessDay)
,(date 2011 09 30, BusinessDay)
,(date 2011 10 01, Weekend)
,(date 2011 10 02, Weekend)
,(date 2011 10 03, Holiday)
,(date 2011 10 04, BusinessDay)
,(date 2011 10 05, BusinessDay)
,(date 2011 10 06, BusinessDay)
,(date 2011 10 07, BusinessDay)
,(date 2011 10 08, Weekend)
,(date 2011 10 09, Weekend)
,(date 2011 10 10, BusinessDay)
,(date 2011 10 11, BusinessDay)
,(date 2011 10 12, BusinessDay)
,(date 2011 10 13, BusinessDay)
,(date 2011 10 14, BusinessDay)
,(date 2011 10 15, Weekend)
,(date 2011 10 16, Weekend)
,(date 2011 10 17, BusinessDay)
,(date 2011 10 18, BusinessDay)
,(date 2011 10 19, BusinessDay)
,(date 2011 10 20, BusinessDay)
,(date 2011 10 21, BusinessDay)
,(date 2011 10 22, Weekend)
,(date 2011 10 23, Weekend)
,(date 2011 10 24, BusinessDay)
,(date 2011 10 25, BusinessDay)
,(date 2011 10 26, BusinessDay)
,(date 2011 10 27, BusinessDay)
,(date 2011 10 28, BusinessDay)
,(date 2011 10 29, Weekend)
,(date 2011 10 30, Weekend)
,(date 2011 10 31, BusinessDay)
,(date 2011 11 01, BusinessDay)
,(date 2011 11 02, BusinessDay)
,(date 2011 11 03, BusinessDay)
,(date 2011 11 04, BusinessDay)
,(date 2011 11 05, Weekend)
,(date 2011 11 06, Weekend)
,(date 2011 11 07, BusinessDay)
,(date 2011 11 08, BusinessDay)
,(date 2011 11 09, BusinessDay)
,(date 2011 11 10, BusinessDay)
,(date 2011 11 11, BusinessDay)
,(date 2011 11 12, Weekend)
,(date 2011 11 13, Weekend)
,(date 2011 11 14, BusinessDay)
,(date 2011 11 15, BusinessDay)
,(date 2011 11 16, BusinessDay)
,(date 2011 11 17, BusinessDay)
,(date 2011 11 18, BusinessDay)
,(date 2011 11 19, Weekend)
,(date 2011 11 20, Weekend)
,(date 2011 11 21, BusinessDay)
,(date 2011 11 22, BusinessDay)
,(date 2011 11 23, BusinessDay)
,(date 2011 11 24, BusinessDay)
,(date 2011 11 25, BusinessDay)
,(date 2011 11 26, Weekend)
,(date 2011 11 27, Weekend)
,(date 2011 11 28, BusinessDay)
,(date 2011 11 29, BusinessDay)
,(date 2011 11 30, BusinessDay)
,(date 2011 12 01, BusinessDay)
,(date 2011 12 02, BusinessDay)
,(date 2011 12 03, Weekend)
,(date 2011 12 04, Weekend)
,(date 2011 12 05, BusinessDay)
,(date 2011 12 06, BusinessDay)
,(date 2011 12 07, BusinessDay)
,(date 2011 12 08, BusinessDay)
,(date 2011 12 09, BusinessDay)
,(date 2011 12 10, Weekend)
,(date 2011 12 11, Weekend)
,(date 2011 12 12, BusinessDay)
,(date 2011 12 13, BusinessDay)
,(date 2011 12 14, BusinessDay)
,(date 2011 12 15, BusinessDay)
,(date 2011 12 16, BusinessDay)
,(date 2011 12 17, Weekend)
,(date 2011 12 18, Weekend)
,(date 2011 12 19, BusinessDay)
,(date 2011 12 20, BusinessDay)
,(date 2011 12 21, BusinessDay)
,(date 2011 12 22, BusinessDay)
,(date 2011 12 23, BusinessDay)
,(date 2011 12 24, Weekend)
,(date 2011 12 25, Weekend)
,(date 2011 12 26, Holiday)
,(date 2011 12 27, BusinessDay)
,(date 2011 12 28, BusinessDay)
,(date 2011 12 29, BusinessDay)
,(date 2011 12 30, BusinessDay)
,(date 2011 12 31, Weekend)
]
|
netrium/Netrium
|
share/Calendar.hs
|
mit
| 22,271 | 0 | 15 | 4,929 | 7,732 | 4,299 | 3,433 | 515 | 4 |
quickSort :: (Ord a) => [a] -> [a]
quickSort [] = []
quickSort (x:xs) = quickSort [a | a <- xs, a <= x] ++ [x] ++ quickSort [b | b <- xs, b > x]
-- quickSort [3,2,1] ++ [4] ++ [] ++ [5] ++ []
-- quickSort [2,1] ++ [3] ++ [] ++ [4] ++ []
-- quickSort [1] ++ [2] ++ [] ++ [3] ++ [4] ++ []
-- [] ++ [1] ++ [] ++ [2] ++ [] ++ [3] ++ [4] ++ []
|
RAFIRAF/HASKELL
|
quickSort2.hs
|
mit
| 339 | 0 | 10 | 87 | 111 | 60 | 51 | 3 | 1 |
module ListT.HTMLParser.Prelude
(
module Exports,
)
where
import BasePrelude as Exports
import MTLPrelude as Exports hiding (Error, shift)
import Control.Monad.Trans.Either as Exports hiding (left, right)
import ListT as Exports (ListT)
import Data.Text as Exports (Text)
import Conversion as Exports
import Conversion.Text as Exports
|
nikita-volkov/list-t-html-parser
|
library/ListT/HTMLParser/Prelude.hs
|
mit
| 339 | 0 | 5 | 47 | 85 | 61 | 24 | 10 | 0 |
{-# LANGUAGE Haskell2010
, GeneralizedNewtypeDeriving
, DeriveDataTypeable
, CPP
, FlexibleContexts
#-}
{-# OPTIONS
-Wall
-fno-warn-missing-signatures
-fno-warn-name-shadowing
#-}
-- | INTERNAL module:
-- The Java Monad Transformer. Most of its API is re-exported by "Foreign.Java"
module Foreign.Java.JavaMonad where
import Control.Monad.State hiding (void)
import qualified Control.Monad.State as State
import Data.Int
import Data.Word
import qualified Foreign.Java.JNI.Safe as JNI
import qualified Foreign.Java.JNI.Types as Core
import Foreign.Java.JNI.Types (
JObject (..),
JThrowable (..)
)
import Foreign hiding (void)
import Foreign.C.String
import Foreign.Java.Util
import Control.Concurrent
import Control.Exception
import Data.Typeable
io :: IO a -> Java a
-- ^ Short for 'liftIO' and restricted to the 'Java' monad.
io = liftIO
-- | An exception in either the Java Virtual Machine or during
-- instantiating the Virtual Machine.
data JavaException =
-- | An exception that occurred during the initialization
-- of the virtual machine. Thrown by 'runJava', 'runJava'',
-- or 'initJava'.
JvmException String [String]
-- | An exception that occurred inside the virtual machine.
-- Thrown by those functions ending with a capital @E@.
| JavaException String JThrowable
deriving Typeable
instance Show JavaException where
show (JvmException jvmlibPath args) =
"JvmException: jvmlibPath = " ++ jvmlibPath
++ ", arguments = " ++ show args
show (JavaException strMessage _throwable) =
"JavaException: " ++ strMessage
instance Exception JavaException
-- | A reference to an instance of a Java Virtual Machine.
newtype JVM = JVM (Ptr Core.JVM)
deriving Show
-- | The State of a virtual machine, running in the Java
-- Monad (which is a State Monad wrapped around the IO
-- Monad with JVMState as additional State).
--
-- All the accessor functions are INTERNAL.
data JVMState = JVMState {
-- | INTERNAL The actual pointer to the virtual machine.
jvmPtr :: Ptr Core.JVM,
-- | INTERNAL Whether this virtual machine instance should
-- be talked to using safe or unsafe calls.
--
-- See also 'setSafe' and 'getSafe'.
jvmSafe :: Bool,
-- | INTERNAL The cached methodID of Object.toString
jvmToString :: Maybe (JObject -> Java (Maybe String)),
-- | INTERNAL The cached methodID of Object.hashCode
jvmHashCode :: Maybe (JObject -> Java Int32),
jvmGetC :: Maybe (Maybe JObject -> Int32 -> Java Word16),
jvmGetB :: Maybe (Maybe JObject -> Int32 -> Java Int8),
jvmGetS :: Maybe (Maybe JObject -> Int32 -> Java Int16),
jvmGetI :: Maybe (Maybe JObject -> Int32 -> Java Int32),
jvmGetJ :: Maybe (Maybe JObject -> Int32 -> Java Int64),
jvmGetF :: Maybe (Maybe JObject -> Int32 -> Java Float),
jvmGetD :: Maybe (Maybe JObject -> Int32 -> Java Double),
jvmGetZ :: Maybe (Maybe JObject -> Int32 -> Java Bool),
jvmGetL :: Maybe (Maybe JObject -> Int32 -> Java (Maybe JObject)),
jvmSetC :: Maybe (Maybe JObject -> Int32 -> Word16 -> Java ()),
jvmSetB :: Maybe (Maybe JObject -> Int32 -> Int8 -> Java ()),
jvmSetS :: Maybe (Maybe JObject -> Int32 -> Int16 -> Java ()),
jvmSetI :: Maybe (Maybe JObject -> Int32 -> Int32 -> Java ()),
jvmSetJ :: Maybe (Maybe JObject -> Int32 -> Int64 -> Java ()),
jvmSetF :: Maybe (Maybe JObject -> Int32 -> Float -> Java ()),
jvmSetD :: Maybe (Maybe JObject -> Int32 -> Double -> Java ()),
jvmSetZ :: Maybe (Maybe JObject -> Int32 -> Bool -> Java ()),
jvmSetL :: Maybe (Maybe JObject -> Int32 -> (Maybe JObject) -> Java ())
}
-- | Creates a JVMState and initializes it with sane default values.
-- A Pointer to the virtual machine is required in any case.
newJVMState vm = JVMState {
jvmPtr = vm,
jvmSafe = True,
jvmToString = Nothing,
jvmHashCode = Nothing,
jvmGetC = Nothing, jvmSetC = Nothing,
jvmGetB = Nothing, jvmSetB = Nothing,
jvmGetS = Nothing, jvmSetS = Nothing,
jvmGetI = Nothing, jvmSetI = Nothing,
jvmGetJ = Nothing, jvmSetJ = Nothing,
jvmGetF = Nothing, jvmSetF = Nothing,
jvmGetD = Nothing, jvmSetD = Nothing,
jvmGetZ = Nothing, jvmSetZ = Nothing,
jvmGetL = Nothing, jvmSetL = Nothing
}
-- | Every computation in the Java Virtual Machine happens inside the
-- Java monad. The Java monad is mightier than the IO monad, i.e.
-- IO operations can be performed in both the IO monad as well as in
-- the Java monad, but Java operations can be performed in the Java
-- monad only and not in the IO monad.
--
-- Use one of 'runJava' or 'runJava'' to perform operations in the
-- Java monad.
newtype Java a = Java { _runJava :: StateT JVMState IO a }
deriving (Applicative, Monad, MonadState JVMState, Functor, MonadIO)
-- | INTERNAL Retrieve the 'jvmPtr' from this Java Monads
-- State.
getVM :: Java (Ptr Core.JVM)
getVM = State.get $> jvmPtr
-- | INTERNAL Retrieve 'jvmSafe' from this Java Monads Sate.
getSafe :: Java Bool
getSafe = State.get $> jvmSafe
-- | By default java methods are invoked via the FFI using
-- safe calls. Safe calls are slower than unsafe calls. This
-- function controls whether safe or unsafe calls are being
-- used to communicate with the JVM.
--
-- If your application does not invoke the JVM concurrently
-- it is mostly safe to use unsafe calls.
--
-- > runJava (setUnsafe True >> doSomething)
--
-- will perform 'doSomething' using unsafe calls.
setUnsafe mode = do
state <- State.get
State.put (state { jvmSafe = not mode })
newtype JavaThreadId a = JavaThreadId (MVar (Either SomeException a))
forkJava :: Java a -> Java (JavaThreadId a)
-- ^ A utility function for forking an OS thread which runs in the
-- Java Monad. It will return a 'JavaThreadId' which you can wait on
-- using 'waitJava'.
forkJava t = io $ do
lock <- newEmptyMVar
_ <- forkOS $ do
result <- try $ runJava t
putMVar lock result
return $ JavaThreadId lock
waitJava :: JavaThreadId a -> Java (Either SomeException a)
-- ^ Wait for a Java Thread to exit. If the thread exits abnormally
-- (that is, if an exception occurred), this function will return
-- @Left SomeException@. Otherwise it will return the result of the
-- computation as @Right a@.
waitJava (JavaThreadId mvar) = io $ takeMVar mvar
runJava :: Java a -> IO a
-- ^ Run a computation with support by a Java Virtual Machine.
runJava = runJava' []
runJava' :: [String] -> Java a -> IO a
-- ^ Run a computation with support by a Java Virtual Machine,
-- initialized with the given parameters.
--
-- This function may be used only once. If you intend to call
-- it multiple times, you need to initialize the Java subsystem
-- once before. If you fail to do so, this function will tear
-- down the virtual machine once it is done.
--
-- By using 'initJava' the virtual machine will be alive during
-- the whole lifetime of your process and 'runJava'' will never
-- tear down the machine.
--
-- /NOTE: According to the Java Native Interface specification it may be possible to create multiple virtual machines within a single process. However, no implementation of the JNI seems to be capable of doing so./
--
-- This function can be used to set for example the classpath
-- of the virtual machine:
--
-- > runJava' ["-Djava.class.path=java-library-dir"] $ do
-- > doSomething
--
-- /NOTE: java.class.path does support relative paths./
runJava' opts f = do
str <- mapM newCString (augmentOpts opts)
ptr <- newArray str
vm <- JNI.createVM' (fromIntegral $ length str) ptr
mapM_ free str >> free ptr
if vm == nullPtr then do
libjvmPath <- JNI.getLibjvmPath >>= peekCString
throw $ JvmException libjvmPath opts
else return ()
(result, _) <- finally (runStateT (_runJava f) (newJVMState vm))
(JNI.destroyVM vm)
return result
#ifdef FFIJNI_DEBUG
augmentOpts = ("-Xcheck:jni" :)
#else
augmentOpts = id
#endif
runJavaGui :: Java a -> IO ()
-- ^ Short hand for @runJavaGui' []@.
runJavaGui = runJavaGui' []
runJavaGui' :: [String] -> Java a -> IO ()
-- ^ Mac OS X needs some special treatment for initializing
-- graphical applications, namely a Cocoa Runloop needs to be present
-- on the main thread. Since the main thread is the application
-- that the JVM was invoked from this has two consequences:
-- (1) A runloop needs to be created on the main thread
-- manually and (2) the main thread is not usable for your application.
--
-- On Mac OS X this function will fork an os thread using 'forkJava'
-- and start the Cocoa main event loop. This means that this function
-- must be called on the main thread and that it will never terminate
-- (since the cocoa event queue will be running there forever).
--
-- Note that this implies that you link your application with
-- the threaded runtime (`-threaded` in GHC).
--
-- Typically your application should look like this:
--
-- > main = runJavaGui $ do
-- > stuffYourApplicationDoes
--
-- On all other platforms this is exactly the same as 'runJava''
-- (minus the fact that it returns @()@).
#if defined(FFIJNI_MACOSX) && defined(FFIJNI_OSX_GUI)
runJavaGui' opts java = runJava' opts $ do
_ <- forkJava java
io JNI.runCocoaMain
#else
runJavaGui' opts javaGui = runJava' opts javaGui >> return ()
#endif
initJava :: [String] -> IO ()
-- ^ Initializes the Java Virtual Machine so that it can
-- be used by subsequent invocations of 'runJava'. Note that
-- once you start the virtual machine it will be runing throughout
-- the whole lifetime of the main thread of your application.
initJava opts = runJava' opts persistVM
persistVM :: Java ()
persistVM = do
vm <- getVM
liftIO $ JNI.persistVM vm
return ()
|
fehu/haskell-java-bridge-fork
|
src/Foreign/Java/JavaMonad.hs
|
mit
| 9,914 | 0 | 15 | 2,165 | 1,772 | 980 | 792 | 120 | 2 |
main = do
putStrLn "Hello, what's your name?"
name <- getLine
putStrLn ("Hey " ++ name ++ ", you rock!!")
|
rglew/lyah
|
getname.hs
|
mit
| 113 | 0 | 10 | 27 | 36 | 16 | 20 | 4 | 1 |
module Main where
import Data.List
import Data.Maybe
import Data.Char
-------------------------------------------------------------------------------------------------
----------------------------------------------- Parser ------------------------------------------
type Parser symbol result = [symbol] -> [([symbol], result)]
symbol :: Eq s => s -> Parser s s
--symbol _ [] = []
--symbol a (x:xs) = [(xs, a)] | a == x]
token :: Eq s => [s] -> Parser s [s]
--token k xs | k == take n xs = [(drop n xs, k)]
-- | otherwise = []
-- where n = length k
satisfy :: (s -> Bool) -> Parser s s
satisfy p [] = []
satisfy p (x:xs) = [(xs, x) | p x]
-- Ex 1
symbol a x = satisfy (a == ) x
epsilon :: Parser s ()
--epsilon xs = [(xs, ())]
succeed :: r -> Parser s r
succeed v xs = [(xs, v)]
epsilon = succeed ()
fail' :: Parser s r
fail' _ = []
infixr 6 <.>
infixr 4 <|>
(<.>) :: Parser s a -> Parser s b -> Parser s (a,b)
(p1 <.> p2) xs = [(xs2, (v1, v2)) | (xs1, v1) <- p1 xs,
(xs2, v2) <- p2 xs1]
(<|>) :: Parser s a -> Parser s a -> Parser s a
(p1 <|> p2) xs = p1 xs ++ p2 xs
spaces :: Parser Char a -> Parser Char a
spaces = ( . dropWhile ( == ' '))
just :: Parser s a -> Parser s a
--just = (filter (null . fst) . )
-- Ex 3
just p x = [([], y) | ([], y) <- p x]
infixr 5 <@
(<@) :: Parser s a -> (a -> b) -> Parser s b
(p <@ f) xs = [(ys, f v) | (ys, v) <- p xs]
digit :: Parser Char Int
digit = satisfy isDigit <@ f
where f c = ord c - ord '0'
type DeterministicParser symbol result = [symbol] -> result
some :: Parser s a -> DeterministicParser s a
some p = snd . head . just p
data Tree = TNil
| Bin (Tree, Tree) deriving Show
open_r = symbol '('
close_r = symbol ')'
infixr 6 <. , .>
(<.) :: Parser s a -> Parser s b -> Parser s a
p <. q = p <.> q <@ fst
(.>) :: Parser s a -> Parser s b -> Parser s b
p .> q = p <.> q <@ snd
parens :: Parser Char Tree
--parens = (
-- symbol '('
-- <.> parens
-- <.> symbol ')'
-- <.> parens
-- ) <@ (\(_, (x, (_, y))) -> Bin (x, y)
-- <|> epsilon <@ const TNil
parens = (open_r .> parens <. close_r) <.> parens <@ Bin
<|> succeed TNil
nesting :: Parser Char Int
nesting = (open_r .> nesting <. close_r) <.> nesting <@ f
<|> succeed 0
where f (a, b) = max (1 + a) b
foldparens :: ((a, a) -> a) -> a -> Parser Char a
foldparens f e = p
where p = (open_r .> p <. close_r) <.> p <@ f
<|> succeed e
many :: Parser s a -> Parser s [a]
--many p = p <.> many p <@ list
-- <|> succeed []
-- where list (x, xs) = x:xs
-- Lambdas! Lambdas everywhere.
many p = p <.> many p <@ (\(x, xs) -> x:xs)
<|> epsilon <@ (\_ -> [])
-- Ex 11
many1 :: Parser s a -> Parser s [a]
many1 p = p <.> many p <@ (\(x, xs) -> x:xs)
natural :: Parser Char Int
natural = many1 digit <@ foldl f 0
where f a b = a * 10 + b
option :: Parser s a -> Parser s [a]
option p = p <@ (\x -> [x])
<|> epsilon <@ (\_ -> [])
infixl 7 <*, <+, <?
infixr 6 <:.>
(<*) = many
(<+) = many1
(<?) = option
p1 <:.> p2 = p1 <.> p2 <@ (\ (x, xs) -> (x:xs))
pack :: Parser s a -> Parser s b -> Parser s c -> Parser s b
pack s1 p s2 = s1 .> p <. s2
open_s = symbol '['
close_s = symbol ']'
parenthesized p = pack open_r p close_r
bracketed p = pack open_s p close_s
listOf :: Parser s a -> Parser s b -> Parser s [a]
listOf p s = p <:.> ((s .> p) <*) <|> succeed []
commaList, normalList :: Parser Char a -> Parser Char [a]
commaList p = listOf p (token' ",")
normalList = bracketed . commaList . spaces
-- Ex 12
sequence' :: [Parser s a] -> Parser s [a]
--sequence' [] = succeed []
--sequence' (p:ps) = p <:.> sequence' ps
sequence' = foldr (<:.>) (succeed [])
choice :: [Parser s a] -> Parser s a
--choice [] = fail'
--choice (p:ps) = p <|> choice ps
choice = foldr (<|>) fail'
-- Ex 13
--token k = sequence' (map symbol k)
token = sequence' . map symbol
ap2 (op, y) = (`op` y)
chainl :: Parser s a -> Parser s (a -> a -> a) -> Parser s a
chainl p s = p <.> ((s <.> p) <*) <@ uncurry (foldl (flip ap2))
-- Ex 14
ap1 (y, op) = (y `op`)
chainr :: Parser s a -> Parser s (a -> a -> a) -> Parser s a
chainr p s = ((p <.> s) <*) <.> p <@ uncurry (flip (foldr ap1))
--(<@) :: Parser s a -> (a -> b) -> Parser s b
--(p <@ f) xs = [(ys, f v) | (ys, v) <- p xs]
infixl 5 <?@
(<?@) :: Parser s [a] -> (b, (a -> b)) -> Parser s b
p <?@ (no, yes) = p <@ f
where f x | length x == 0 = no
| length x == 1 = yes (head x)
-- Ex 15
integer :: Parser Char Int
--integer = ((symbol '-' <?) <?@ ((+), (\_ -> (-))))
-- <.> natural
-- <@ (\(op, y) -> 0 `op` y)
--where g (x, n) | x == '+' = n
-- | x == '-' = 0 - n
integer = ((symbol '-' <?) <?@ (id, const negate))
<.> natural
<@ (\(op, y) -> op y)
--ap1 (y, op) = (y `op`)
--ap2 (op, y) = (`op` y)
--chainr p s = ((p <.> s) <*) <.> p <@ uncurry (flip (foldr ap1))
ap3 (y, op) = (op y)
ap4 (op, y) = (op y)
chainr' :: Parser s a -> Parser s (a -> a -> a) -> Parser s a
chainr' p s = q
where q = p <.> (((s <.> q) <?) <?@ (id, ap2))
<@ ap3
--chainl' :: Parser s a -> Parser s (a -> a -> a) -> Parser s a
--chainl' p s = q
-- where q = (((q <.> s) <?) <?@ (id, ap1)) <.> p
-- <@ ap4
first :: Parser a b -> Parser a b
first p xs | null r = []
| otherwise = [head r]
where r = p xs
greedy = first . many
greedy1 = first . many1
compulsion = first . option
type Op a = ([Char], a -> a -> a)
genl :: [Op a] -> Parser Char a -> Parser Char a
genl ops p = chainl p (choice (map f ops))
where f (t, e) = token' t <@ const e
genop :: (Char, [Op a]) -> Parser Char a -> Parser Char a
genop (a, op) p =
chain p (choice (map
(\ (t, e)-> token' t <@ const e) op))
where
chain | a == 'r' = chainr
| a == 'l' = chainl
| a == 'i' = \ pr s -> pr <|> (pr <.> s <.> pr <@ \ (a, (f, b)) -> f a b)
gen :: Parser Char a -> [(Char, [Op a])] -> Parser Char a
gen = foldr genop
token' x = spaces (token x)
----------------------- MicroHaskell begin --------------------
type Fname = String
type Var = String
data Program = Prog [Fundef] Exp deriving Show
data Fundef = Fun String [String] Exp deriving Show
data Exp = I Int | V Var | B Bool | Nil |
Fname String |
App Exp Exp deriving Show
type ExpParser = Parser Char Exp
keywords = ["if",
"then",
"else",
"car",
"cdr",
"null"]
----------------------- Helper functions --------------------
pair2Exp :: (Exp, Exp) -> Exp
pair2Exp (x, y) = App x y
isWord, isStartWord :: Char -> Bool
isWord x = isAlphaNum x || (x == '_')
isStartWord x = isAlpha x || (x == '_')
isKeyword :: [ Char ] -> Bool
isKeyword x = x `elem` keywords
word, name :: Parser Char [ Char ]
word = (satisfy isStartWord <:.> (satisfy (isWord) <*))
name x = [(a, b) | (a, b) <- (spaces (first word) x),
not (isKeyword b)]
funargs :: [Exp] -> Exp
funargs [x] = x
funargs (x:xs) = foldl (\ x y -> App x y) x xs
optofun :: [Char] -> Exp -> Exp -> Exp
optofun f x y = App (App (Fname f) x) y
args :: Parser Char [[ Char ]]
args = name <:.> (name <*) <|> succeed []
newlines :: Parser Char [ Char ]
newlines = (spaces (symbol '\n') <*)
-------------------------------------------------------------
-------------------------------------------------------------
---------------------- Constant Terms -----------------------
intlit, boollit, nil, constant :: ExpParser
intlit = integer <@ I
boollit = ((token' "True" <|> token' "False") <@ f)
where f x | x == "True" = B True
| x == "False" = B False
nil = token' "[" <.> token' "]" <@ f
where f _ = Nil
constant = first (intlit <|> boollit <|> nil)
-------------------------------------------------------------
-------------------------------------------------------------
------------------------- User terms ------------------------
variable, fname :: ExpParser
variable = name <@ V
fname = name <@ Fname
-------------------------------------------------------------
-------------------------------------------------------------
-------------------- Grammar Constructs ---------------------
cons = optofun "cons"
addis = [ ("+", optofun "+"),
("-", optofun "-")]
multis = [ ("*", optofun "*"),
("/", optofun "/")]
function, ifstmt :: ExpParser
function = fname <.> (term <*)
<@ (\ (x, y) -> if length y == 0 then x
else funargs (x:y))
ifstmt = ((token' "if" .> expr
<@ (\ y -> App (Fname "If") y))
<.> token' "then" .> expr
<@ pair2Exp)
<.> token' "else" .> expr
<@ pair2Exp
car, cdr, nul :: ExpParser
car = token' "car" .> term <@ (\ x -> App (Fname "car") x)
cdr = token' "cdr" .> term <@ (\ x -> App (Fname "cdr") x)
nul = token' "null" .> term <@ (\ x -> App (Fname "null") x)
term, expr :: ExpParser
term = spaces(
constant
<|> variable
<|> ifstmt
<|> car
<|> cdr
<|> nul
<|> function
<|> ((normalList expr) <@ foldr cons Nil)
<|> parenthesized expr
)
expr = gen term [ ('i', [("==", optofun "==")]),
('r', [(":", cons)]),
('l', addis),
('l', multis)
]
fundef :: Parser Char Fundef
fundef = (name <.> args <.> token' "=" .> expr)
<@ \ (f, (as, e)) -> Fun f as e
funs :: Parser Char [ Fundef ]
funs = (listOf fundef newlines) <. token' "\n"
program :: Parser Char Program
program = funs <.> expr <. newlines <@ \ (fs, e) -> Prog fs e
----------------------- Parser output -------------------------
ptext (Prog fs e) = unlines ((map show fs) ++ [show e])
parse x = (some program x)
-------------------------------------------------------------------------------------------------
------------------------------------------- Compiler --------------------------------------------
type Code = [Instn]
data Instn = PUSH Int | PUSHINT Int | PUSHGLOBAL String |
PUSHBOOL Bool | PUSHNIL | POP Int |
EVAL | UNWIND | MKAP | UPDATE Int | RETURN |
LABEL String | JUMP String | JFALSE String |
ADD | SUB | MUL | DIV | CONS | HEAD | TAIL | IF | EQU |
GLOBSTART String Int | PRINT | STOP
instance Show Instn where
show (PUSH i) = " PUSH " ++ show i ++ "\n"
show (PUSHINT i) = " PUSHINT " ++ show i ++ "\n"
show (PUSHGLOBAL str) = " PUSHGLOBAL " ++ show str ++ "\n"
show (PUSHBOOL i) = " PUSH " ++ show i ++ "\n"
show PUSHNIL = " PUSHNIL " ++ "\n"
show (POP i) = " POP " ++ show i ++ "\n"
show EVAL = " EVAL" ++ "\n"
show UNWIND = " UNWIND" ++ "\n"
show MKAP = " MKAP" ++ "\n"
show RETURN = " RETURN" ++ "\n"
show (UPDATE i) = " UPDATE " ++ show i ++ "\n"
show (LABEL str) = "LABEL " ++ show str ++ "\n"
show (JUMP str) = " JUMP " ++ show str ++ "\n"
show (JFALSE str) = " JFALSE " ++ show str ++ "\n"
show ADD = " ADD" ++ "\n"
show SUB = " SUB" ++ "\n"
show MUL = " MUL" ++ "\n"
show DIV = " DIV" ++ "\n"
show CONS = " CONS" ++ "\n"
show HEAD = " HEAD" ++ "\n"
show TAIL = " TAIL" ++ "\n"
show IF = " IF" ++ "\n"
show EQU = " EQU" ++ "\n"
show (GLOBSTART str i) = "\n GLOBSTART " ++ show str ++ " " ++ show i ++ "\n"
show PRINT = " PRINT" ++ "\n"
show STOP = " STOP" ++ "\n"
gencpgm :: Program -> Code
gencpgm (Prog fs e) = foldr gencfun (gencmain e) fs
gencfun :: Fundef -> Code -> Code
gencfun (Fun fname args body) code = GLOBSTART fname (length args) :
expcode body var_position (length args) (unwind_pop args code)
where var_position name = fromJust (elemIndex name args) + 1
unwind_pop :: [String] -> Code -> Code
unwind_pop [] code = UPDATE 1 : UNWIND : code
unwind_pop args code = UPDATE (length args + 1) : POP (length args) : UNWIND : code
gencmain :: Exp -> Code
gencmain e = LABEL "MAIN" : expcode e (\x -> 0) 0 (EVAL : PRINT : STOP: builtins)
expcode :: Exp -> (String -> Int) -> Int -> Code -> Code
expcode (App e1 e2) s d code = expcode e2 s d (expcode e1 s (d + 1) (MKAP : code))
expcode exp s d code = expinst exp : code
where
expinst (I i) = PUSHINT i
expinst (B b) = PUSHBOOL b
expinst (V v) = PUSH (d - s v)
expinst Nil = PUSHNIL
expinst (Fname f) = PUSHGLOBAL f
builtins :: Code
builtins = concat (map builtin ["cons", "head", "tail", "if", "null", "+", "-", "*", "=="])
builtin :: String -> Code
--builtin "not" = [GLOBSTART "not", EVAL, NEG, UPDATE 1, RETURN]
builtin "cons" = [GLOBSTART "cons" 2, CONS, UPDATE 1, RETURN]
builtin "head" = [GLOBSTART "car" 1, EVAL, HEAD, EVAL, UPDATE 1, UNWIND]
builtin "tail" = [GLOBSTART "cdr" 1, EVAL, TAIL, EVAL, UPDATE 1, UNWIND]
builtin "null" = [GLOBSTART "null" 1, EVAL, PUSHNIL, EQU, UPDATE 1, UNWIND]
builtin "if" = [ GLOBSTART "if" 3,
PUSH 0,
EVAL,
JFALSE "1",
PUSH 1,
JUMP "2",
LABEL "1",
PUSH 2,
LABEL "2",
EVAL,
UPDATE 4,
POP 3,
UNWIND ]
builtin "+" = binarybuiltin "+"
builtin "-" = binarybuiltin "-"
builtin "*" = binarybuiltin "*"
builtin "/" = binarybuiltin "/"
builtin "==" = binarybuiltin "=="
binarybuiltin :: String -> Code
binarybuiltin op = [ GLOBSTART op 2,
PUSH 1,
EVAL,
PUSH 1,
EVAL,
opcode op,
UPDATE 3,
POP 2,
UNWIND ]
where
opcode "+" = ADD
opcode "-" = SUB
opcode "*" = MUL
opcode "/" = DIV
opcode "==" = EQU
-------------------------------------------------------------------------------------------------
--------------------------------------------- Interpreter ---------------------------------------
type Tag = Int
type Label = String
type Stack = [Tag]
data Node = NApp Tag Tag
| NDef Label Int Code
| NInt Int
| NBool Bool
| NNil
| NCons Tag Tag
deriving Show
type Heap = [(Tag, Node)]
type Dump = [(Code, Stack)]
type Globals = [(Tag, Label)]
type Output = [String]
type State = (Stack, Heap, Code, Dump, Globals, Output)
run :: Code -> Output
run code = output
where
(main, func) = extract_main code
(init_heap, globals) = find_globals func
(_, _, _, _, _, output) = eval ([], init_heap, main, [], globals, [])
extract_main ((LABEL l):code) = if l == "MAIN" then func_code code else extract_main code
extract_main (c:code) = (m, c:cs)
where (m, cs) = extract_main code
base_heap :: Heap
base_heap = [(2, NBool False), (1, NBool True), (0, NNil)]
find_globals :: Code -> (Heap, Globals)
find_globals [] = (base_heap, [])
find_globals ((GLOBSTART label nargs):cs) = ((tag, NDef label nargs cs'):h, (tag, label):g)
where
(cs', cs'') = func_code cs
(h, g) = find_globals cs''
tag = length h
find_globals (_:cs) = find_globals cs
func_code :: Code -> (Code, Code)
func_code [] = ([], [])
func_code cs@((GLOBSTART _ _):_) = ([], cs)
func_code (c:cs) = (c:cs', cs'')
where
(cs', cs'') = func_code cs
eval:: State -> State
eval (n:s, h, EVAL:c, d, g, o) = f top ------ EVAL
where
top = lookup_tag h n
f (NApp t1 t2) = eval ([n], h, [UNWIND], (c, s):d, g, o)
f (NDef _ 0 c') = eval (n:s, h'', c, d, g, o')
where
([t], h', _, _, _, o') = eval ([n], h, c', [([],[])], g, o)
h'' = update_heap h' n (lookup_tag h' t)
f _ = eval (n:s, h, c, d, g, o)
eval (n:s, h, [UNWIND], d, g, o) = f top ------- UNWIND
where
top = lookup_tag h n
(cs, s'):d' = d
f (NApp t1 _) = eval (t1:n:s, h, [UNWIND], d, g, o)
f (NDef _ k c) = eval (if length s < k then (last s:s', h, cs, d', g, o) else (nks, h, c, d, g, o))
where
(vs, s'') = split s k
vk = vs!!(k - 1)
nodes = map (lookup_tag h) vs
nks = foldr (\ (NApp _ n) y -> n:y) (vk:s'') nodes
f _ = eval (n:s', h, cs, d', g, o)
eval (s, h, [RETURN], (cs, s'):d, g, o) = eval (last s:s', h, cs, d, g, o) ------- RETURN
eval (s, h, JUMP label:cs, d, g, o) = eval (s, h, cs', d, g, o) ------- JUMP
where cs' = after label cs
eval (n:s, h, JFALSE label:cs, d, g, o) = eval state ------- JFALSE
where
NBool b = lookup_tag h n
cs' = after label cs
state | b = (s, h, cs, d, g, o)
| otherwise = (s, h, cs', d, g, o)
eval (s, h, PUSH k:cs, d, g, o) = eval ((s!!k):s, h, cs, d, g, o) ------- PUSH
eval (s, h, PUSHINT i:cs, d, g, o) = eval (t:s, (t, n):h, cs, d, g, o) ------- PUSHINT
where
t = length h
n = NInt i
eval (s, h, PUSHBOOL b:cs, d, g, o) = eval (t:s, h, cs, d, g, o) ------- PUSHBOOL
where t = if b then 1 else 2
eval (s, h, PUSHNIL:cs, d, g, o) = eval (0:s, h, cs, d, g, o) ------- PUSHNIL
eval (s, h, PUSHGLOBAL f:cs, d, g, o) = eval (t:s, h, cs, d, g, o) ------- PUSHGLOBAL
where t = lookup_global f g
eval (s, h, POP k:cs, d, g, o) = eval (s', h, cs, d, g, o) ------- POP
where (_, s') = split s k
eval (s@(t:s'), h, UPDATE k:cs, d, g, o) = eval (s', h', cs, d, g, o) ------- UPDATE
where
node = lookup_tag h t
nk = s!!k
h' = update_heap h nk node
eval (t:s, h, HEAD:cs, d, g, o) = eval (t1:s, h, cs, d, g, o) ------- HEAD
where NCons t1 _ = lookup_tag h t
eval (t:s, h, TAIL:cs, d, g, o) = eval (t2:s, h, cs, d, g, o) ------- TAIL
where NCons _ t2 = lookup_tag h t
eval (t1:t2:s, h, ADD:cs, d, g, o) = eval (t:s, (t, node):h, cs, d, g, o) ------- ADD
where (t, node) = binary_op ADD t1 t2 h
eval (t1:t2:s, h, SUB:cs, d, g, o) = eval (t:s, (t, node):h, cs, d, g, o) ------- SUB
where (t, node) = binary_op SUB t1 t2 h
eval (t1:t2:s, h, MUL:cs, d, g, o) = eval (t:s, (t, node):h, cs, d, g, o) ------- MUL
where (t, node) = binary_op MUL t1 t2 h
eval (t1:t2:s, h, DIV:cs, d, g, o) = eval (t:s, (t, node):h, cs, d, g, o) ------- DIV
where (t, node) = binary_op DIV t1 t2 h
eval (t1:t2:s, h, EQU:cs, d, g, o) = eval (t:s, h, cs, d, g, o) ------- EQU
where (t, _) = binary_op EQU t1 t2 h
eval (t1:t2:s, h, MKAP:cs, d, g, o) = eval (t:s, (t, NApp t1 t2):h, cs, d, g, o) ------- MKAP
where t = length h
eval (t1:t2:s, h, CONS:cs, d, g, o) = eval (t:s, (t, NCons t1 t2):h, cs, d, g, o) ------- CONS
where t = length h
eval (s, h, LABEL _:cs, d, g, o) = eval (s, h, cs, d, g, o) ------- LABEL
eval (t:s, h, PRINT:cs, d, g, o) = f top ------- PRINT
where
top = lookup_tag h t
f (NInt i) = eval (s, h, cs, d, g, (show i):o)
f (NBool b) = eval (s, h, cs, d, g, (show b):o)
f (NCons t1 t2) = eval (t1:t2:s, h, EVAL:PRINT:EVAL:PRINT:cs, d, g, o)
f (NApp t1 t2) = eval (t:s, h, EVAL:PRINT:cs, d, g, o)
f _ = eval (s, h, cs, d, g, o)
eval (s, h, STOP:cs, d, g, o) = (s, h, [], d, g, o) ------- STOP
eval (s, h, [], d, g, o) = (s, h, [], d, g, o)
after :: Label -> Code -> Code
after l (LABEL x:cs) = if x == l then cs else after l cs
after l (_:cs) = after l cs
split :: [a] -> Int -> ([a], [a])
split xs 0 = ([], xs)
split (x:xs) n = (x:xs', xs'')
where (xs', xs'') = split xs (n - 1)
lookup_global :: Label -> Globals -> Tag
--lookup_global label [] = -1
lookup_global label ((tag, l):gs) | label == l = tag
| otherwise = lookup_global label gs
lookup_tag :: Heap -> Tag -> Node
--lookup_tag ((t, n):h) k | t == k = n
-- | otherwise = lookup_tag h k
lookup_tag h t = snd (h!!(length h - t - 1))
update_heap :: Heap -> Tag -> Node -> Heap
update_heap ((t, n):h) k node | k == t = (t, node):h
| otherwise = (t, n):update_heap h k node
binary_op :: Instn -> Tag -> Tag -> Heap -> (Tag, Node)
binary_op EQU t1 t2 h = (t, NBool b)
where
t = if b then 1 else 2
b = is_equal (lookup_tag h t1) (lookup_tag h t2)
is_equal (NInt a) (NInt b) = a == b
is_equal (NBool a) (NBool b) = a == b
is_equal NNil NNil = True
is_equal _ _ = False
binary_op op_code t1 t2 h = (t, node)
where
t = length h
op = code_fun op_code
NInt n1 = lookup_tag h t1
NInt n2 = lookup_tag h t2
node = NInt (n1 `op` n2)
code_fun ADD = (+)
code_fun SUB = (-)
code_fun MUL = (*)
code_fun DIV = div
main = do
input <- readFile "pfile"
let
code = (gencpgm . parse) input
output = run code
putStr (concat output ++ "\n")
|
murukeshm/scratchpad
|
haskell/133059001.hs
|
gpl-2.0
| 19,765 | 336 | 19 | 5,047 | 9,630 | 5,294 | 4,336 | 458 | 11 |
{- Programa Haskell -}
|
saxsoares/PARADIGMAS
|
HASKELL/haskell1.hs
|
gpl-2.0
| 24 | 0 | 2 | 5 | 3 | 2 | 1 | 1 | 0 |
{- |
Module : $EmptyHeader$
Description : <optional short description entry>
Copyright : (c) <Authors or Affiliations>
License : GPLv2 or higher, see LICENSE.txt
Maintainer : <email>
Stability : unstable | experimental | provisional | stable | frozen
Portability : portable | non-portable (<reason>)
<optional description>
-}
module Search.SPASS.UnWrap where
import Data.List as L (nubBy,partition)
import Data.Set (Set,empty,insert,union,unions,fromList,toList)
import Common.AS_Annotation
import SoftFOL.DFGParser
import SoftFOL.Sign
import SoftFOL.Print (printFormula)
import Text.ParserCombinators.Parsec
import Search.Common.Data
import Search.Common.Normalization --(normalize,Formula,Const,TrueAtom)
import Search.SPASS.FormulaWrapper (wrapTerm,SpassConst)
import Search.DB.Connection (multiInsertProfiles,insertStatistics,ProfileTuple)
type DFGSkeleton = Formula (Constant SpassConst) Int
type DFGFormula = (SPTerm, LineNr, Role)
type DFGParameter = String
-- (lib,theory,lineNr,spterm,skel,pars,role,strength)
type DFGProfile = Profile SPTerm DFGSkeleton DFGParameter
readDFGFormulae :: SourceName -> IO [DFGFormula]
readDFGFormulae file = (readProblem file) >>= (return . getDFGFormulae)
readProblem :: SourceName -> IO SPProblem
readProblem filePath =
do result <- parseFromFile parseSPASS filePath
case result
of Left err -> error $ show err
Right spproblem -> return spproblem
dfgNormalize (lib,theory) (spterm, lineNr, role) =
Profile lib theory lineNr spterm skel pars role strength
where (skel,pars,strength) = normalize $ wrapTerm spterm
getDFGFormulae :: SPProblem -> [DFGFormula]
getDFGFormulae spproblem = concatMap unWrapFormulaList flsts
where (SPProblem _ _ (SPLogicalPart _ _ flsts _ _) _) = spproblem
unWrapFormulaList :: SPFormulaList -> [DFGFormula]
unWrapFormulaList flst = map (toDFGFormula role) (formulae flst)
where role = case originType flst
of SPOriginAxioms -> Axiom
SPOriginConjectures -> Theorem
toDFGFormula :: Role -> Named SPTerm -> (SPTerm, Int, Role)
toDFGFormula role sen = (spterm, lineNr, role)
where spterm = unType $ sentence sen
lineNr = read $ senAttr sen
unType :: SPTerm -> SPTerm
unType (SPSimpleTerm s) = (SPSimpleTerm s)
unType (SPComplexTerm s ts) = (SPComplexTerm s (map unType ts))
unType (SPQuantTerm q vs t) =
let isSyimpleTerm (SPSimpleTerm _) = True
isSyimpleTerm _ = False
in case partition isSyimpleTerm vs
of (vs',[]) -> SPQuantTerm q vs t
(vs',tvs) -> SPQuantTerm q mergedVars (compose q)
where vs'' = unions $ map (vars empty) tvs
mergedVars = toList $ union (fromList vs') vs''
wrapAnd [t] = t
wrapAnd ts = SPComplexTerm SPAnd tvs
compose SPForall = SPComplexTerm SPImplies [wrapAnd tvs, t]
compose SPExists = SPComplexTerm SPAnd (t:tvs)
compose _ = error "don't know how to untype this"
-- vars assumes quantifier free expressions
vars :: Set SPTerm -> SPTerm -> Set SPTerm
vars vs (SPSimpleTerm s) = insert (SPSimpleTerm s) vs
vars vs (SPComplexTerm _ ts) = unions $ (vs : (map (vars empty) ts))
vars _ _ = error "vars is not intended to handle quantified expressions."
f1 = "/home/immanuel/programming/casl/overloading_s1.dfg"
f2 = "/home/immanuel/dfg/query-files/test.dfg"
printDFGFormula (t,_,_) = printFormula $ makeNamed "" t
showTest = do [f] <- readDFGFormulae f2
return $ printDFGFormula f
|
nevrenato/Hets_Fork
|
Search/SPASS/UnWrap.hs
|
gpl-2.0
| 3,593 | 1 | 15 | 761 | 991 | 524 | 467 | 64 | 6 |
module Display(display) where
import Expr
import Data.ByteString.Char8 hiding (head, replicate)
data Child = Leaf
| Child1 Size
| Child2 Size Size
type DStr = String -> String
type Size = ((Int,Int,Int),Child)
height :: Size -> Int
height ((t,b,_),_) = b-t+1
display :: Expr -> ByteString
display e = pack $ ($"") $ line e
char :: Char -> DStr
char = (:)
digit :: Int -> DStr
digit = (:) . head . show
str :: String -> DStr
str = (++)
line :: Expr -> DStr
line e = let (s@((t,b,_),_),d) = line' e t b s in d
line' :: Expr -> Int -> Int -> Size -> (Size, DStr)
line' e y b z = let
(s,d) = disp e y z
(_,r) = line' e (y-1) b s
in (s,if y < b then id else d.char '\n'.r)
ope :: Ope -> Char
ope Plus = '+'
ope Minus = '-'
ope Mult = '*'
paren :: Int -> DStr -> DStr
paren 0 s = str "( ".s.str " )"
paren d s = str " ".s.str " "
spaceWrap :: DStr -> DStr
spaceWrap s = char ' '.s.char ' '
spaces :: Int -> DStr
spaces n = str $ replicate n ' '
disp :: Expr -> Int -> Size -> (Size, DStr)
disp e@(Bi o le re) y ~(_,Child2 ls rs) = let
(vl@((tl,bl,wl),_),sl) = disp le y ls
(vr@((tr,br,wr),_),sr) = disp re y rs
top = max tl tr
bot = min bl br
wl' = wl + if e>le then 4 else 0
sl' = bound y (tl,bl,wl') $ if e>le then paren y sl else sl
wr' = wr + if e>re then 4 else 0
sr' = bound y (tr,br,wr') $ if e>re then paren y sr else sr
wid = wl'+3+wr'
s = spaceWrap $ char $ if y == 0 then ope o else ' '
in (((top,bot,wid),Child2 vl vr),sl'.s.sr')
disp n@(Neg e) y ~(_,Child1 s) = let
(v@(yp@(t,b,w),_),ss) = disp e y s
sign = bound y (0,0,2) $ str "- "
in case e of
Bi o _ _
| o /= Mult -> (((t,b,w+6),Child1 v),sign.paren y ss)
_ -> (((t,b,w+2),Child1 v),sign.ss)
disp e@(Pow le re) y ~(_,Child2 ls rs@((_,rb,_),_)) = let
(vl@((tl,bl,wl),_),sl) = disp le y ls
(vr@(yr@(tr,br,wr),_),sr) = disp re (y-1+rb) rs
top = max tl (tr-br+1)
wl' = wl + if e>=le then 4 else 0
sl' = bound y (tl,bl,wl') $ if e>=le then paren y sl else sl
sr' = bound (y-1+rb) yr sr
wid = wl'+wr
in (((top,bl,wid),Child2 vl vr),sl'.sr')
disp e@(Frac le re) y ~(_,Child2 ls@((lt,lb,_),_) rs@((rt,rb,_),_)) = let
(vl@((tl,bl,wl),_),sl) = disp le (y-1+lb) ls
(vr@((tr,br,wr),_),sr) = disp re (y+1+rt) rs
top = tl-bl+1
bot = br-tr-1
wid = max wl wr + 2
sl' = widen wid wl sl
sr' = widen wid wr sr
s = str $ replicate wid '-'
ss = if y > 0 then sl' else if y == 0 then s else sr'
in (((top,bot,wid),Child2 vl vr),ss)
disp (Digit d) y _ = (((0,0,1),Leaf),if y == 0 then digit d else char ' ')
disp _ _ _ = undefined
bound :: Int -> (Int, Int, Int) -> DStr -> DStr
bound y (t,b,w) s = let
in if b <= y && y <= t then s else spaces w
widen :: Int -> Int -> DStr -> DStr
widen w c s = let
a = (w-c)`div`2
b = (w-c+1)`div`2
in spaces a.s.spaces b
|
phi16/ASCIIize
|
Display.hs
|
gpl-3.0
| 2,906 | 0 | 14 | 796 | 1,899 | 1,053 | 846 | 86 | 12 |
{-# LANGUAGE OverloadedStrings #-}
-- | Properties from the org.mpris.MediaPlayer2.Player interface
--
-- All properties are currently read-only
--
-- More information at <http://specifications.freedesktop.org/mpris-spec/latest/Player_Interface.html>
module DBus.Mpris.MediaPlayer2.Player.Properties
( PlaybackStatus(..)
, playbackStatus
, LoopStatus(..)
, loopStatus
, rate
, shuffle
, Metadata(..)
, metadata
, volume
, setVolume
, position
, minimumRate
, maximumRate
, canGoNext
, canGoPrevious
, canPlay
, canPause
, canSeek
, canControl
) where
import DBus
import Data.Map
import Data.Int (Int64)
import Data.Word (Word64)
import Control.Applicative ((<$>), (<|>))
import Control.Monad (liftM)
import Control.Monad.Trans (liftIO)
import Prelude hiding (lookup)
import qualified DBus.Mpris.Properties as P
import DBus.Mpris.Monad
import DBus.Mpris.MediaPlayer2.Player.Data as Data
unpackIntM :: Mpris (Maybe Int64) -> Mpris (Maybe Integer)
unpackIntM = liftM . liftM $ fromIntegral
readM :: Read a => Mpris (Maybe String) -> Mpris (Maybe a)
readM = liftM . liftM $ read
property :: IsVariant a => String -> BusName -> Mpris (Maybe a)
property = P.getProperty "org.mpris.MediaPlayer2.Player"
setProperty :: IsVariant a => String -> BusName -> a -> Mpris ()
setProperty = P.setProperty "org.mpris.MediaPlayer2.Player"
-- | The current playback status.
playbackStatus :: BusName -> Mpris (Maybe PlaybackStatus)
playbackStatus = readM . property "PlaybackStatus"
-- | The current loop / repeat status
loopStatus :: BusName -> Mpris (Maybe LoopStatus)
loopStatus = readM . property "LoopStatus"
-- | The current playback rate.
rate :: BusName -> Mpris (Maybe Double)
rate = property "Rate"
-- | A value of 'False' indicates that playback is progressing
-- linearly through a playlist, while 'True' means playback is
-- progressing through a playlist in some other order.
shuffle :: BusName -> Mpris (Maybe Bool)
shuffle = property "Shuffle"
-- | The metadata of the current element.
metadata :: BusName -> Mpris (Maybe Metadata)
metadata bus = fmap (\md -> Metadata {
trackId = lookup "mpris:trackid" md >>= fromVariant
, len = fmap fromInt (lookup "mpris:length" md >>= fromVariant) <|>
fmap fromWord (lookup "mpris:length" md >>= fromVariant)
, album = lookup "xesam:album" md >>= fromVariant
, artist = head <$> (lookup "xesam:artist" md >>= fromVariant)
, title = lookup "xesam:title" md >>= fromVariant
, url = lookup "xesam:url" md >>= fromVariant
, unknown = md
}) `liftM` property "Metadata" bus
where fromInt :: Int64 -> Integer
fromInt = fromIntegral
fromWord :: Word64 -> Integer
fromWord = fromIntegral
-- | The volume level.
volume :: BusName -> Mpris (Maybe Double)
volume = property "Volume"
-- | Set volume level.
setVolume :: BusName -> Double -> Mpris ()
setVolume = setProperty "Volume"
-- | The current track position in microseconds, between 0 and the
-- 'mpris:length' metadata entry (see Metadata).
position :: BusName -> Mpris (Maybe Integer)
position = unpackIntM . property "Position"
-- | The minimum value which the Rate property can take.
minimumRate :: BusName -> Mpris (Maybe Double)
minimumRate = property "MinimumRate"
-- | The maximum value which the Rate property can take.
maximumRate :: BusName -> Mpris (Maybe Double)
maximumRate = property "MaximumRate"
-- | Whether the client can call the 'next' method on this interface and
-- expect the current track to change.
canGoNext :: BusName -> Mpris (Maybe Bool)
canGoNext = property "CanGoNext"
-- | Whether the client can call the 'previous' method on this interface
-- and expect the current track to change.
canGoPrevious :: BusName -> Mpris (Maybe Bool)
canGoPrevious = property "CanGoPrevious"
-- | Whether playback can be started using 'play' or 'playPause'.
canPlay :: BusName -> Mpris (Maybe Bool)
canPlay = property "CanPlay"
-- | Whether playback can be paused using 'pause' or 'playPause. '
canPause :: BusName -> Mpris (Maybe Bool)
canPause = property "CanPause"
-- | Whether the client can control the playback position using 'seek'
-- and 'setPosition'.
canSeek :: BusName -> Mpris (Maybe Bool)
canSeek = property "CanSeek"
-- | Whether the media player may be controlled over this interface.
canControl :: BusName -> Mpris (Maybe Bool)
canControl = property "CanControl"
|
Fuco1/mpris
|
src/DBus/Mpris/MediaPlayer2/Player/Properties.hs
|
gpl-3.0
| 4,491 | 0 | 15 | 860 | 987 | 545 | 442 | 85 | 1 |
module Main where
gerarLinha :: Int -> Int -> Int -> [Int] -> [Int]
gerarLinha x xA n listaI
| xA >= n = listaI
| otherwise = (funcaoAuxiliar x xA) : (gerarLinha x (xA+1) n listaI)
funcaoAuxiliar :: Int -> Int -> Int
funcaoAuxiliar x xA
| x == xA = 1
| otherwise = 0
gerarMatrizIdentidade :: Int -> [[Int]]
gerarMatrizIdentidade n = [gerarLinha x 0 n [] | x<-[0..n-1]]
somaDiagonal :: [[Int]] -> Int
somaDiagonal matriz = sum [(matriz !! x)!!x | x <- [0..((length matriz)-1)]]
somaDiagonalSecundaria :: [[Int]] -> Int
somaDiagonalSecundaria matriz = sum [(matriz !! x)!!(((length matriz)-1)-x) | x <- [0..((length matriz)-1)]]
main :: IO()
main = do
print(somaDiagonalSecundaria (gerarMatrizIdentidade 6))
print(somaDiagonalSecundaria (gerarMatrizIdentidade 7))
print(somaDiagonalSecundaria ([[1,2,3],[4,5,6],[7,8,9]]))
|
llscm0202/BIGDATA2017
|
ATIVIDADE1/exerciciosMatrizes/ex3.hs
|
gpl-3.0
| 850 | 0 | 13 | 151 | 445 | 236 | 209 | 20 | 1 |
-- Parser generated by Pappy - do not edit
module Lojban where
import Pappy.Pos
import Pappy.Parse
import Pappy.Basic
{-# LINE 4 "Lojban.pappy" #-}
import JboSyntax
import Logic hiding (Term,Connective)
import Data.Maybe
import Control.Monad.State
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Char (isSpace, isDigit, digitToInt)
data JekJoik = JJJek LogJboConnective | JJJoik Joik
jjJboCon :: (Maybe Tag) -> JekJoik -> Connective
jjJboCon mtag (JJJek lcon) = jboConnLogOrQ mtag lcon
jjJboCon mtag (JJJoik joik) = JboConnJoik mtag joik
jboConnLogOrQ mtag (LogJboConnective _ 'i' _) = JboConnJoik mtag "??"
jboConnLogOrQ mtag lcon = JboConnLog mtag lcon
{-# LINE 1130 "Lojban.pappy" #-}
data LojbanDerivs = LojbanDerivs {
lojbanSub0 :: LojbanDerivs0,
lojbanSub1 :: LojbanDerivs1,
lojbanSub2 :: LojbanDerivs2,
lojbanSub3 :: LojbanDerivs3,
lojbanSub4 :: LojbanDerivs4,
lojbanChar :: Result LojbanDerivs Char,
lojbanPos :: Pos
}
instance Derivs LojbanDerivs where
dvChar d = lojbanChar d
dvPos d = lojbanPos d
data LojbanDerivs0 = LojbanDerivs0 {
lojbanSubStarRule0 :: Result LojbanDerivs ([String]),
lojbanSubfree :: Result LojbanDerivs (Free),
lojbanSubStarRule1 :: Result LojbanDerivs ([COI]),
lojbanSubPlusRule1 :: Result LojbanDerivs ([COI]),
lojbanSubcoi :: Result LojbanDerivs (COI),
lojbanSubindicator :: Result LojbanDerivs (Free),
lojbanSubStarRule3 :: Result LojbanDerivs ([String]),
lojbanSubtext :: Result LojbanDerivs (Text),
lojbanSubStarRule4 :: Result LojbanDerivs ([Free]),
lojbanSubtext1 :: Result LojbanDerivs ([Paragraph]),
lojbanSubPlusRule4 :: Result LojbanDerivs ([String]),
lojbanSubparagraphs :: Result LojbanDerivs ([Paragraph]),
lojbanSubStarRule5 :: Result LojbanDerivs ([Maybe (Either Fragment Statement)]),
lojbanSubstatementOrFragment :: Result LojbanDerivs (Either Fragment Statement),
lojbanSubstatement :: Result LojbanDerivs (Statement),
lojbanSubStarRule9 :: Result LojbanDerivs ([(Connective, Statement1)]),
lojbanSubstatement2 :: Result LojbanDerivs (Statement1),
lojbanSubtermsAndTail :: Result LojbanDerivs (([Term],BridiTail)),
lojbanSubsubsentence :: Result LojbanDerivs (Subsentence)}
data LojbanDerivs1 = LojbanDerivs1 {
lojbanSubbridiTail :: Result LojbanDerivs (BridiTail),
lojbanSubStarRule13 :: Result LojbanDerivs ([(Connective, BridiTail, [Term])]),
lojbanSubbridiTail2 :: Result LojbanDerivs (BridiTail),
lojbanSubgekSentence :: Result LojbanDerivs (GekSentence),
lojbanSubStarRule14 :: Result LojbanDerivs ([Term]),
lojbanSubPlusRule5 :: Result LojbanDerivs ([Term]),
lojbanSubterms1 :: Result LojbanDerivs (Term),
lojbanSubPlusRule6 :: Result LojbanDerivs ([Term]),
lojbanSubterm :: Result LojbanDerivs (Term),
lojbanSubtermsGikTerms :: Result LojbanDerivs (([Term],Bool,[Term])),
lojbanSubsumti :: Result LojbanDerivs (Sumti),
lojbanSubStarRule15 :: Result LojbanDerivs ([(Connective, Sumti)]),
lojbanSubsumti3 :: Result LojbanDerivs (Sumti),
lojbanSubsumti4 :: Result LojbanDerivs (Sumti),
lojbanSubsumti6 :: Result LojbanDerivs (SumtiAtom),
lojbanSubqualifier :: Result LojbanDerivs (SumtiQualifier),
lojbanSubPlusRule7 :: Result LojbanDerivs ([String]),
lojbanSubStarRule17 :: Result LojbanDerivs ([String])}
data LojbanDerivs2 = LojbanDerivs2 {
lojbanSubStarRule18 :: Result LojbanDerivs ([String]),
lojbanSubStarRule19 :: Result LojbanDerivs ([String]),
lojbanSubsumtiTail1 :: Result LojbanDerivs ((Maybe Mex, Either Selbri Sumti, [RelClause])),
lojbanSubStarRule20 :: Result LojbanDerivs ([RelClause]),
lojbanSubrelativeClause :: Result LojbanDerivs (RelClause),
lojbanSubselbri :: Result LojbanDerivs (Selbri),
lojbanSubselbri2 :: Result LojbanDerivs (Selbri2),
lojbanSubselbri3Tail :: Result LojbanDerivs ((Selbri3 -> Selbri3)),
lojbanSubStarRule21 :: Result LojbanDerivs ([(Connective, Selbri3)]),
lojbanSubselbri5 :: Result LojbanDerivs (Selbri3),
lojbanSubselbri6 :: Result LojbanDerivs (Selbri3),
lojbanSubtanruUnitTail :: Result LojbanDerivs ((Selbri3 -> Selbri3)),
lojbanSubStarRule22 :: Result LojbanDerivs ([Free]),
lojbanSubPlusRule8 :: Result LojbanDerivs ([String]),
lojbanSubtanruUnit2 :: Result LojbanDerivs (TanruUnit),
lojbanSubabstractor :: Result LojbanDerivs (Abstractor),
lojbanSublinks :: Result LojbanDerivs ([Term]),
lojbanSubStarRule23 :: Result LojbanDerivs ([Mex -> Mex]),
lojbanSubmex1 :: Result LojbanDerivs (Mex)}
data LojbanDerivs3 = LojbanDerivs3 {
lojbanSubmex2 :: Result LojbanDerivs (Mex),
lojbanSubrpExpressionTail :: Result LojbanDerivs (Mex -> Mex),
lojbanSubStarRule24 :: Result LojbanDerivs ([(Connective, Operator)]),
lojbanSuboperator1 :: Result LojbanDerivs (Operator),
lojbanSuboperator2 :: Result LojbanDerivs (Operator),
lojbanSubmexOperator :: Result LojbanDerivs (Operator),
lojbanSuboperand :: Result LojbanDerivs (Mex),
lojbanSubStarRule25 :: Result LojbanDerivs ([Mex -> Mex]),
lojbanSuboperand2 :: Result LojbanDerivs (Mex),
lojbanSubPlusRule10 :: Result LojbanDerivs ([Mex]),
lojbanSuboperand3 :: Result LojbanDerivs (Mex),
lojbanSubStarRule26 :: Result LojbanDerivs ([Numeral]),
lojbanSubPlusRule11 :: Result LojbanDerivs ([Int]),
lojbanSubStarRule27 :: Result LojbanDerivs ([Lerfu]),
lojbanSublerfuWord :: Result LojbanDerivs (Lerfu),
lojbanSubek :: Result LojbanDerivs (LogJboConnective),
lojbanSubgihek :: Result LojbanDerivs (LogJboConnective),
lojbanSubjek :: Result LojbanDerivs (LogJboConnective)}
data LojbanDerivs4 = LojbanDerivs4 {
lojbanSubjoik :: Result LojbanDerivs (String),
lojbanSubinterval :: Result LojbanDerivs (String),
lojbanSubgek :: Result LojbanDerivs (Bool -> Connective),
lojbanSubguhek :: Result LojbanDerivs (Bool -> LogJboConnective),
lojbanSubStarRule28 :: Result LojbanDerivs ([(Connective, Tag)]),
lojbanSubPlusRule12 :: Result LojbanDerivs ([DecoratedTagUnit]),
lojbanSubdecoratedTagUnit :: Result LojbanDerivs (DecoratedTagUnit),
lojbanSubPlusRule13 :: Result LojbanDerivs ([()]),
lojbanSubPlusRule14 :: Result LojbanDerivs ([Char]),
lojbanSubPlusRule15 :: Result LojbanDerivs ([Char]),
lojbanSubStarRule29 :: Result LojbanDerivs ([Char]),
lojbanSubStarRule30 :: Result LojbanDerivs ([Char]),
lojbanSubPlusRule16 :: Result LojbanDerivs ([Char]),
lojbanSubBU :: Result LojbanDerivs (String),
lojbanSubGOhA :: Result LojbanDerivs (String),
lojbanSubKOhA :: Result LojbanDerivs (String),
lojbanSubPA :: Result LojbanDerivs (String),
lojbanSubUI :: Result LojbanDerivs (String)}
lojbanStarRule0 = lojbanSubStarRule0 . lojbanSub0
lojbanfree = lojbanSubfree . lojbanSub0
lojbanStarRule1 = lojbanSubStarRule1 . lojbanSub0
lojbanPlusRule1 = lojbanSubPlusRule1 . lojbanSub0
lojbancoi = lojbanSubcoi . lojbanSub0
lojbanindicator = lojbanSubindicator . lojbanSub0
lojbanStarRule3 = lojbanSubStarRule3 . lojbanSub0
lojbantext = lojbanSubtext . lojbanSub0
lojbanStarRule4 = lojbanSubStarRule4 . lojbanSub0
lojbantext1 = lojbanSubtext1 . lojbanSub0
lojbanPlusRule4 = lojbanSubPlusRule4 . lojbanSub0
lojbanparagraphs = lojbanSubparagraphs . lojbanSub0
lojbanStarRule5 = lojbanSubStarRule5 . lojbanSub0
lojbanstatementOrFragment = lojbanSubstatementOrFragment . lojbanSub0
lojbanstatement = lojbanSubstatement . lojbanSub0
lojbanStarRule9 = lojbanSubStarRule9 . lojbanSub0
lojbanstatement2 = lojbanSubstatement2 . lojbanSub0
lojbantermsAndTail = lojbanSubtermsAndTail . lojbanSub0
lojbansubsentence = lojbanSubsubsentence . lojbanSub0
lojbanbridiTail = lojbanSubbridiTail . lojbanSub1
lojbanStarRule13 = lojbanSubStarRule13 . lojbanSub1
lojbanbridiTail2 = lojbanSubbridiTail2 . lojbanSub1
lojbangekSentence = lojbanSubgekSentence . lojbanSub1
lojbanStarRule14 = lojbanSubStarRule14 . lojbanSub1
lojbanPlusRule5 = lojbanSubPlusRule5 . lojbanSub1
lojbanterms1 = lojbanSubterms1 . lojbanSub1
lojbanPlusRule6 = lojbanSubPlusRule6 . lojbanSub1
lojbanterm = lojbanSubterm . lojbanSub1
lojbantermsGikTerms = lojbanSubtermsGikTerms . lojbanSub1
lojbansumti = lojbanSubsumti . lojbanSub1
lojbanStarRule15 = lojbanSubStarRule15 . lojbanSub1
lojbansumti3 = lojbanSubsumti3 . lojbanSub1
lojbansumti4 = lojbanSubsumti4 . lojbanSub1
lojbansumti6 = lojbanSubsumti6 . lojbanSub1
lojbanqualifier = lojbanSubqualifier . lojbanSub1
lojbanPlusRule7 = lojbanSubPlusRule7 . lojbanSub1
lojbanStarRule17 = lojbanSubStarRule17 . lojbanSub1
lojbanStarRule18 = lojbanSubStarRule18 . lojbanSub2
lojbanStarRule19 = lojbanSubStarRule19 . lojbanSub2
lojbansumtiTail1 = lojbanSubsumtiTail1 . lojbanSub2
lojbanStarRule20 = lojbanSubStarRule20 . lojbanSub2
lojbanrelativeClause = lojbanSubrelativeClause . lojbanSub2
lojbanselbri = lojbanSubselbri . lojbanSub2
lojbanselbri2 = lojbanSubselbri2 . lojbanSub2
lojbanselbri3Tail = lojbanSubselbri3Tail . lojbanSub2
lojbanStarRule21 = lojbanSubStarRule21 . lojbanSub2
lojbanselbri5 = lojbanSubselbri5 . lojbanSub2
lojbanselbri6 = lojbanSubselbri6 . lojbanSub2
lojbantanruUnitTail = lojbanSubtanruUnitTail . lojbanSub2
lojbanStarRule22 = lojbanSubStarRule22 . lojbanSub2
lojbanPlusRule8 = lojbanSubPlusRule8 . lojbanSub2
lojbantanruUnit2 = lojbanSubtanruUnit2 . lojbanSub2
lojbanabstractor = lojbanSubabstractor . lojbanSub2
lojbanlinks = lojbanSublinks . lojbanSub2
lojbanStarRule23 = lojbanSubStarRule23 . lojbanSub2
lojbanmex1 = lojbanSubmex1 . lojbanSub2
lojbanmex2 = lojbanSubmex2 . lojbanSub3
lojbanrpExpressionTail = lojbanSubrpExpressionTail . lojbanSub3
lojbanStarRule24 = lojbanSubStarRule24 . lojbanSub3
lojbanoperator1 = lojbanSuboperator1 . lojbanSub3
lojbanoperator2 = lojbanSuboperator2 . lojbanSub3
lojbanmexOperator = lojbanSubmexOperator . lojbanSub3
lojbanoperand = lojbanSuboperand . lojbanSub3
lojbanStarRule25 = lojbanSubStarRule25 . lojbanSub3
lojbanoperand2 = lojbanSuboperand2 . lojbanSub3
lojbanPlusRule10 = lojbanSubPlusRule10 . lojbanSub3
lojbanoperand3 = lojbanSuboperand3 . lojbanSub3
lojbanStarRule26 = lojbanSubStarRule26 . lojbanSub3
lojbanPlusRule11 = lojbanSubPlusRule11 . lojbanSub3
lojbanStarRule27 = lojbanSubStarRule27 . lojbanSub3
lojbanlerfuWord = lojbanSublerfuWord . lojbanSub3
lojbanek = lojbanSubek . lojbanSub3
lojbangihek = lojbanSubgihek . lojbanSub3
lojbanjek = lojbanSubjek . lojbanSub3
lojbanjoik = lojbanSubjoik . lojbanSub4
lojbaninterval = lojbanSubinterval . lojbanSub4
lojbangek = lojbanSubgek . lojbanSub4
lojbanguhek = lojbanSubguhek . lojbanSub4
lojbanStarRule28 = lojbanSubStarRule28 . lojbanSub4
lojbanPlusRule12 = lojbanSubPlusRule12 . lojbanSub4
lojbandecoratedTagUnit = lojbanSubdecoratedTagUnit . lojbanSub4
lojbanPlusRule13 = lojbanSubPlusRule13 . lojbanSub4
lojbanPlusRule14 = lojbanSubPlusRule14 . lojbanSub4
lojbanPlusRule15 = lojbanSubPlusRule15 . lojbanSub4
lojbanStarRule29 = lojbanSubStarRule29 . lojbanSub4
lojbanStarRule30 = lojbanSubStarRule30 . lojbanSub4
lojbanPlusRule16 = lojbanSubPlusRule16 . lojbanSub4
lojbanBU = lojbanSubBU . lojbanSub4
lojbanGOhA = lojbanSubGOhA . lojbanSub4
lojbanKOhA = lojbanSubKOhA . lojbanSub4
lojbanPA = lojbanSubPA . lojbanSub4
lojbanUI = lojbanSubUI . lojbanSub4
lojbanParse :: String -> String -> LojbanDerivs
lojbanParse name text = lojbanDerivs (Pos name 1 1) text
lojbanDerivs :: Pos -> String -> LojbanDerivs
lojbanDerivs pos text = dvs where
dvs = LojbanDerivs
(lojbanDerivs0 dvs)
(lojbanDerivs1 dvs)
(lojbanDerivs2 dvs)
(lojbanDerivs3 dvs)
(lojbanDerivs4 dvs)
chr pos
chr = case text of
[] -> NoParse (msgError (lojbanPos dvs) "end of input")
(c:cs) -> Parsed c (lojbanDerivs (nextPos pos c) cs) (ParseError pos [])
lojbanDerivs0 dvs = LojbanDerivs0
(lojbanParseStarRule0 dvs)
(lojbanParsefree dvs)
(lojbanParseStarRule1 dvs)
(lojbanParsePlusRule1 dvs)
(lojbanParsecoi dvs)
(lojbanParseindicator dvs)
(lojbanParseStarRule3 dvs)
(lojbanParsetext dvs)
(lojbanParseStarRule4 dvs)
(lojbanParsetext1 dvs)
(lojbanParsePlusRule4 dvs)
(lojbanParseparagraphs dvs)
(lojbanParseStarRule5 dvs)
(lojbanParsestatementOrFragment dvs)
(lojbanParsestatement dvs)
(lojbanParseStarRule9 dvs)
(lojbanParsestatement2 dvs)
(lojbanParsetermsAndTail dvs)
(lojbanParsesubsentence dvs)
lojbanDerivs1 dvs = LojbanDerivs1
(lojbanParsebridiTail dvs)
(lojbanParseStarRule13 dvs)
(lojbanParsebridiTail2 dvs)
(lojbanParsegekSentence dvs)
(lojbanParseStarRule14 dvs)
(lojbanParsePlusRule5 dvs)
(lojbanParseterms1 dvs)
(lojbanParsePlusRule6 dvs)
(lojbanParseterm dvs)
(lojbanParsetermsGikTerms dvs)
(lojbanParsesumti dvs)
(lojbanParseStarRule15 dvs)
(lojbanParsesumti3 dvs)
(lojbanParsesumti4 dvs)
(lojbanParsesumti6 dvs)
(lojbanParsequalifier dvs)
(lojbanParsePlusRule7 dvs)
(lojbanParseStarRule17 dvs)
lojbanDerivs2 dvs = LojbanDerivs2
(lojbanParseStarRule18 dvs)
(lojbanParseStarRule19 dvs)
(lojbanParsesumtiTail1 dvs)
(lojbanParseStarRule20 dvs)
(lojbanParserelativeClause dvs)
(lojbanParseselbri dvs)
(lojbanParseselbri2 dvs)
(lojbanParseselbri3Tail dvs)
(lojbanParseStarRule21 dvs)
(lojbanParseselbri5 dvs)
(lojbanParseselbri6 dvs)
(lojbanParsetanruUnitTail dvs)
(lojbanParseStarRule22 dvs)
(lojbanParsePlusRule8 dvs)
(lojbanParsetanruUnit2 dvs)
(lojbanParseabstractor dvs)
(lojbanParselinks dvs)
(lojbanParseStarRule23 dvs)
(lojbanParsemex1 dvs)
lojbanDerivs3 dvs = LojbanDerivs3
(lojbanParsemex2 dvs)
(lojbanParserpExpressionTail dvs)
(lojbanParseStarRule24 dvs)
(lojbanParseoperator1 dvs)
(lojbanParseoperator2 dvs)
(lojbanParsemexOperator dvs)
(lojbanParseoperand dvs)
(lojbanParseStarRule25 dvs)
(lojbanParseoperand2 dvs)
(lojbanParsePlusRule10 dvs)
(lojbanParseoperand3 dvs)
(lojbanParseStarRule26 dvs)
(lojbanParsePlusRule11 dvs)
(lojbanParseStarRule27 dvs)
(lojbanParselerfuWord dvs)
(lojbanParseek dvs)
(lojbanParsegihek dvs)
(lojbanParsejek dvs)
lojbanDerivs4 dvs = LojbanDerivs4
(lojbanParsejoik dvs)
(lojbanParseinterval dvs)
(lojbanParsegek dvs)
(lojbanParseguhek dvs)
(lojbanParseStarRule28 dvs)
(lojbanParsePlusRule12 dvs)
(lojbanParsedecoratedTagUnit dvs)
(lojbanParsePlusRule13 dvs)
(lojbanParsePlusRule14 dvs)
(lojbanParsePlusRule15 dvs)
(lojbanParseStarRule29 dvs)
(lojbanParseStarRule30 dvs)
(lojbanParsePlusRule16 dvs)
(lojbanParseBU dvs)
(lojbanParseGOhA dvs)
(lojbanParseKOhA dvs)
(lojbanParsePA dvs)
(lojbanParseUI dvs)
lojbanwholeStatement :: LojbanDerivs -> Result LojbanDerivs (Statement)
lojbanwholeStatement d =
case lojbanstatement d of
Parsed s pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos pappyDvs1) []) where
pappyAlt5_1 pappyErr5 =
case lojbanPlusRule4 pappyDvs1 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
()) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanI pappyDvs1 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
()) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
pappyAlt5_3 pappyErr5 =
case lojbanChar pappyDvs1 of
NoParse pappyErr7 ->
Parsed (
()) pappyDvs1 (max pappyErr7 pappyErr5)
Parsed _ _ pappyErr7 -> pappyAlt5_4 (max pappyErr7 pappyErr5)
pappyAlt5_4 pappyErr5 = NoParse pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule0 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParseStarRule0 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule0 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanI d of
Parsed i pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (i) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr11 -> pappyAlt5_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
where
pappyResult11 =
case lojbanBO pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
where
pappyResult9 =
case lojbanjoikJek pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanNIhO d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbantextHead :: LojbanDerivs -> Result LojbanDerivs (())
lojbantextHead d =
case lojbanStarRule0 d of
Parsed _ pappyDvs1 pappyErr1 ->
Parsed (
()) pappyDvs1 pappyErr1
NoParse pappyErr1 -> NoParse pappyErr1
lojbanterminatedText :: LojbanDerivs -> Result LojbanDerivs (Text)
lojbanterminatedText d =
case lojbantext d of
Parsed t pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanChar pappyDvs3 of
Parsed '%' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '%' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '%' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'E' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'N' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'D' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '%' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '%' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '%' pappyDvs21 _ ->
Parsed (t) pappyDvs21 (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
_ -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case lojbanPlusRule13 pappyDvs1 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
()) pappyDvs7 pappyErr7
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsefree :: LojbanDerivs -> Result LojbanDerivs (Free)
lojbanParsefree d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanSEI d of
Parsed "sei" pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
NoParse pappyErr5 ->
case pappyResult7 of
Parsed mts pappyDvs7 pappyErr7 ->
case lojbanselbri pappyDvs7 of
Parsed sb pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
Discursive $ BridiTail3 sb $ fromMaybe [] mts) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case lojbanSEhU pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs3 pappyErr9
where
pappyResult9 =
case pappyResult11 of
Parsed ts pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (ts) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanCU pappyDvs11 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
NoParse pappyErr11 -> NoParse pappyErr11
where
pappyResult11 =
case lojbanPlusRule5 pappyDvs3 of
Parsed ts pappyDvs13 pappyErr13 ->
Parsed (
ts ) pappyDvs13 pappyErr13
NoParse pappyErr13 -> NoParse pappyErr13
Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_2 (max (ParseError (lojbanPos d) [Expected "sei"]) pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanSEI d of
Parsed "ti'o" pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
NoParse pappyErr5 ->
case pappyResult7 of
Parsed mts pappyDvs7 pappyErr7 ->
case lojbanselbri pappyDvs7 of
Parsed sb pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
MexPrecedence $ BridiTail3 sb $ fromMaybe [] mts) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case lojbanSEhU pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt1_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs3 pappyErr9
where
pappyResult9 =
case pappyResult11 of
Parsed ts pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (ts) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanCU pappyDvs11 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
NoParse pappyErr11 -> NoParse pappyErr11
where
pappyResult11 =
case lojbanPlusRule5 pappyDvs3 of
Parsed ts pappyDvs13 pappyErr13 ->
Parsed (
ts ) pappyDvs13 pappyErr13
NoParse pappyErr13 -> NoParse pappyErr13
Parsed _ _ pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_3 (max (ParseError (lojbanPos d) [Expected "ti'o"]) pappyErr1)
pappyAlt1_3 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanBU pappyDvs5 of
NoParse pappyErr7 ->
case lojbansumti pappyDvs5 of
Parsed s pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed ms pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (
SOI s ms ) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr13 -> pappyAlt1_4 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult13 =
case lojbanSEhU pappyDvs11 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
NoParse pappyErr11 -> pappyAlt1_4 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case lojbansumti pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt1_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 's' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"soi") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_4 pappyErr1 =
case lojbanvocative d of
Parsed cs pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
NoParse pappyErr5 ->
case lojbanmaybeRelativeClauses pappyDvs3 of
Parsed rels1 pappyDvs7 pappyErr7 ->
case lojbanselbri pappyDvs7 of
Parsed sb pappyDvs9 pappyErr9 ->
case lojbanmaybeRelativeClauses pappyDvs9 of
Parsed rels2 pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (
Vocative cs $ Just (QAtom [] Nothing (rels1++rels2)
(Description "le" Nothing Nothing (Left sb) [] [])) ) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr13 -> pappyAlt1_5 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult13 =
case lojbanDOhU pappyDvs11 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
NoParse pappyErr11 -> pappyAlt1_5 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_5 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
pappyAlt1_5 pappyErr1 =
case lojbanvocative d of
Parsed cs pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
NoParse pappyErr5 ->
case lojbanname pappyDvs3 of
Parsed n pappyDvs7 pappyErr7 ->
case lojbanmaybeRelativeClauses pappyDvs7 of
Parsed rels pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
Vocative cs $ Just (QAtom [] Nothing rels (n "la")) ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_6 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case lojbanDOhU pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt1_6 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_6 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
pappyAlt1_6 pappyErr1 =
case lojbanvocative d of
Parsed cs pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
NoParse pappyErr5 ->
case lojbanfree pappyDvs3 of
NoParse pappyErr7 ->
case pappyResult9 of
Parsed ms pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
Vocative cs ms ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_7 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case lojbanDOhU pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt1_7 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbansumti pappyDvs3 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs3 pappyErr11
Parsed _ _ pappyErr7 -> pappyAlt1_7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_7 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_7 (max pappyErr3 pappyErr1)
pappyAlt1_7 pappyErr1 =
case lojbannumberOrLerfuString d of
Parsed q pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed s pappyDvs5 pappyErr5 ->
case lojbanpostClause pappyDvs5 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
MAI q ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_8 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_8 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanChar pappyDvs3 of
Parsed 'm' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'o' pappyDvs13 _ ->
Parsed (
"mo'o") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"mai") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
NoParse pappyErr3 -> pappyAlt1_8 (max pappyErr3 pappyErr1)
pappyAlt1_8 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanBU pappyDvs5 of
NoParse pappyErr7 ->
case lojbantext pappyDvs5 of
Parsed t pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
Bracketed t) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_9 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case pappyResult13 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
where
pappyResult13 =
case pappyResult15 of
Parsed s pappyDvs15 pappyErr15 ->
case lojbanpostClause pappyDvs15 of
Parsed _ pappyDvs17 pappyErr17 ->
Parsed (s) pappyDvs17 (max pappyErr17 pappyErr15)
NoParse pappyErr17 -> NoParse (max pappyErr17 pappyErr15)
NoParse pappyErr15 -> NoParse pappyErr15
where
pappyResult15 =
case lojbanChar pappyDvs9 of
Parsed 't' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'i' pappyDvs21 _ ->
Parsed (
"toi") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
NoParse pappyErr9 -> pappyAlt1_9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr7 -> pappyAlt1_9 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_9 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_9 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 't' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"to'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ ->
Parsed (
"to") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_9 pappyErr1 =
case pappyResult3 of
Parsed q pappyDvs3 pappyErr3 ->
Parsed (
XI q) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_10 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanXI d of
Parsed _ pappyDvs7 pappyErr7 ->
case lojbanBU pappyDvs7 of
NoParse pappyErr9 ->
case lojbannumberOrLerfuString pappyDvs7 of
Parsed q pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (q) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr13 -> pappyAlt5_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
where
pappyResult13 =
case lojbanBOI pappyDvs11 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
NoParse pappyErr11 -> pappyAlt5_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
Parsed _ _ pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanXI d of
Parsed _ pappyDvs7 pappyErr7 ->
case lojbanBU pappyDvs7 of
NoParse pappyErr9 ->
case lojbanVEI pappyDvs7 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbanmex pappyDvs11 of
Parsed q pappyDvs13 pappyErr13 ->
case pappyResult15 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (q) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr15 -> pappyAlt5_3 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
where
pappyResult15 =
case lojbanVEhO pappyDvs13 of
Parsed pappyVal17 pappyDvs17 pappyErr17 -> Parsed (Just pappyVal17) pappyDvs17 pappyErr17
NoParse pappyErr17 -> Parsed (Nothing) pappyDvs13 pappyErr17
NoParse pappyErr13 -> pappyAlt5_3 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr11 -> pappyAlt5_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
Parsed _ _ pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_10 pappyErr1 =
case pappyResult3 of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanindicator pappyDvs3 of
Parsed i pappyDvs5 pappyErr5 ->
Parsed (i) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_11 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_11 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
where
pappyResult5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (s) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
NoParse pappyErr7 -> NoParse pappyErr7
where
pappyResult7 =
case lojbanChar d of
Parsed 'f' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'e' pappyDvs15 _ ->
Parsed (
"fu'e") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_11 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
NullFree) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_12 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_12 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'b' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"ba'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'z' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"za'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_12 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanBU pappyDvs5 of
NoParse pappyErr7 ->
Parsed (
NullFree) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr7 -> pappyAlt1_13 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_13 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_13 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'y' pappyDvs5 _ ->
Parsed (
"y") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_13 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule1 :: LojbanDerivs -> Result LojbanDerivs ([COI])
lojbanParseStarRule1 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbancoi d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule1 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule1 :: LojbanDerivs -> Result LojbanDerivs ([COI])
lojbanParsePlusRule1 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbancoi d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule1 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbancoi d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanvocative :: LojbanDerivs -> Result LojbanDerivs ([COI])
lojbanvocative d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanStarRule1 d of
Parsed cs pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed s pappyDvs5 pappyErr5 ->
case lojbanpostClause pappyDvs5 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (cs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanChar pappyDvs3 of
Parsed 'd' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"doi") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanPlusRule1 d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsecoi :: LojbanDerivs -> Result LojbanDerivs (COI)
lojbanParsecoi d =
case pappyResult1 of
Parsed c pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mn pappyDvs5 pappyErr5 ->
Parsed (
COI c $ isJust mn) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanNAI pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ju'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"je'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"coi") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"co'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'f' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"fi'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"fe'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ta'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"mu'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"mi'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'p' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"pe'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ke'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ki'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"nu'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'r' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"re'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"be'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"vi'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanParseindicator :: LojbanDerivs -> Result LojbanDerivs (Free)
lojbanParseindicator d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanUI d of
Parsed "xu" pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
NoParse pappyErr5 ->
case pappyResult7 of
Parsed k pappyDvs7 pappyErr7 ->
Parsed (
TruthQ k) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs3 pappyErr9
where
pappyResult9 =
case lojbanUI pappyDvs3 of
Parsed "kau" pappyDvs11 pappyErr11 ->
case lojbanBU pappyDvs11 of
NoParse pappyErr13 ->
case pappyResult15 of
Parsed x pappyDvs15 pappyErr15 ->
Parsed (
fromMaybe 1 x) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr15 -> NoParse (maximum [pappyErr15,pappyErr13,pappyErr11])
where
pappyResult15 =
case lojbanxiLit pappyDvs11 of
Parsed pappyVal17 pappyDvs17 pappyErr17 -> Parsed (Just pappyVal17) pappyDvs17 pappyErr17
NoParse pappyErr17 -> Parsed (Nothing) pappyDvs11 pappyErr17
Parsed _ _ pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [Expected "kau"])
Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_2 (max (ParseError (lojbanPos d) [Expected "xu"]) pappyErr1)
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed c pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed nai pappyDvs5 pappyErr5 ->
case lojbanBU pappyDvs5 of
NoParse pappyErr7 ->
Parsed (
Indicator (isJust nai) c ) pappyDvs5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanNAI pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanUI d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
where
pappyResult7 =
case lojbanChar d of
Parsed 'p' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
Parsed (
"pei") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
Parsed 'c' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
Parsed (
"cai") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'u' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
Parsed (
"cu'i") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
Parsed 's' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
Parsed (
"sai") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
Parsed 'r' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'e' pappyDvs15 _ ->
Parsed (
"ru'e") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_3 pappyErr1 =
case pappyResult3 of
Parsed c pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
NoParse pappyErr5 ->
Parsed (
Indicator False c ) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
where
pappyResult7 =
case lojbanChar d of
Parsed 'd' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'o' pappyDvs15 _ ->
Parsed (
"da'o") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt5_2 pappyErr5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
where
pappyResult7 =
case lojbanChar d of
Parsed 'f' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'o' pappyDvs15 _ ->
Parsed (
"fu'o") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule3 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParseStarRule3 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanNAI d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule3 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsetext :: LojbanDerivs -> Result LojbanDerivs (Text)
lojbanParsetext d =
case lojbanStarRule22 d of
Parsed fs1 pappyDvs1 pappyErr1 ->
case lojbanStarRule3 pappyDvs1 of
Parsed ns pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed fs2 pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mjjfrag pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mps pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
Text (fs1++fs2) (not $ null ns) $
maybe [] (\jjfrag -> [[Left $ FragCon $ jjJboCon Nothing jjfrag]]) mjjfrag ++
fromMaybe [] mps) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case pappyResult13 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
where
pappyResult13 =
case pappyResult15 of
Parsed s pappyDvs15 pappyErr15 ->
case lojbanpostClause pappyDvs15 of
Parsed _ pappyDvs17 pappyErr17 ->
Parsed (s) pappyDvs17 (max pappyErr17 pappyErr15)
NoParse pappyErr17 -> NoParse (max pappyErr17 pappyErr15)
NoParse pappyErr15 -> NoParse pappyErr15
where
pappyResult15 =
case lojbanChar pappyDvs9 of
Parsed 'f' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'o' pappyDvs23 _ ->
Parsed (
"fa'o") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbantext1 pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
where
pappyResult9 =
case lojbantext1 pappyDvs5 of
NoParse pappyErr11 ->
case lojbanjoikJek pappyDvs5 of
Parsed jjfrag pappyDvs13 pappyErr13 ->
Parsed (jjfrag) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
Parsed _ _ pappyErr11 -> NoParse pappyErr11
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case lojbanPlusRule7 pappyDvs3 of
Parsed cs pappyDvs9 pappyErr9 ->
Parsed (
[Vocative [] $ Just $ QAtom [] Nothing [] $ Name "la" [] $ unwords cs] ) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
pappyAlt7_2 pappyErr7 =
case lojbanStarRule4 pappyDvs3 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed pappyVal9 pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_3 (max pappyErr9 pappyErr7)
pappyAlt7_3 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule4 :: LojbanDerivs -> Result LojbanDerivs ([Free])
lojbanParseStarRule4 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanindicator d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule4 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsetext1 :: LojbanDerivs -> Result LojbanDerivs ([Paragraph])
lojbanParsetext1 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanI d of
Parsed _ pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mjj pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mmtag pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mt pappyDvs9 pappyErr9 ->
Parsed (
if isNothing mt && isNothing mmtag && isJust mjj
then [[Left $ FragCon $ jjJboCon Nothing $ fromJust mjj]]
else fromMaybe [] mt) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbantext1 pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
where
pappyResult9 =
case pappyResult11 of
Parsed mtag pappyDvs11 pappyErr11 ->
case lojbanBO pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (mtag) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
NoParse pappyErr11 -> NoParse pappyErr11
where
pappyResult11 =
case lojbantag pappyDvs5 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs5 pappyErr13
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanjoikJek pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanPlusRule4 d of
Parsed _ pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mps pappyDvs5 pappyErr5 ->
Parsed (
fromMaybe [] mps) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanparagraphs pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanparagraphs d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule4 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParsePlusRule4 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanNIhO d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule4 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanNIhO d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseparagraphs :: LojbanDerivs -> Result LojbanDerivs ([Paragraph])
lojbanParseparagraphs d =
case pappyResult1 of
Parsed p pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed mps pappyDvs3 pappyErr3 ->
Parsed (
p : fromMaybe [] mps) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case lojbanPlusRule4 pappyDvs1 of
Parsed _ pappyDvs7 pappyErr7 ->
case lojbanparagraphs pappyDvs7 of
Parsed ps pappyDvs9 pappyErr9 ->
Parsed (ps) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanstatementOrFragment d of
Parsed sf pappyDvs3 pappyErr3 ->
case lojbanStarRule5 pappyDvs3 of
Parsed msfs pappyDvs5 pappyErr5 ->
Parsed (
(sf:) $ concat $ map maybeToList msfs) pappyDvs5 (max pappyErr5 pappyErr3)
NoParse pappyErr5 -> NoParse (max pappyErr5 pappyErr3)
NoParse pappyErr3 -> NoParse pappyErr3
lojbanParseStarRule5 :: LojbanDerivs -> Result LojbanDerivs ([Maybe (Either Fragment Statement)])
lojbanParseStarRule5 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanI d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanjek pappyDvs3 of
NoParse pappyErr5 ->
case lojbanjoik pappyDvs3 of
NoParse pappyErr7 ->
case lojbanjoikJek pappyDvs3 of
NoParse pappyErr9 ->
case pappyResult11 of
Parsed v pappyDvs11 pappyErr11 ->
case lojbanStarRule5 pappyDvs11 of
Parsed vs pappyDvs13 pappyErr13 ->
Parsed (
v : vs) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr13 -> pappyAlt1_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case lojbanstatementOrFragment pappyDvs3 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs3 pappyErr13
Parsed _ _ pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsestatementOrFragment :: LojbanDerivs -> Result LojbanDerivs (Either Fragment Statement)
lojbanParsestatementOrFragment d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanstatement d of
Parsed s pappyDvs3 pappyErr3 ->
Parsed (
Right s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanStarRule22 d of
Parsed _ pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed f pappyDvs5 pappyErr5 ->
Parsed (
Left f) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case lojbanprenex pappyDvs3 of
Parsed p pappyDvs9 pappyErr9 ->
Parsed (
FragPrenex p) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
pappyAlt7_2 pappyErr7 =
case pappyResult9 of
Parsed ts pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
FragTerms ts) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_3 (maximum [pappyErr11,pappyErr9,pappyErr7])
where
pappyResult11 =
case lojbanVAU pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt7_3 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanPlusRule5 pappyDvs3 of
Parsed ts pappyDvs11 pappyErr11 ->
Parsed (
ts ) pappyDvs11 pappyErr11
NoParse pappyErr11 -> NoParse pappyErr11
pappyAlt7_3 pappyErr7 =
case lojbanek pappyDvs3 of
Parsed c pappyDvs9 pappyErr9 ->
Parsed (
FragCon $ jboConnLogOrQ Nothing c) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_4 (max pappyErr9 pappyErr7)
pappyAlt7_4 pappyErr7 =
case lojbangihek pappyDvs3 of
Parsed c pappyDvs9 pappyErr9 ->
Parsed (
FragCon $ jboConnLogOrQ Nothing c) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_5 (max pappyErr9 pappyErr7)
pappyAlt7_5 pappyErr7 =
case lojbanquantifier pappyDvs3 of
Parsed m pappyDvs9 pappyErr9 ->
Parsed (
FragQuantifier m) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_6 (max pappyErr9 pappyErr7)
pappyAlt7_6 pappyErr7 =
case lojbanNA pappyDvs3 of
Parsed n pappyDvs9 pappyErr9 ->
case lojbanJA pappyDvs9 of
NoParse pappyErr11 ->
Parsed (
FragNA n) pappyDvs9 (maximum [pappyErr11,pappyErr9,pappyErr7])
Parsed _ _ pappyErr11 -> pappyAlt7_7 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_7 (max pappyErr9 pappyErr7)
pappyAlt7_7 pappyErr7 =
case lojbanrelativeClauses pappyDvs3 of
Parsed rels pappyDvs9 pappyErr9 ->
Parsed (
FragRels rels) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_8 (max pappyErr9 pappyErr7)
pappyAlt7_8 pappyErr7 =
case lojbanlinks pappyDvs3 of
Parsed ts pappyDvs9 pappyErr9 ->
Parsed (
FragLinks ts) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_9 (max pappyErr9 pappyErr7)
pappyAlt7_9 pappyErr7 =
case lojbanlinkargs pappyDvs3 of
Parsed ts pappyDvs9 pappyErr9 ->
Parsed (
FragLinks ts) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_10 (max pappyErr9 pappyErr7)
pappyAlt7_10 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsestatement :: LojbanDerivs -> Result LojbanDerivs (Statement)
lojbanParsestatement d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanStarRule22 d of
Parsed fs pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed s pappyDvs5 pappyErr5 ->
Parsed (
Statement fs [] s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanstatement2 pappyDvs3 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanStarRule9 pappyDvs7 of
Parsed jekss pappyDvs9 pappyErr9 ->
Parsed (
foldl (\s1 -> \(con,s2) -> ConnectedStatement con s1 s2) s jekss ) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanStarRule22 d of
Parsed fs pappyDvs3 pappyErr3 ->
case lojbanprenex pappyDvs3 of
Parsed ps pappyDvs5 pappyErr5 ->
case lojbanstatement pappyDvs5 of
Parsed (Statement fs' ps' s) pappyDvs7 pappyErr7 ->
Parsed (
Statement (fs++fs') (ps++ps') s) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ _ -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule9 :: LojbanDerivs -> Result LojbanDerivs ([(Connective, Statement1)])
lojbanParseStarRule9 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule9 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanI d of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanjoikJek pappyDvs5 of
Parsed jj pappyDvs7 pappyErr7 ->
case lojbanstatement2 pappyDvs7 of
Parsed s pappyDvs9 pappyErr9 ->
Parsed (
(jjJboCon Nothing jj,s)) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsestatement2 :: LojbanDerivs -> Result LojbanDerivs (Statement1)
lojbanParsestatement2 d =
case pappyResult1 of
Parsed s1 pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed boSt pappyDvs3 pappyErr3 ->
Parsed (
case boSt of
Nothing -> s1
Just (con,s2) -> ConnectedStatement con s1 s2 ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case lojbanI pappyDvs1 of
Parsed _ pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mjj pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed mtag pappyDvs11 pappyErr11 ->
case lojbanBO pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
case lojbanstatement2 pappyDvs13 of
Parsed s pappyDvs15 pappyErr15 ->
Parsed (
(jjJboCon mtag $ fromMaybe (JJJek $ LogJboConnective True 'e' True) mjj,s)) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr15 -> NoParse (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7])
where
pappyResult11 =
case lojbantag pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanjoikJek pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
pappyAlt3_1 (ParseError (lojbanPos d) []) where
pappyAlt3_1 pappyErr3 =
case lojbanStarRule22 d of
Parsed fs pappyDvs5 pappyErr5 ->
case lojbansentence pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
Parsed (
StatementSentence fs s) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
pappyAlt3_2 pappyErr3 =
case pappyResult5 of
Parsed mtag pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbantext1 pappyDvs9 of
Parsed ps pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (
StatementParas mtag ps) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr13 -> pappyAlt3_3 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
where
pappyResult13 =
case pappyResult15 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
where
pappyResult15 =
case pappyResult17 of
Parsed s pappyDvs17 pappyErr17 ->
case lojbanpostClause pappyDvs17 of
Parsed _ pappyDvs19 pappyErr19 ->
Parsed (s) pappyDvs19 (max pappyErr19 pappyErr17)
NoParse pappyErr19 -> NoParse (max pappyErr19 pappyErr17)
NoParse pappyErr17 -> NoParse pappyErr17
where
pappyResult17 =
case lojbanChar pappyDvs11 of
Parsed 't' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'u' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed '\'' pappyDvs23 _ ->
case lojbanChar pappyDvs23 of
Parsed 'u' pappyDvs25 _ ->
Parsed (
"tu'u") pappyDvs25 (ParseError (lojbanPos pappyDvs25) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
NoParse pappyErr11 -> pappyAlt3_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr9 -> pappyAlt3_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
where
pappyResult7 =
case lojbanChar pappyDvs5 of
Parsed 't' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'e' pappyDvs15 _ ->
Parsed (
"tu'e") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
where
pappyResult5 =
case lojbantag d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) d pappyErr7
pappyAlt3_3 pappyErr3 = NoParse pappyErr3
lojbanprenex :: LojbanDerivs -> Result LojbanDerivs ([Term])
lojbanprenex d =
case pappyResult1 of
Parsed ps pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (ps) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar pappyDvs1 of
Parsed 'z' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
Parsed (
"zo'u") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs1) [])
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanPlusRule5 d of
Parsed ts pappyDvs3 pappyErr3 ->
Parsed (
ts ) pappyDvs3 pappyErr3
NoParse pappyErr3 -> NoParse pappyErr3
lojbansentence :: LojbanDerivs -> Result LojbanDerivs (Sentence)
lojbansentence d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanbridiTail d of
Parsed bt pappyDvs3 pappyErr3 ->
Parsed (
Sentence [] bt ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbantermsAndTail d of
Parsed ((ts,bt)) pappyDvs3 pappyErr3 ->
Parsed (
Sentence ts bt) pappyDvs3 (max pappyErr3 pappyErr1)
Parsed _ _ _ -> pappyAlt1_3 pappyErr1
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsetermsAndTail :: LojbanDerivs -> Result LojbanDerivs (([Term],BridiTail))
lojbanParsetermsAndTail d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanbridiTail pappyDvs3 of
Parsed bt pappyDvs5 pappyErr5 ->
Parsed (
([],bt)) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanCU d of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
pappyAlt1_2 pappyErr1 =
case lojbanterms1 d of
Parsed t pappyDvs3 pappyErr3 ->
case lojbantermsAndTail pappyDvs3 of
Parsed ((ts,bt)) pappyDvs5 pappyErr5 ->
Parsed (
t:ts,bt) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ _ -> pappyAlt1_3 (max pappyErr3 pappyErr1)
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsesubsentence :: LojbanDerivs -> Result LojbanDerivs (Subsentence)
lojbanParsesubsentence d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanStarRule22 d of
Parsed fs pappyDvs3 pappyErr3 ->
case lojbansentence pappyDvs3 of
Parsed s pappyDvs5 pappyErr5 ->
Parsed (
Subsentence fs [] s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanStarRule22 d of
Parsed fs pappyDvs3 pappyErr3 ->
case lojbanprenex pappyDvs3 of
Parsed ps pappyDvs5 pappyErr5 ->
case lojbansubsentence pappyDvs5 of
Parsed (Subsentence fs' ps' s) pappyDvs7 pappyErr7 ->
Parsed (
Subsentence (fs++fs') (ps++ps') s ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ _ -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsebridiTail :: LojbanDerivs -> Result LojbanDerivs (BridiTail)
lojbanParsebridiTail d =
case pappyResult1 of
Parsed bt1 pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed gihek pappyDvs3 pappyErr3 ->
Parsed (
case gihek of
Nothing -> bt1
Just (con, bt2, tts) -> ConnectedBT con bt1 bt2 tts ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case lojbangihek pappyDvs1 of
Parsed lcon pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mtag pappyDvs9 pappyErr9 ->
case lojbanKE pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbanbridiTail pappyDvs11 of
Parsed bt2 pappyDvs13 pappyErr13 ->
case pappyResult15 of
Parsed _ pappyDvs15 pappyErr15 ->
case lojbantailTerms pappyDvs15 of
Parsed tts pappyDvs17 pappyErr17 ->
Parsed (
(jboConnLogOrQ mtag lcon, bt2, tts)) pappyDvs17 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr17 -> NoParse (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr15 -> NoParse (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
where
pappyResult15 =
case lojbanKEhE pappyDvs13 of
Parsed pappyVal17 pappyDvs17 pappyErr17 -> Parsed (Just pappyVal17) pappyDvs17 pappyErr17
NoParse pappyErr17 -> Parsed (Nothing) pappyDvs13 pappyErr17
NoParse pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbantag pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanbridiTail2 d of
Parsed bt pappyDvs3 pappyErr3 ->
case lojbanStarRule13 pappyDvs3 of
Parsed giheks pappyDvs5 pappyErr5 ->
Parsed (
foldl (\bt1 -> \(con,bt2,tts) ->
ConnectedBT con bt1 bt2 tts
) bt giheks ) pappyDvs5 (max pappyErr5 pappyErr3)
NoParse pappyErr5 -> NoParse (max pappyErr5 pappyErr3)
NoParse pappyErr3 -> NoParse pappyErr3
lojbanParseStarRule13 :: LojbanDerivs -> Result LojbanDerivs ([(Connective, BridiTail, [Term])])
lojbanParseStarRule13 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule13 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbangihek d of
Parsed lcon pappyDvs5 pappyErr5 ->
case pappyResult7 of
NoParse pappyErr7 ->
case pappyResult9 of
NoParse pappyErr9 ->
case lojbanbridiTail2 pappyDvs5 of
Parsed bt pappyDvs11 pappyErr11 ->
case lojbantailTerms pappyDvs11 of
Parsed tts pappyDvs13 pappyErr13 ->
Parsed (
(jboConnLogOrQ Nothing lcon, bt, tts)) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
Parsed _ _ pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5])
where
pappyResult9 =
case pappyResult11 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbanKE pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (
()) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
NoParse pappyErr11 -> NoParse pappyErr11
where
pappyResult11 =
case lojbantag pappyDvs5 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs5 pappyErr13
Parsed _ _ pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
where
pappyResult7 =
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbanBO pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
()) pappyDvs11 (max pappyErr11 pappyErr9)
NoParse pappyErr11 -> NoParse (max pappyErr11 pappyErr9)
NoParse pappyErr9 -> NoParse pappyErr9
where
pappyResult9 =
case lojbantag pappyDvs5 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs5 pappyErr11
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsebridiTail2 :: LojbanDerivs -> Result LojbanDerivs (BridiTail)
lojbanParsebridiTail2 d =
case pappyResult1 of
Parsed bt1 pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed gihek pappyDvs3 pappyErr3 ->
Parsed (
case gihek of
Nothing -> bt1
Just (con, bt2, tts) -> ConnectedBT con bt1 bt2 tts ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case lojbangihek pappyDvs1 of
Parsed lcon pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mtag pappyDvs9 pappyErr9 ->
case lojbanBO pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbanbridiTail2 pappyDvs11 of
Parsed bt2 pappyDvs13 pappyErr13 ->
case lojbantailTerms pappyDvs13 of
Parsed tts pappyDvs15 pappyErr15 ->
Parsed (
(jboConnLogOrQ mtag lcon,bt2,tts)) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr15 -> NoParse (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbantag pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
pappyAlt3_1 (ParseError (lojbanPos d) []) where
pappyAlt3_1 pappyErr3 =
case lojbanselbri d of
Parsed sb pappyDvs5 pappyErr5 ->
case lojbantailTerms pappyDvs5 of
Parsed ts pappyDvs7 pappyErr7 ->
Parsed (
BridiTail3 sb ts ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
pappyAlt3_2 pappyErr3 =
case pappyResult5 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbangekSentence pappyDvs5 of
Parsed gs pappyDvs7 pappyErr7 ->
Parsed (
GekSentence gs ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
where
pappyResult5 =
case pappyResult7 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) d pappyErr7
where
pappyResult7 =
case lojbanNA d of
Parsed "ja'a" pappyDvs9 pappyErr9 ->
Parsed (
()) pappyDvs9 pappyErr9
_ -> NoParse (ParseError (lojbanPos d) [Expected "ja'a"])
pappyAlt3_3 pappyErr3 = NoParse pappyErr3
lojbanParsegekSentence :: LojbanDerivs -> Result LojbanDerivs (GekSentence)
lojbanParsegekSentence d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbangek d of
Parsed pcon pappyDvs3 pappyErr3 ->
case lojbansubsentence pappyDvs3 of
Parsed s1 pappyDvs5 pappyErr5 ->
case lojbangik pappyDvs5 of
Parsed b pappyDvs7 pappyErr7 ->
case lojbansubsentence pappyDvs7 of
Parsed s2 pappyDvs9 pappyErr9 ->
case lojbantailTerms pappyDvs9 of
Parsed tts pappyDvs11 pappyErr11 ->
Parsed (
ConnectedGS (pcon b) s1 s2 tts ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed mtag pappyDvs3 pappyErr3 ->
case lojbanKE pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbangekSentence pappyDvs5 of
Parsed gs pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
maybe gs (flip TaggedGS gs) mtag ) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanKEhE pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbantag d of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
pappyAlt1_3 pappyErr1 =
case lojbanNA d of
Parsed "na" pappyDvs3 pappyErr3 ->
case lojbangekSentence pappyDvs3 of
Parsed gs pappyDvs5 pappyErr5 ->
Parsed (
NegatedGS gs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_4 (max (ParseError (lojbanPos d) [Expected "na"]) pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule14 :: LojbanDerivs -> Result LojbanDerivs ([Term])
lojbanParseStarRule14 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanterms1 d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule14 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbantailTerms :: LojbanDerivs -> Result LojbanDerivs ([Term])
lojbantailTerms d =
case lojbanStarRule14 d of
Parsed ts pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (ts) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanVAU pappyDvs1 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsePlusRule5 :: LojbanDerivs -> Result LojbanDerivs ([Term])
lojbanParsePlusRule5 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanterms1 d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule5 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanterms1 d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseterms1 :: LojbanDerivs -> Result LojbanDerivs (Term)
lojbanParseterms1 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanterms2 d of
Parsed ts1 pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed s pappyDvs5 pappyErr5 ->
case lojbanpostClause pappyDvs5 of
Parsed _ pappyDvs7 pappyErr7 ->
case lojbanjoikJek pappyDvs7 of
Parsed jj pappyDvs9 pappyErr9 ->
case lojbanterms2 pappyDvs9 of
Parsed ts2 pappyDvs11 pappyErr11 ->
Parsed (
ConnectedTerms False (jjJboCon Nothing jj) ts1 ts2 ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanChar pappyDvs3 of
Parsed 'p' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'e' pappyDvs13 _ ->
Parsed (
"pe'e") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanterms2 d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule6 :: LojbanDerivs -> Result LojbanDerivs ([Term])
lojbanParsePlusRule6 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanCEhE d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanterms2 pappyDvs3 of
Parsed v pappyDvs5 pappyErr5 ->
case lojbanPlusRule6 pappyDvs5 of
Parsed vs pappyDvs7 pappyErr7 ->
Parsed (
v : vs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanCEhE d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanterms2 pappyDvs3 of
Parsed v pappyDvs5 pappyErr5 ->
Parsed (
[v]) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanterms2 :: LojbanDerivs -> Result LojbanDerivs (Term)
lojbanterms2 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanterm d of
Parsed t pappyDvs3 pappyErr3 ->
case lojbanPlusRule6 pappyDvs3 of
Parsed ts pappyDvs5 pappyErr5 ->
Parsed (
Termset (t:ts) ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanterm d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseterm :: LojbanDerivs -> Result LojbanDerivs (Term)
lojbanParseterm d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbansumti d of
Parsed s pappyDvs3 pappyErr3 ->
Parsed (
Sumti Untagged s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbangek d of
NoParse pappyErr3 ->
case lojbantag d of
Parsed tag pappyDvs5 pappyErr5 ->
case lojbansumti pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
Parsed (
Sumti (Tagged tag) s) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbangek d of
NoParse pappyErr3 ->
case lojbantag d of
Parsed tag pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
BareTag tag) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 =
case lojbantagFA d of
Parsed n pappyDvs3 pappyErr3 ->
case lojbansumti pappyDvs3 of
Parsed s pappyDvs5 pappyErr5 ->
Parsed (
Sumti (FATagged n) s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
pappyAlt1_5 pappyErr1 =
case lojbantagFA d of
Parsed n pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
BareFA $ Just n) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanKU pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
pappyAlt1_6 pappyErr1 =
case lojbanFA d of
Parsed "fai" pappyDvs3 pappyErr3 ->
case lojbansumti pappyDvs3 of
Parsed s pappyDvs5 pappyErr5 ->
Parsed (
Sumti FAITagged s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_7 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_7 (max (ParseError (lojbanPos d) [Expected "fai"]) pappyErr1)
pappyAlt1_7 pappyErr1 =
case lojbanFA d of
Parsed _ pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
NullTerm) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_8 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanKU pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_8 (max pappyErr3 pappyErr1)
pappyAlt1_8 pappyErr1 =
pappyAlt3_1 pappyErr1 where
pappyAlt3_1 pappyErr3 =
case lojbanNUhI d of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbangek pappyDvs5 of
Parsed pcon pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed ts1 pappyDvs9 pappyErr9 ->
case lojbanNUhU pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbangik pappyDvs11 of
Parsed b pappyDvs13 pappyErr13 ->
case pappyResult15 of
Parsed ts2 pappyDvs15 pappyErr15 ->
case pappyResult17 of
Parsed _ pappyDvs17 pappyErr17 ->
Parsed (
ConnectedTerms True (pcon b) (Termset ts1) (Termset ts2) ) pappyDvs17 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr17 -> pappyAlt3_2 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
where
pappyResult17 =
case lojbanNUhU pappyDvs15 of
Parsed pappyVal19 pappyDvs19 pappyErr19 -> Parsed (Just pappyVal19) pappyDvs19 pappyErr19
NoParse pappyErr19 -> Parsed (Nothing) pappyDvs15 pappyErr19
NoParse pappyErr15 -> pappyAlt3_2 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
where
pappyResult15 =
case lojbanPlusRule5 pappyDvs13 of
Parsed ts pappyDvs17 pappyErr17 ->
Parsed (
ts ) pappyDvs17 pappyErr17
NoParse pappyErr17 -> NoParse pappyErr17
NoParse pappyErr13 -> pappyAlt3_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr11 -> pappyAlt3_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr9 -> pappyAlt3_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
where
pappyResult9 =
case lojbanPlusRule5 pappyDvs7 of
Parsed ts pappyDvs11 pappyErr11 ->
Parsed (
ts ) pappyDvs11 pappyErr11
NoParse pappyErr11 -> NoParse pappyErr11
NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr5 -> pappyAlt3_2 (max pappyErr5 pappyErr3)
pappyAlt3_2 pappyErr3 =
case lojbanNUhI d of
Parsed _ pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed ts pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
Termset ts ) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr9 -> pappyAlt3_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
where
pappyResult9 =
case lojbanNUhU pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
where
pappyResult7 =
case lojbanPlusRule5 pappyDvs5 of
Parsed ts pappyDvs9 pappyErr9 ->
Parsed (
ts ) pappyDvs9 pappyErr9
NoParse pappyErr9 -> NoParse pappyErr9
NoParse pappyErr5 -> pappyAlt3_3 (max pappyErr5 pappyErr3)
pappyAlt3_3 pappyErr3 =
case lojbangek d of
Parsed pcon pappyDvs5 pappyErr5 ->
case lojbantermsGikTerms pappyDvs5 of
Parsed ((ts1,b,ts2)) pappyDvs7 pappyErr7 ->
Parsed (
ConnectedTerms True (pcon b) (Termset ts1) (Termset ts2) ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3])
Parsed _ _ _ -> pappyAlt3_4 (max pappyErr5 pappyErr3)
NoParse pappyErr7 -> pappyAlt3_4 (maximum [pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr5 -> pappyAlt3_4 (max pappyErr5 pappyErr3)
pappyAlt3_4 pappyErr3 = pappyAlt1_9 pappyErr3
pappyAlt1_9 pappyErr1 =
case lojbanNA d of
Parsed "na" pappyDvs3 pappyErr3 ->
case lojbanKU pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
Negation) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_10 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_10 (max (ParseError (lojbanPos d) [Expected "na"]) pappyErr1)
pappyAlt1_10 pappyErr1 =
case lojbanNA d of
Parsed "ja'a" pappyDvs3 pappyErr3 ->
Parsed (
NullTerm) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_11 (max (ParseError (lojbanPos d) [Expected "ja'a"]) pappyErr1)
pappyAlt1_11 pappyErr1 = NoParse pappyErr1
lojbanParsetermsGikTerms :: LojbanDerivs -> Result LojbanDerivs (([Term],Bool,[Term]))
lojbanParsetermsGikTerms d =
case lojbanterm d of
Parsed t1 pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed ((ts1,b,ts2)) pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t2 pappyDvs5 pappyErr5 ->
Parsed (
(t1:ts1,b,ts2++[t2])) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ _ -> NoParse pappyErr1
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos pappyDvs1) []) where
pappyAlt5_1 pappyErr5 =
case lojbangik pappyDvs1 of
Parsed b pappyDvs7 pappyErr7 ->
Parsed (
([],b,[])) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbantermsGikTerms pappyDvs1 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsesumti :: LojbanDerivs -> Result LojbanDerivs (Sumti)
lojbanParsesumti d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed rels pappyDvs3 pappyErr3 ->
Parsed (
case rels of
Nothing -> s
Just rels -> appendRelsToSumti rels s ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbanrelativeClauses pappyDvs9 of
Parsed rels pappyDvs11 pappyErr11 ->
Parsed (rels) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
NoParse pappyErr7 -> NoParse pappyErr7
where
pappyResult7 =
case lojbanChar pappyDvs1 of
Parsed 'v' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'o' pappyDvs15 _ ->
Parsed (
"vu'o") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs1) [])
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case pappyResult3 of
Parsed s1 pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed eks pappyDvs5 pappyErr5 ->
Parsed (
case eks of
Nothing -> s1
Just (con,s2) -> ConnectedSumti False con s1 s2 [] ) pappyDvs5 (max pappyErr5 pappyErr3)
NoParse pappyErr5 -> NoParse (max pappyErr5 pappyErr3)
where
pappyResult5 =
case pappyResult7 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
where
pappyResult7 =
case lojbanjoikEk pappyDvs3 of
Parsed jj pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed mtag pappyDvs11 pappyErr11 ->
case lojbanKE pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
case lojbansumti pappyDvs13 of
Parsed s pappyDvs15 pappyErr15 ->
case pappyResult17 of
Parsed _ pappyDvs17 pappyErr17 ->
Parsed (
(jjJboCon mtag jj,s)) pappyDvs17 (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9])
NoParse pappyErr17 -> NoParse (maximum [pappyErr17,pappyErr15,pappyErr13,pappyErr11,pappyErr9])
where
pappyResult17 =
case lojbanKEhE pappyDvs15 of
Parsed pappyVal19 pappyDvs19 pappyErr19 -> Parsed (Just pappyVal19) pappyDvs19 pappyErr19
NoParse pappyErr19 -> Parsed (Nothing) pappyDvs15 pappyErr19
NoParse pappyErr15 -> NoParse (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9])
NoParse pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9])
NoParse pappyErr11 -> NoParse (max pappyErr11 pappyErr9)
where
pappyResult11 =
case lojbantag pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> NoParse pappyErr9
NoParse pappyErr3 -> NoParse pappyErr3
where
pappyResult3 =
case lojbansumti3 d of
Parsed s pappyDvs5 pappyErr5 ->
case lojbanStarRule15 pappyDvs5 of
Parsed ekss pappyDvs7 pappyErr7 ->
Parsed (
foldl (\s1 -> \(con,s2) -> ConnectedSumti False con s1 s2 []) s ekss ) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
NoParse pappyErr5 -> NoParse pappyErr5
lojbanParseStarRule15 :: LojbanDerivs -> Result LojbanDerivs ([(Connective, Sumti)])
lojbanParseStarRule15 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule15 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanjoikEk d of
Parsed jj pappyDvs5 pappyErr5 ->
case lojbansumti3 pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
Parsed (
(jjJboCon Nothing jj,s)) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsesumti3 :: LojbanDerivs -> Result LojbanDerivs (Sumti)
lojbanParsesumti3 d =
case lojbansumti4 d of
Parsed s1 pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed eks pappyDvs3 pappyErr3 ->
Parsed (
case eks of
Nothing -> s1
Just (con,s2) -> ConnectedSumti False con s1 s2 [] ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case lojbanjoikEk pappyDvs1 of
Parsed jj pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mtag pappyDvs9 pappyErr9 ->
case lojbanBO pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbansumti3 pappyDvs11 of
Parsed s pappyDvs13 pappyErr13 ->
Parsed (
(jjJboCon mtag jj,s)) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr13 -> NoParse (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbantag pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsesumti4 :: LojbanDerivs -> Result LojbanDerivs (Sumti)
lojbanParsesumti4 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed q pappyDvs3 pappyErr3 ->
case lojbansumti6 pappyDvs3 of
Parsed s pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed k pappyDvs7 pappyErr7 ->
case lojbanStarRule22 pappyDvs7 of
Parsed fs pappyDvs9 pappyErr9 ->
case lojbanmaybeRelativeClauses pappyDvs9 of
Parsed rels pappyDvs11 pappyErr11 ->
Parsed (
QAtom fs q rels (maybe s (SumtiQ . Just) k)) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
where
pappyResult9 =
case lojbanUI pappyDvs5 of
Parsed "kau" pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed x pappyDvs13 pappyErr13 ->
Parsed (
fromMaybe 1 x) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanxiLit pappyDvs11 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [Expected "kau"])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanquantifier d of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
pappyAlt1_2 pappyErr1 =
case lojbanquantifier d of
Parsed q pappyDvs3 pappyErr3 ->
case lojbanselbri pappyDvs3 of
Parsed sb pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
case lojbanmaybeRelativeClauses pappyDvs7 of
Parsed rels pappyDvs9 pappyErr9 ->
Parsed (
QSelbri q rels sb) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbangek d of
Parsed pcon pappyDvs3 pappyErr3 ->
case lojbansumti pappyDvs3 of
Parsed s1 pappyDvs5 pappyErr5 ->
case lojbangik pappyDvs5 of
Parsed b pappyDvs7 pappyErr7 ->
case lojbansumti4 pappyDvs7 of
Parsed s2 pappyDvs9 pappyErr9 ->
Parsed (
ConnectedSumti True (pcon b) s1 s2 [] ) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParsesumti6 :: LojbanDerivs -> Result LojbanDerivs (SumtiAtom)
lojbanParsesumti6 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanPlusRule13 pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanValsi pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
Parsed (
Word s) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'z' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
Parsed (
"zo") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed "zoi" pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
Parsed (
NonJboQuote s) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
pappyAlt9_1 (ParseError (lojbanPos pappyDvs5) []) where
pappyAlt9_1 pappyErr9 =
case lojbanValsi pappyDvs5 of
Parsed "zoi" pappyDvs11 pappyErr11 ->
case lojbanStarRule17 pappyDvs11 of
Parsed ws pappyDvs13 pappyErr13 ->
case lojbanValsi pappyDvs13 of
Parsed "zoi" pappyDvs15 pappyErr15 ->
Parsed (
unwords ws) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9])
_ -> pappyAlt9_2 (maximum [(ParseError (lojbanPos pappyDvs13) [Expected "zoi"]),pappyErr13,pappyErr11,pappyErr9])
NoParse pappyErr13 -> pappyAlt9_2 (maximum [pappyErr13,pappyErr11,pappyErr9])
_ -> pappyAlt9_2 (max (ParseError (lojbanPos pappyDvs5) [Expected "zoi"]) pappyErr9)
pappyAlt9_2 pappyErr9 =
case lojbanValsi pappyDvs5 of
Parsed "gy" pappyDvs11 pappyErr11 ->
case lojbanStarRule18 pappyDvs11 of
Parsed ws pappyDvs13 pappyErr13 ->
case lojbanValsi pappyDvs13 of
Parsed "gy" pappyDvs15 pappyErr15 ->
Parsed (
unwords ws) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9])
_ -> pappyAlt9_3 (maximum [(ParseError (lojbanPos pappyDvs13) [Expected "gy"]),pappyErr13,pappyErr11,pappyErr9])
NoParse pappyErr13 -> pappyAlt9_3 (maximum [pappyErr13,pappyErr11,pappyErr9])
_ -> pappyAlt9_3 (max (ParseError (lojbanPos pappyDvs5) [Expected "gy"]) pappyErr9)
pappyAlt9_3 pappyErr9 = NoParse pappyErr9
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_3 (max (ParseError (lojbanPos d) [Expected "zoi"]) pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'z' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"zoi") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'l' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"la'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_3 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanStarRule19 pappyDvs5 of
Parsed vs pappyDvs7 pappyErr7 ->
case lojbanLEhU pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
ErrorQuote vs) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'l' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
Parsed (
"lo'u") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_4 pappyErr1 =
case lojbanlerfuString d of
Parsed l pappyDvs3 pappyErr3 ->
case lojbanMOI pappyDvs3 of
NoParse pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
LerfuString l) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanBOI pappyDvs3 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs3 pappyErr9
Parsed _ _ pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
pappyAlt1_5 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbantext pappyDvs5 of
Parsed t pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
Quote t) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_6 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case pappyResult11 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
where
pappyResult11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (max pappyErr15 pappyErr13)
NoParse pappyErr15 -> NoParse (max pappyErr15 pappyErr13)
NoParse pappyErr13 -> NoParse pappyErr13
where
pappyResult13 =
case lojbanChar pappyDvs7 of
Parsed 'l' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'u' pappyDvs21 _ ->
Parsed (
"li'u") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
NoParse pappyErr7 -> pappyAlt1_6 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'l' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
Parsed (
"lu") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_6 pappyErr1 =
case lojbanqualifier d of
Parsed qual pappyDvs3 pappyErr3 ->
case lojbanmaybeRelativeClauses pappyDvs3 of
Parsed rels pappyDvs5 pappyErr5 ->
case lojbansumti pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
QualifiedSumti qual rels s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_7 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanLUhU pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_7 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_7 (max pappyErr3 pappyErr1)
pappyAlt1_7 pappyErr1 =
case lojbanKOhA d of
Parsed k pappyDvs3 pappyErr3 ->
case (k `elem` ["do","ko","do'o","mi","ma'a","mi'a","mi'o"]) of
True ->
Parsed (
NonAnaphoricProsumti k) pappyDvs3 (max pappyErr3 pappyErr1)
False -> pappyAlt1_8 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_8 (max pappyErr3 pappyErr1)
pappyAlt1_8 pappyErr1 =
case lojbanKOhA d of
Parsed k pappyDvs3 pappyErr3 ->
case (k `elem` ["ti","ta","tu"]) of
True ->
Parsed (
NonAnaphoricProsumti k) pappyDvs3 (max pappyErr3 pappyErr1)
False -> pappyAlt1_9 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_9 (max pappyErr3 pappyErr1)
pappyAlt1_9 pappyErr1 =
case lojbanKOhA d of
Parsed k pappyDvs3 pappyErr3 ->
case (k `elem` ["da'e","de'e","di'e","da'u","de'u","di'u","dei","do'i"]) of
True ->
Parsed (
NonAnaphoricProsumti k) pappyDvs3 (max pappyErr3 pappyErr1)
False -> pappyAlt1_10 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_10 (max pappyErr3 pappyErr1)
pappyAlt1_10 pappyErr1 =
case pappyResult3 of
Parsed n pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mn pappyDvs5 pappyErr5 ->
Parsed (
Variable $ fromMaybe n mn) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_11 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanxiLit pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_11 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanKOhA d of
Parsed "da" pappyDvs7 pappyErr7 ->
Parsed (
1) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_2 (max (ParseError (lojbanPos d) [Expected "da"]) pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanKOhA d of
Parsed "de" pappyDvs7 pappyErr7 ->
Parsed (
2) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_3 (max (ParseError (lojbanPos d) [Expected "de"]) pappyErr5)
pappyAlt5_3 pappyErr5 =
case lojbanKOhA d of
Parsed "di" pappyDvs7 pappyErr7 ->
Parsed (
3) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_4 (max (ParseError (lojbanPos d) [Expected "di"]) pappyErr5)
pappyAlt5_4 pappyErr5 = NoParse pappyErr5
pappyAlt1_11 pappyErr1 =
case lojbanKOhA d of
Parsed "ke'a" pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mn pappyDvs5 pappyErr5 ->
Parsed (
RelVar $ fromMaybe 1 mn) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_12 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanxiLit pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
_ -> pappyAlt1_12 (max (ParseError (lojbanPos d) [Expected "ke'a"]) pappyErr1)
pappyAlt1_12 pappyErr1 =
case lojbanKOhA d of
Parsed "ce'u" pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed ml pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mn pappyDvs7 pappyErr7 ->
Parsed (
LambdaVar ml mn) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_13 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanxiLit pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_13 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanxiLit pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
_ -> pappyAlt1_13 (max (ParseError (lojbanPos d) [Expected "ce'u"]) pappyErr1)
pappyAlt1_13 pappyErr1 =
case lojbanKOhA d of
Parsed "ri" pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mn pappyDvs5 pappyErr5 ->
Parsed (
Ri $ fromMaybe 1 mn) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_14 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanxiLit pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
_ -> pappyAlt1_14 (max (ParseError (lojbanPos d) [Expected "ri"]) pappyErr1)
pappyAlt1_14 pappyErr1 =
case lojbanKOhA d of
Parsed "ra" pappyDvs3 pappyErr3 ->
Parsed (
Ra "ra") pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_15 (max (ParseError (lojbanPos d) [Expected "ra"]) pappyErr1)
pappyAlt1_15 pappyErr1 =
case lojbanKOhA d of
Parsed "ru" pappyDvs3 pappyErr3 ->
Parsed (
Ra "ru") pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_16 (max (ParseError (lojbanPos d) [Expected "ru"]) pappyErr1)
pappyAlt1_16 pappyErr1 =
case pappyResult3 of
Parsed n pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mn pappyDvs5 pappyErr5 ->
Parsed (
Assignable $ fromMaybe n mn) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_17 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanxiLit pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_17 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanKOhA d of
Parsed "ko'a" pappyDvs7 pappyErr7 ->
Parsed (
1) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_2 (max (ParseError (lojbanPos d) [Expected "ko'a"]) pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanKOhA d of
Parsed "ko'e" pappyDvs7 pappyErr7 ->
Parsed (
2) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_3 (max (ParseError (lojbanPos d) [Expected "ko'e"]) pappyErr5)
pappyAlt5_3 pappyErr5 =
case lojbanKOhA d of
Parsed "ko'i" pappyDvs7 pappyErr7 ->
Parsed (
3) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_4 (max (ParseError (lojbanPos d) [Expected "ko'i"]) pappyErr5)
pappyAlt5_4 pappyErr5 =
case lojbanKOhA d of
Parsed "ko'o" pappyDvs7 pappyErr7 ->
Parsed (
4) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_5 (max (ParseError (lojbanPos d) [Expected "ko'o"]) pappyErr5)
pappyAlt5_5 pappyErr5 =
case lojbanKOhA d of
Parsed "ko'u" pappyDvs7 pappyErr7 ->
Parsed (
5) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_6 (max (ParseError (lojbanPos d) [Expected "ko'u"]) pappyErr5)
pappyAlt5_6 pappyErr5 =
case lojbanKOhA d of
Parsed "fo'a" pappyDvs7 pappyErr7 ->
Parsed (
6) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_7 (max (ParseError (lojbanPos d) [Expected "fo'a"]) pappyErr5)
pappyAlt5_7 pappyErr5 =
case lojbanKOhA d of
Parsed "fo'e" pappyDvs7 pappyErr7 ->
Parsed (
7) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_8 (max (ParseError (lojbanPos d) [Expected "fo'e"]) pappyErr5)
pappyAlt5_8 pappyErr5 =
case lojbanKOhA d of
Parsed "fo'i" pappyDvs7 pappyErr7 ->
Parsed (
8) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_9 (max (ParseError (lojbanPos d) [Expected "fo'i"]) pappyErr5)
pappyAlt5_9 pappyErr5 =
case lojbanKOhA d of
Parsed "fo'o" pappyDvs7 pappyErr7 ->
Parsed (
9) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_10 (max (ParseError (lojbanPos d) [Expected "fo'o"]) pappyErr5)
pappyAlt5_10 pappyErr5 =
case lojbanKOhA d of
Parsed "fo'u" pappyDvs7 pappyErr7 ->
Parsed (
10) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_11 (max (ParseError (lojbanPos d) [Expected "fo'u"]) pappyErr5)
pappyAlt5_11 pappyErr5 = NoParse pappyErr5
pappyAlt1_17 pappyErr1 =
case pappyResult3 of
Parsed n pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mn pappyDvs5 pappyErr5 ->
Parsed (
MainBridiSumbasti $ fromMaybe n mn) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_18 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanxiLit pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_18 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanKOhA d of
Parsed "vo'a" pappyDvs7 pappyErr7 ->
Parsed (
1) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_2 (max (ParseError (lojbanPos d) [Expected "vo'a"]) pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanKOhA d of
Parsed "vo'e" pappyDvs7 pappyErr7 ->
Parsed (
2) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_3 (max (ParseError (lojbanPos d) [Expected "vo'e"]) pappyErr5)
pappyAlt5_3 pappyErr5 =
case lojbanKOhA d of
Parsed "vo'i" pappyDvs7 pappyErr7 ->
Parsed (
3) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_4 (max (ParseError (lojbanPos d) [Expected "vo'i"]) pappyErr5)
pappyAlt5_4 pappyErr5 =
case lojbanKOhA d of
Parsed "vo'o" pappyDvs7 pappyErr7 ->
Parsed (
4) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_5 (max (ParseError (lojbanPos d) [Expected "vo'o"]) pappyErr5)
pappyAlt5_5 pappyErr5 =
case lojbanKOhA d of
Parsed "vo'u" pappyDvs7 pappyErr7 ->
Parsed (
5) pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_6 (max (ParseError (lojbanPos d) [Expected "vo'u"]) pappyErr5)
pappyAlt5_6 pappyErr5 = NoParse pappyErr5
pappyAlt1_18 pappyErr1 =
case lojbanKOhA d of
Parsed "zo'e" pappyDvs3 pappyErr3 ->
Parsed (
Zohe) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_19 (max (ParseError (lojbanPos d) [Expected "zo'e"]) pappyErr1)
pappyAlt1_19 pappyErr1 =
case lojbanKOhA d of
Parsed k pappyDvs3 pappyErr3 ->
case (k `elem` ["zi'o","zu'i"]) of
True ->
Parsed (
NonAnaphoricProsumti k) pappyDvs3 (max pappyErr3 pappyErr1)
False -> pappyAlt1_20 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_20 (max pappyErr3 pappyErr1)
pappyAlt1_20 pappyErr1 =
case lojbanKOhA d of
Parsed "ma" pappyDvs3 pappyErr3 ->
Parsed (
SumtiQ Nothing) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_21 (max (ParseError (lojbanPos d) [Expected "ma"]) pappyErr1)
pappyAlt1_21 pappyErr1 =
case lojbanLA d of
Parsed g pappyDvs3 pappyErr3 ->
case lojbanname pappyDvs3 of
Parsed n pappyDvs5 pappyErr5 ->
Parsed (
n g) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_22 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_22 (max pappyErr3 pappyErr1)
pappyAlt1_22 pappyErr1 =
case pappyResult3 of
Parsed g pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed ((is,q,ssb,rels,irels)) pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
Description g is q ssb rels irels) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_23 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
Parsed _ _ _ -> pappyAlt1_23 (max pappyErr3 pappyErr1)
NoParse pappyErr5 -> pappyAlt1_23 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case lojbansumti6 pappyDvs3 of
Parsed s pappyDvs9 pappyErr9 ->
case lojbanmaybeRelativeClauses pappyDvs9 of
Parsed srels pappyDvs11 pappyErr11 ->
case lojbansumtiTail1 pappyDvs11 of
Parsed ((q,ssb,irels)) pappyDvs13 pappyErr13 ->
Parsed (
(Just (QAtom [] Nothing srels s),q,ssb,[],irels)) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
Parsed _ _ _ -> pappyAlt7_2 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr13 -> pappyAlt7_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_2 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
pappyAlt7_2 pappyErr7 =
case lojbanmaybeRelativeClauses pappyDvs3 of
Parsed rels pappyDvs9 pappyErr9 ->
case lojbansumtiTail1 pappyDvs9 of
Parsed ((q,ssb,irels)) pappyDvs11 pappyErr11 ->
Parsed (
(Nothing,q,ssb,rels,irels)) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
Parsed _ _ _ -> pappyAlt7_3 (max pappyErr9 pappyErr7)
NoParse pappyErr11 -> pappyAlt7_3 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_3 (max pappyErr9 pappyErr7)
pappyAlt7_3 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> pappyAlt1_23 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanLA d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
where
pappyResult7 =
case lojbanChar d of
Parsed 'l' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
Parsed (
"le'i") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
Parsed 'e' pappyDvs15 _ ->
Parsed (
"le'e") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'i' pappyDvs13 _ ->
Parsed (
"lei") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ ->
Parsed (
"le") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'o' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
Parsed (
"lo'i") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
Parsed 'e' pappyDvs15 _ ->
Parsed (
"lo'e") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'i' pappyDvs13 _ ->
Parsed (
"loi") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ ->
Parsed (
"lo") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_23 pappyErr1 =
pappyAlt3_1 pappyErr1 where
pappyAlt3_1 pappyErr3 =
case lojbanLI d of
Parsed "li" pappyDvs5 pappyErr5 ->
case lojbanmex pappyDvs5 of
Parsed m pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
MexLi m ) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr9 -> pappyAlt3_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
where
pappyResult9 =
case lojbanLOhO pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt3_2 (maximum [pappyErr7,pappyErr5,pappyErr3])
_ -> pappyAlt3_2 (max (ParseError (lojbanPos d) [Expected "li"]) pappyErr3)
pappyAlt3_2 pappyErr3 =
case lojbanLI d of
Parsed "me'o" pappyDvs5 pappyErr5 ->
case lojbanmex pappyDvs5 of
Parsed m pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
MexMex m ) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
NoParse pappyErr9 -> pappyAlt3_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3])
where
pappyResult9 =
case lojbanLOhO pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt3_3 (maximum [pappyErr7,pappyErr5,pappyErr3])
_ -> pappyAlt3_3 (max (ParseError (lojbanPos d) [Expected "me'o"]) pappyErr3)
pappyAlt3_3 pappyErr3 = pappyAlt1_24 pappyErr3
pappyAlt1_24 pappyErr1 = NoParse pappyErr1
lojbanParsequalifier :: LojbanDerivs -> Result LojbanDerivs (SumtiQualifier)
lojbanParsequalifier d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed l pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
LAhE l) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 't' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"tu'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'l' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"lu'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'o' pappyDvs11 _ ->
Parsed (
"lu'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'i' pappyDvs11 _ ->
Parsed (
"lu'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'e' pappyDvs11 _ ->
Parsed (
"lu'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"la'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'v' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"vu'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_2 pappyErr1 =
case lojbanNAhE d of
Parsed n pappyDvs3 pappyErr3 ->
case lojbanBO pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
NAhE_BO n) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule7 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParsePlusRule7 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanCMENE d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule7 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanCMENE d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanname :: LojbanDerivs -> Result LojbanDerivs (Gadri -> SumtiAtom)
lojbanname d =
case lojbanmaybeRelativeClauses d of
Parsed rels pappyDvs1 pappyErr1 ->
case lojbanPlusRule7 pappyDvs1 of
Parsed cs pappyDvs3 pappyErr3 ->
Parsed (
\g -> Name g rels $ unwords cs) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule17 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParseStarRule17 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule17 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanWord d of
Parsed w pappyDvs5 pappyErr5 ->
case (w/="zoi") of
True ->
Parsed (w) pappyDvs5 pappyErr5
False -> NoParse pappyErr5
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule18 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParseStarRule18 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule18 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanWord d of
Parsed w pappyDvs5 pappyErr5 ->
case (w/="gy") of
True ->
Parsed (w) pappyDvs5 pappyErr5
False -> NoParse pappyErr5
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule19 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParseStarRule19 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanLEhU d of
NoParse pappyErr3 ->
case lojbanValsi d of
Parsed v pappyDvs5 pappyErr5 ->
case lojbanStarRule19 pappyDvs5 of
Parsed vs pappyDvs7 pappyErr7 ->
Parsed (
v : vs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsesumtiTail1 :: LojbanDerivs -> Result LojbanDerivs ((Maybe Mex, Either Selbri Sumti, [RelClause]))
lojbanParsesumtiTail1 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanselbri d of
Parsed sb pappyDvs3 pappyErr3 ->
case lojbanmaybeRelativeClauses pappyDvs3 of
Parsed rels pappyDvs5 pappyErr5 ->
Parsed (
(Nothing,Left sb,rels)) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed mq pappyDvs3 pappyErr3 ->
case lojbanselbri pappyDvs3 of
Parsed sb pappyDvs5 pappyErr5 ->
case lojbanmaybeRelativeClauses pappyDvs5 of
Parsed rels pappyDvs7 pappyErr7 ->
Parsed (
(mq,Left sb,rels)) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanquantifier d of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
pappyAlt1_3 pappyErr1 =
case lojbanquantifier d of
Parsed q pappyDvs3 pappyErr3 ->
case lojbansumti pappyDvs3 of
Parsed s pappyDvs5 pappyErr5 ->
Parsed (
(Just q,Right s,[])) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanmaybeRelativeClauses :: LojbanDerivs -> Result LojbanDerivs ([RelClause])
lojbanmaybeRelativeClauses d =
case pappyResult1 of
Parsed mrels pappyDvs1 pappyErr1 ->
Parsed (
fromMaybe [] mrels) pappyDvs1 pappyErr1
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanrelativeClauses d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3
lojbanParseStarRule20 :: LojbanDerivs -> Result LojbanDerivs ([RelClause])
lojbanParseStarRule20 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanrelativeClause pappyDvs5 of
Parsed v pappyDvs7 pappyErr7 ->
case lojbanStarRule20 pappyDvs7 of
Parsed vs pappyDvs9 pappyErr9 ->
Parsed (
v : vs) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'z' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"zi'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanrelativeClauses :: LojbanDerivs -> Result LojbanDerivs ([RelClause])
lojbanrelativeClauses d =
case lojbanrelativeClause d of
Parsed r pappyDvs1 pappyErr1 ->
case lojbanStarRule20 pappyDvs1 of
Parsed rs pappyDvs3 pappyErr3 ->
Parsed (
(r:rs)) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParserelativeClause :: LojbanDerivs -> Result LojbanDerivs (RelClause)
lojbanParserelativeClause d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanNOI d of
Parsed "poi" pappyDvs3 pappyErr3 ->
case lojbansubsentence pappyDvs3 of
Parsed subs pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
Restrictive subs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKUhO pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_2 (max (ParseError (lojbanPos d) [Expected "poi"]) pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanNOI d of
Parsed "noi" pappyDvs3 pappyErr3 ->
case lojbansubsentence pappyDvs3 of
Parsed subs pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
Incidental subs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKUhO pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_3 (max (ParseError (lojbanPos d) [Expected "noi"]) pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanNOI d of
Parsed "voi" pappyDvs3 pappyErr3 ->
case lojbansubsentence pappyDvs3 of
Parsed subs pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
Descriptive subs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKUhO pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_4 (max (ParseError (lojbanPos d) [Expected "voi"]) pappyErr1)
pappyAlt1_4 pappyErr1 =
case lojbanGOI d of
Parsed "goi" pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
Assignment t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanGEhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_5 (max (ParseError (lojbanPos d) [Expected "goi"]) pappyErr1)
pappyAlt1_5 pappyErr1 =
case lojbanGOI d of
Parsed "ne" pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
IncidentalGOI "ne" t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_6 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanGEhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_6 (max (ParseError (lojbanPos d) [Expected "ne"]) pappyErr1)
pappyAlt1_6 pappyErr1 =
case lojbanGOI d of
Parsed "no'u" pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
IncidentalGOI "no'u" t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanGEhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_7 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_7 (max (ParseError (lojbanPos d) [Expected "no'u"]) pappyErr1)
pappyAlt1_7 pappyErr1 =
case lojbanGOI d of
Parsed "pe" pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
RestrictiveGOI "pe" t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_8 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanGEhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_8 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_8 (max (ParseError (lojbanPos d) [Expected "pe"]) pappyErr1)
pappyAlt1_8 pappyErr1 =
case lojbanGOI d of
Parsed "po'u" pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
RestrictiveGOI "po'u" t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_9 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanGEhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_9 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_9 (max (ParseError (lojbanPos d) [Expected "po'u"]) pappyErr1)
pappyAlt1_9 pappyErr1 =
case lojbanGOI d of
Parsed "po" pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
RestrictiveGOI "po" t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_10 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanGEhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_10 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_10 (max (ParseError (lojbanPos d) [Expected "po"]) pappyErr1)
pappyAlt1_10 pappyErr1 =
case lojbanGOI d of
Parsed "po'e" pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
RestrictiveGOI "po'e" t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_11 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanGEhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_11 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_11 (max (ParseError (lojbanPos d) [Expected "po'e"]) pappyErr1)
pappyAlt1_11 pappyErr1 = NoParse pappyErr1
lojbanParseselbri :: LojbanDerivs -> Result LojbanDerivs (Selbri)
lojbanParseselbri d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbantag d of
Parsed tag pappyDvs3 pappyErr3 ->
case lojbanselbri1 pappyDvs3 of
Parsed sb pappyDvs5 pappyErr5 ->
Parsed (
TaggedSelbri tag sb) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanselbri1 d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanselbri1 :: LojbanDerivs -> Result LojbanDerivs (Selbri)
lojbanselbri1 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanNA d of
Parsed "na" pappyDvs3 pappyErr3 ->
case lojbanselbri pappyDvs3 of
Parsed sb pappyDvs5 pappyErr5 ->
Parsed (
Negated sb) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
_ -> pappyAlt1_2 (max (ParseError (lojbanPos d) [Expected "na"]) pappyErr1)
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanselbri2 pappyDvs3 of
Parsed sb pappyDvs5 pappyErr5 ->
Parsed (
Selbri2 sb) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
where
pappyResult5 =
case lojbanNA d of
Parsed "ja'a" pappyDvs7 pappyErr7 ->
Parsed () pappyDvs7 pappyErr7
_ -> NoParse (ParseError (lojbanPos d) [Expected "ja'a"])
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseselbri2 :: LojbanDerivs -> Result LojbanDerivs (Selbri2)
lojbanParseselbri2 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanselbri3 d of
Parsed sb pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed s pappyDvs5 pappyErr5 ->
case lojbanpostClause pappyDvs5 of
Parsed _ pappyDvs7 pappyErr7 ->
case lojbanselbri2 pappyDvs7 of
Parsed sb' pappyDvs9 pappyErr9 ->
Parsed (
SBInverted sb sb') pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanChar pappyDvs3 of
Parsed 'c' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"co") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanselbri3 d of
Parsed sb pappyDvs3 pappyErr3 ->
Parsed (
Selbri3 sb) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseselbri3Tail :: LojbanDerivs -> Result LojbanDerivs ((Selbri3 -> Selbri3))
lojbanParseselbri3Tail d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanselbri4 d of
Parsed sb' pappyDvs3 pappyErr3 ->
case lojbanselbri3Tail pappyDvs3 of
Parsed pappyTail pappyDvs5 pappyErr5 ->
Parsed (
\sb -> pappyTail (SBTanru sb sb')) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
\v -> v) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanselbri3 :: LojbanDerivs -> Result LojbanDerivs (Selbri3)
lojbanselbri3 d =
case lojbanselbri4 d of
Parsed l pappyDvs1 pappyErr1 ->
case lojbanselbri3Tail pappyDvs1 of
Parsed t pappyDvs3 pappyErr3 ->
Parsed (
t l) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule21 :: LojbanDerivs -> Result LojbanDerivs ([(Connective, Selbri3)])
lojbanParseStarRule21 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule21 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanjoikJek d of
Parsed jj pappyDvs7 pappyErr7 ->
case lojbanselbri5 pappyDvs7 of
Parsed sb pappyDvs9 pappyErr9 ->
Parsed (
(jjJboCon Nothing jj,sb)) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanjoik d of
Parsed joik pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mtag pappyDvs9 pappyErr9 ->
case lojbanKE pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbanselbri3 pappyDvs11 of
Parsed sb pappyDvs13 pappyErr13 ->
case pappyResult15 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (
(JboConnJoik mtag joik,sb)) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr15 -> pappyAlt5_3 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
where
pappyResult15 =
case lojbanKEhE pappyDvs13 of
Parsed pappyVal17 pappyDvs17 pappyErr17 -> Parsed (Just pappyVal17) pappyDvs17 pappyErr17
NoParse pappyErr17 -> Parsed (Nothing) pappyDvs13 pappyErr17
NoParse pappyErr13 -> pappyAlt5_3 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr11 -> pappyAlt5_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
where
pappyResult9 =
case lojbantag pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanselbri4 :: LojbanDerivs -> Result LojbanDerivs (Selbri3)
lojbanselbri4 d =
case lojbanselbri5 d of
Parsed sb pappyDvs1 pappyErr1 ->
case lojbanStarRule21 pappyDvs1 of
Parsed jekss pappyDvs3 pappyErr3 ->
Parsed (
foldl (\sb1 -> \(con,sb2) -> ConnectedSB False con (sb3tosb sb1) sb2) sb jekss ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseselbri5 :: LojbanDerivs -> Result LojbanDerivs (Selbri3)
lojbanParseselbri5 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanselbri6 d of
Parsed sb1 pappyDvs3 pappyErr3 ->
case lojbanjoikJek pappyDvs3 of
Parsed jj pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mtag pappyDvs7 pappyErr7 ->
case lojbanBO pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbanselbri5 pappyDvs9 of
Parsed sb2 pappyDvs11 pappyErr11 ->
Parsed (
ConnectedSB False (jjJboCon mtag jj) (sb3tosb sb1) sb2 ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbantag pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanselbri6 d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseselbri6 :: LojbanDerivs -> Result LojbanDerivs (Selbri3)
lojbanParseselbri6 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbantanruUnit d of
Parsed tu pappyDvs3 pappyErr3 ->
case lojbanBO pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanselbri6 pappyDvs5 of
Parsed sb pappyDvs7 pappyErr7 ->
Parsed (
SBTanru tu sb) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbantanruUnit d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case pappyResult3 of
Parsed mn pappyDvs3 pappyErr3 ->
case lojbanguhek pappyDvs3 of
Parsed pcon pappyDvs5 pappyErr5 ->
case lojbanselbri pappyDvs5 of
Parsed sb1 pappyDvs7 pappyErr7 ->
case lojbangik pappyDvs7 of
Parsed b pappyDvs9 pappyErr9 ->
case lojbanselbri6 pappyDvs9 of
Parsed sb2 pappyDvs11 pappyErr11 ->
Parsed (
maybe id ScalarNegatedSB mn $
ConnectedSB True (jboConnLogOrQ Nothing $ pcon b) sb1 sb2 ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_4 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanNAhE d of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParsetanruUnitTail :: LojbanDerivs -> Result LojbanDerivs ((Selbri3 -> Selbri3))
lojbanParsetanruUnitTail d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbantanruUnit1 pappyDvs5 of
Parsed tu' pappyDvs7 pappyErr7 ->
case lojbantanruUnitTail pappyDvs7 of
Parsed pappyTail pappyDvs9 pappyErr9 ->
Parsed (
\tu -> pappyTail (BridiBinding tu tu')) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'c' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"cei") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_2 pappyErr1 =
Parsed (
\v -> v) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbantanruUnit :: LojbanDerivs -> Result LojbanDerivs (Selbri3)
lojbantanruUnit d =
case lojbantanruUnit1 d of
Parsed l pappyDvs1 pappyErr1 ->
case lojbantanruUnitTail pappyDvs1 of
Parsed t pappyDvs3 pappyErr3 ->
Parsed (
t l) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule22 :: LojbanDerivs -> Result LojbanDerivs ([Free])
lojbanParseStarRule22 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanfree d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule22 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbantanruUnit1 :: LojbanDerivs -> Result LojbanDerivs (Selbri3)
lojbantanruUnit1 d =
case lojbantanruUnit2 d of
Parsed tu pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed k pappyDvs3 pappyErr3 ->
case lojbanStarRule22 pappyDvs3 of
Parsed fs pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed las pappyDvs7 pappyErr7 ->
Parsed (
TanruUnit fs (maybe tu (TUBridiQ . Just) k) (fromMaybe [] las)) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanlinkargs pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case lojbanUI pappyDvs1 of
Parsed "kau" pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed x pappyDvs9 pappyErr9 ->
Parsed (
fromMaybe 1 x) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanxiLit pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
_ -> NoParse (ParseError (lojbanPos pappyDvs1) [Expected "kau"])
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsePlusRule8 :: LojbanDerivs -> Result LojbanDerivs ([String])
lojbanParsePlusRule8 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanZEI d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanValsi pappyDvs3 of
Parsed v pappyDvs5 pappyErr5 ->
case lojbanPlusRule8 pappyDvs5 of
Parsed vs pappyDvs7 pappyErr7 ->
Parsed (
v : vs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanZEI d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanValsi pappyDvs3 of
Parsed v pappyDvs5 pappyErr5 ->
Parsed (
[v]) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsetanruUnit2 :: LojbanDerivs -> Result LojbanDerivs (TanruUnit)
lojbanParsetanruUnit2 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanValsi d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule8 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
TUZei $ v:vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanCMENE d of
NoParse pappyErr3 ->
case pappyResult5 of
NoParse pappyErr5 ->
case lojbanValsi d of
Parsed bv pappyDvs7 pappyErr7 ->
Parsed (
TUBrivla bv) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos d) []) where
pappyAlt7_1 pappyErr7 =
case lojbanConsonant d of
Parsed c pappyDvs9 pappyErr9 ->
case lojbanStarRule30 pappyDvs9 of
Parsed vs pappyDvs11 pappyErr11 ->
case lojbanPlusRule13 pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (
c:vs) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr13 -> pappyAlt7_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_2 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
pappyAlt7_2 pappyErr7 =
case lojbanPlusRule16 d of
Parsed vs pappyDvs9 pappyErr9 ->
case lojbanPlusRule13 pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (vs) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_3 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_3 (max pappyErr9 pappyErr7)
pappyAlt7_3 pappyErr7 = NoParse pappyErr7
Parsed _ _ pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanGOhA d of
Parsed "mo" pappyDvs3 pappyErr3 ->
Parsed (
TUBridiQ Nothing) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_4 (max (ParseError (lojbanPos d) [Expected "mo"]) pappyErr1)
pappyAlt1_4 pappyErr1 =
case lojbanGOhA d of
Parsed g pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed mn pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
TUGOhA g $ fromMaybe 1 mn) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
where
pappyResult9 =
case pappyResult11 of
Parsed s pappyDvs11 pappyErr11 ->
case lojbanpostClause pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (s) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
NoParse pappyErr11 -> NoParse pappyErr11
where
pappyResult11 =
case lojbanChar pappyDvs5 of
Parsed 'r' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'a' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
Parsed (
"ra'o") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanxiLit pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
pappyAlt1_5 pappyErr1 =
case lojbanKE d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanselbri3 pappyDvs3 of
Parsed sb pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
TUSelbri3 sb) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_6 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKEhE pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
pappyAlt1_6 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed mmoi pappyDvs11 pappyErr11 ->
Parsed (
maybe (TUMe s) (TUMoi s) mmoi) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_7 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult11 =
case lojbanMOI pappyDvs9 of
Parsed pappyVal13 pappyDvs13 pappyErr13 -> Parsed (Just pappyVal13) pappyDvs13 pappyErr13
NoParse pappyErr13 -> Parsed (Nothing) pappyDvs9 pappyErr13
NoParse pappyErr9 -> pappyAlt1_7 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case pappyResult11 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
where
pappyResult11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (max pappyErr15 pappyErr13)
NoParse pappyErr15 -> NoParse (max pappyErr15 pappyErr13)
NoParse pappyErr13 -> NoParse pappyErr13
where
pappyResult13 =
case lojbanChar pappyDvs7 of
Parsed 'm' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'u' pappyDvs21 _ ->
Parsed (
"me'u") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
NoParse pappyErr7 -> pappyAlt1_7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
pappyAlt9_1 (ParseError (lojbanPos pappyDvs5) []) where
pappyAlt9_1 pappyErr9 =
case lojbansumti pappyDvs5 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed pappyVal11 pappyDvs11 (max pappyErr11 pappyErr9)
NoParse pappyErr11 -> pappyAlt9_2 (max pappyErr11 pappyErr9)
pappyAlt9_2 pappyErr9 =
case lojbanlerfuString pappyDvs5 of
Parsed ls pappyDvs11 pappyErr11 ->
Parsed (
QAtom [] Nothing [] $ LerfuString ls) pappyDvs11 (max pappyErr11 pappyErr9)
NoParse pappyErr11 -> pappyAlt9_3 (max pappyErr11 pappyErr9)
pappyAlt9_3 pappyErr9 = NoParse pappyErr9
NoParse pappyErr5 -> pappyAlt1_7 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_7 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'm' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
Parsed (
"me") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_7 pappyErr1 =
case lojbannumberOrLerfuString d of
Parsed q pappyDvs3 pappyErr3 ->
case lojbanMOI pappyDvs3 of
Parsed moi pappyDvs5 pappyErr5 ->
Parsed (
TUMoi (QAtom [] Nothing [] $ MexLi q) moi) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_8 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_8 (max pappyErr3 pappyErr1)
pappyAlt1_8 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanmexOperator pappyDvs5 of
Parsed op pappyDvs7 pappyErr7 ->
Parsed (
TUOperator op) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_9 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_9 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_9 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'n' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"nu'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_9 pappyErr1 =
case lojbanconvSE d of
Parsed n pappyDvs3 pappyErr3 ->
case lojbantanruUnit2 pappyDvs3 of
Parsed tu pappyDvs5 pappyErr5 ->
Parsed (
TUPermuted n tu) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_10 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_10 (max pappyErr3 pappyErr1)
pappyAlt1_10 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mt pappyDvs7 pappyErr7 ->
case lojbantanruUnit2 pappyDvs7 of
Parsed tu pappyDvs9 pappyErr9 ->
Parsed (
TUJai mt tu) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_11 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_11 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbantag pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_11 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_11 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'j' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"jai") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_11 pappyErr1 =
case lojbanNAhE d of
Parsed n pappyDvs3 pappyErr3 ->
case lojbantanruUnit2 pappyDvs3 of
Parsed tu pappyDvs5 pappyErr5 ->
Parsed (
TUSelbri3 $ ScalarNegatedSB n $ TanruUnit [] tu []) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_12 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_12 (max pappyErr3 pappyErr1)
pappyAlt1_12 pappyErr1 =
case lojbanabstractor d of
Parsed a pappyDvs3 pappyErr3 ->
case lojbansubsentence pappyDvs3 of
Parsed ss pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
TUAbstraction a ss) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_13 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
where
pappyResult9 =
case pappyResult11 of
Parsed s pappyDvs11 pappyErr11 ->
case lojbanpostClause pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (s) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
NoParse pappyErr11 -> NoParse pappyErr11
where
pappyResult11 =
case lojbanChar pappyDvs5 of
Parsed 'k' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'e' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"kei") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
NoParse pappyErr5 -> pappyAlt1_13 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_13 (max pappyErr3 pappyErr1)
pappyAlt1_13 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbantag pappyDvs5 of
Parsed t pappyDvs7 pappyErr7 ->
Parsed (
TUXOhI t) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_14 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_14 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_14 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'x' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"xo'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_14 pappyErr1 = NoParse pappyErr1
lojbanconvSE :: LojbanDerivs -> Result LojbanDerivs (Int)
lojbanconvSE d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanSE d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanxiLit pappyDvs3 of
Parsed n pappyDvs5 pappyErr5 ->
Parsed (n) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanSE d of
Parsed "se" pappyDvs3 pappyErr3 ->
Parsed (
2) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_3 (max (ParseError (lojbanPos d) [Expected "se"]) pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanSE d of
Parsed "te" pappyDvs3 pappyErr3 ->
Parsed (
3) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_4 (max (ParseError (lojbanPos d) [Expected "te"]) pappyErr1)
pappyAlt1_4 pappyErr1 =
case lojbanSE d of
Parsed "ve" pappyDvs3 pappyErr3 ->
Parsed (
4) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_5 (max (ParseError (lojbanPos d) [Expected "ve"]) pappyErr1)
pappyAlt1_5 pappyErr1 =
case lojbanSE d of
Parsed "xe" pappyDvs3 pappyErr3 ->
Parsed (
5) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_6 (max (ParseError (lojbanPos d) [Expected "xe"]) pappyErr1)
pappyAlt1_6 pappyErr1 = NoParse pappyErr1
lojbanParseabstractor :: LojbanDerivs -> Result LojbanDerivs (Abstractor)
lojbanParseabstractor d =
case pappyResult1 of
Parsed n pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed nai pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mca pappyDvs7 pappyErr7 ->
Parsed (
let a1 = (if isJust nai then NegatedAbstractor else id) $ NU n
in case mca of
Nothing -> a1
Just (JJJek lcon,a2) -> LogConnectedAbstractor lcon a1 a2
Just (JJJoik joik,a2) -> JoiConnectedAbstractor joik a1 a2) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case pappyResult9 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
where
pappyResult9 =
case lojbanjoikJek pappyDvs5 of
Parsed jj pappyDvs11 pappyErr11 ->
case lojbanabstractor pappyDvs11 of
Parsed a pappyDvs13 pappyErr13 ->
Parsed (
(jj,a)) pappyDvs13 (max pappyErr13 pappyErr11)
NoParse pappyErr13 -> NoParse (max pappyErr13 pappyErr11)
NoParse pappyErr11 -> NoParse pappyErr11
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanNAI pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ni") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"nu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'd' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"du'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 's' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"si'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"su'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'l' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"li'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
Parsed (
"ka") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"jei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'z' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"zu'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"za'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"mu'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'p' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"pu'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"poi'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanlinkargs :: LojbanDerivs -> Result LojbanDerivs ([Term])
lojbanlinkargs d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed ts pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
(t : (fromMaybe [] ts))) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> NoParse (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case pappyResult11 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
where
pappyResult11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (max pappyErr15 pappyErr13)
NoParse pappyErr15 -> NoParse (max pappyErr15 pappyErr13)
NoParse pappyErr13 -> NoParse pappyErr13
where
pappyResult13 =
case lojbanChar pappyDvs7 of
Parsed 'b' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'o' pappyDvs21 _ ->
Parsed (
"be'o") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanlinks pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
Parsed (
"be") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanParselinks :: LojbanDerivs -> Result LojbanDerivs ([Term])
lojbanParselinks d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanterm pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed ts pappyDvs7 pappyErr7 ->
Parsed (
(t : (fromMaybe [] ts))) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanlinks pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"bei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanquantifier :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanquantifier d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbannumber d of
Parsed q pappyDvs3 pappyErr3 ->
case lojbanMOI pappyDvs3 of
NoParse pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (q) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanBOI pappyDvs3 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs3 pappyErr9
Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanVEI d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanmex pappyDvs3 of
Parsed m pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (m) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanVEhO pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule23 :: LojbanDerivs -> Result LojbanDerivs ([Mex -> Mex])
lojbanParseStarRule23 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanoptail d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule23 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanmex :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanmex d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanmex1 d of
Parsed m pappyDvs3 pappyErr3 ->
case lojbanStarRule23 pappyDvs3 of
Parsed opts pappyDvs5 pappyErr5 ->
Parsed (
foldl (flip ($)) m opts) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanrpExpression pappyDvs5 of
Parsed e pappyDvs7 pappyErr7 ->
Parsed (e) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'f' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"fu'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanoptail :: LojbanDerivs -> Result LojbanDerivs (Mex -> Mex)
lojbanoptail d =
case lojbanoperator d of
Parsed o pappyDvs1 pappyErr1 ->
case lojbanmex1 pappyDvs1 of
Parsed m pappyDvs3 pappyErr3 ->
Parsed (
\m1 -> Operation o [m1,m] ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsemex1 :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanParsemex1 d =
case lojbanmex2 d of
Parsed m pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed mopt pappyDvs3 pappyErr3 ->
Parsed (
maybe m ($m) mopt) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
where
pappyResult5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbanoptail pappyDvs9 of
Parsed opt pappyDvs11 pappyErr11 ->
Parsed (opt) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> NoParse (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
NoParse pappyErr7 -> NoParse pappyErr7
where
pappyResult7 =
case lojbanChar pappyDvs1 of
Parsed 'b' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'e' pappyDvs15 _ ->
Parsed (
"bi'e") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs1) [])
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsemex2 :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanParsemex2 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanoperand d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanoperator pappyDvs3 of
Parsed op pappyDvs5 pappyErr5 ->
case lojbanPlusRule10 pappyDvs5 of
Parsed os pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
Operation op os) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_3 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case pappyResult11 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
where
pappyResult11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (max pappyErr15 pappyErr13)
NoParse pappyErr15 -> NoParse (max pappyErr15 pappyErr13)
NoParse pappyErr13 -> NoParse pappyErr13
where
pappyResult13 =
case lojbanChar pappyDvs7 of
Parsed 'k' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'e' pappyDvs21 _ ->
Parsed (
"ku'e") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case pappyResult5 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
where
pappyResult5 =
case pappyResult7 of
Parsed s pappyDvs7 pappyErr7 ->
case lojbanpostClause pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (s) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> NoParse (max pappyErr9 pappyErr7)
NoParse pappyErr7 -> NoParse pappyErr7
where
pappyResult7 =
case lojbanChar d of
Parsed 'p' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed '\'' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'o' pappyDvs15 _ ->
Parsed (
"pe'o") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanrpExpression :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanrpExpression d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanoperand d of
Parsed o pappyDvs3 pappyErr3 ->
case lojbanrpExpressionTail pappyDvs3 of
Parsed mt pappyDvs5 pappyErr5 ->
Parsed (
mt o ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanoperand d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParserpExpressionTail :: LojbanDerivs -> Result LojbanDerivs (Mex -> Mex)
lojbanParserpExpressionTail d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanrpExpression d of
Parsed m pappyDvs3 pappyErr3 ->
case lojbanoperator pappyDvs3 of
Parsed opr pappyDvs5 pappyErr5 ->
case lojbanrpExpressionTail pappyDvs5 of
Parsed t pappyDvs7 pappyErr7 ->
Parsed (
t . \m1 -> Operation opr [m1,m] ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanrpExpression d of
Parsed m pappyDvs3 pappyErr3 ->
case lojbanoperator pappyDvs3 of
Parsed opr pappyDvs5 pappyErr5 ->
Parsed (
\m1 -> Operation opr [m1,m] ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule24 :: LojbanDerivs -> Result LojbanDerivs ([(Connective, Operator)])
lojbanParseStarRule24 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule24 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanjoikJek d of
Parsed jj pappyDvs7 pappyErr7 ->
case lojbanoperator1 pappyDvs7 of
Parsed op pappyDvs9 pappyErr9 ->
Parsed (
(jjJboCon Nothing jj,op)) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_2 (maximum [pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanjoik d of
Parsed joik pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed mtag pappyDvs9 pappyErr9 ->
case lojbanKE pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbanoperator pappyDvs11 of
Parsed op pappyDvs13 pappyErr13 ->
case pappyResult15 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (
(JboConnJoik mtag joik,op)) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr15 -> pappyAlt5_3 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
where
pappyResult15 =
case lojbanKEhE pappyDvs13 of
Parsed pappyVal17 pappyDvs17 pappyErr17 -> Parsed (Just pappyVal17) pappyDvs17 pappyErr17
NoParse pappyErr17 -> Parsed (Nothing) pappyDvs13 pappyErr17
NoParse pappyErr13 -> pappyAlt5_3 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr11 -> pappyAlt5_3 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5])
NoParse pappyErr9 -> pappyAlt5_3 (maximum [pappyErr9,pappyErr7,pappyErr5])
where
pappyResult9 =
case lojbantag pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanoperator :: LojbanDerivs -> Result LojbanDerivs (Operator)
lojbanoperator d =
case lojbanoperator1 d of
Parsed op pappyDvs1 pappyErr1 ->
case lojbanStarRule24 pappyDvs1 of
Parsed jekss pappyDvs3 pappyErr3 ->
Parsed (
foldl (\op1 -> \(con,op2) -> ConnectedOperator False con op1 op2) op jekss ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseoperator1 :: LojbanDerivs -> Result LojbanDerivs (Operator)
lojbanParseoperator1 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanoperator2 d of
Parsed op1 pappyDvs3 pappyErr3 ->
case lojbanjoikJek pappyDvs3 of
Parsed jj pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mtag pappyDvs7 pappyErr7 ->
case lojbanBO pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbanoperator1 pappyDvs9 of
Parsed op2 pappyDvs11 pappyErr11 ->
Parsed (
ConnectedOperator False (jjJboCon mtag jj) op1 op2 ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbantag pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanoperator2 d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanguhek d of
Parsed pcon pappyDvs3 pappyErr3 ->
case lojbanoperator1 pappyDvs3 of
Parsed op1 pappyDvs5 pappyErr5 ->
case lojbangik pappyDvs5 of
Parsed b pappyDvs7 pappyErr7 ->
case lojbanoperator2 pappyDvs7 of
Parsed op2 pappyDvs9 pappyErr9 ->
Parsed (
ConnectedOperator True (jboConnLogOrQ Nothing $ pcon b) op1 op2 ) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParseoperator2 :: LojbanDerivs -> Result LojbanDerivs (Operator)
lojbanParseoperator2 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanmexOperator d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanKE d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanoperator pappyDvs3 of
Parsed op pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (op) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanKEhE pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsemexOperator :: LojbanDerivs -> Result LojbanDerivs (Operator)
lojbanParsemexOperator d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanconvSE d of
Parsed c pappyDvs3 pappyErr3 ->
case lojbanmexOperator pappyDvs3 of
Parsed op pappyDvs5 pappyErr5 ->
Parsed (
OpPermuted c op ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanNAhE d of
Parsed n pappyDvs3 pappyErr3 ->
case lojbanmexOperator pappyDvs3 of
Parsed op pappyDvs5 pappyErr5 ->
Parsed (
OpScalarNegated n op ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanmex pappyDvs5 of
Parsed m pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
OpMex m) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanTEhU pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'm' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"ma'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_4 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanselbri pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
OpSelbri s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_5 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanTEhU pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'n' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
Parsed (
"na'u") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_5 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
OpVUhU v) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'g' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"ge'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"gei") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'f' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
Parsed (
"fu'u") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"fe'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'a' pappyDvs11 _ ->
Parsed (
"fe'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"fa'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'p' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"pi'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'a' pappyDvs11 _ ->
Parsed (
"pi'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"pa'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'v' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
Parsed (
"vu'u") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"va'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 's' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"su'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"sa'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'i' pappyDvs11 _ ->
Parsed (
"sa'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"si'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'j' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'u' pappyDvs11 _ ->
Parsed (
"ju'u") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 't' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"te'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'c' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"cu'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'n' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"ne'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'd' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"de'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'r' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"re'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"ri'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_6 pappyErr1 = NoParse pappyErr1
lojbanParseoperand :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanParseoperand d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanoperand1 d of
Parsed o1 pappyDvs3 pappyErr3 ->
case lojbanjoikEk pappyDvs3 of
Parsed jj pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mtag pappyDvs7 pappyErr7 ->
case lojbanKE pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbanoperand pappyDvs9 of
Parsed o2 pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (
ConnectedMex False (jjJboCon mtag jj) o1 o2 ) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr13 -> pappyAlt1_2 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult13 =
case lojbanKEhE pappyDvs11 of
Parsed pappyVal15 pappyDvs15 pappyErr15 -> Parsed (Just pappyVal15) pappyDvs15 pappyErr15
NoParse pappyErr15 -> Parsed (Nothing) pappyDvs11 pappyErr15
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbantag pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanoperand1 d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule25 :: LojbanDerivs -> Result LojbanDerivs ([Mex -> Mex])
lojbanParseStarRule25 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule25 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanjoikEk d of
Parsed jj pappyDvs5 pappyErr5 ->
case lojbanoperand2 pappyDvs5 of
Parsed o2 pappyDvs7 pappyErr7 ->
Parsed (
\o1 -> ConnectedMex False (jjJboCon Nothing jj) o1 o2 ) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanoperand1 :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanoperand1 d =
case lojbanoperand2 d of
Parsed o pappyDvs1 pappyErr1 ->
case lojbanStarRule25 pappyDvs1 of
Parsed jekss pappyDvs3 pappyErr3 ->
Parsed (
foldl (flip ($)) o jekss) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseoperand2 :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanParseoperand2 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanoperand3 d of
Parsed o1 pappyDvs3 pappyErr3 ->
case lojbanjoikEk pappyDvs3 of
Parsed jj pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed mtag pappyDvs7 pappyErr7 ->
case lojbanBO pappyDvs7 of
Parsed _ pappyDvs9 pappyErr9 ->
case lojbanoperand2 pappyDvs9 of
Parsed o2 pappyDvs11 pappyErr11 ->
Parsed (
ConnectedMex False (jjJboCon mtag jj) o1 o2 ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_2 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbantag pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanoperand3 d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule10 :: LojbanDerivs -> Result LojbanDerivs ([Mex])
lojbanParsePlusRule10 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanmex2 d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule10 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanmex2 d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseoperand3 :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbanParseoperand3 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanquantifier d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanlerfuString d of
Parsed ls pappyDvs3 pappyErr3 ->
case lojbanMOI pappyDvs3 of
NoParse pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
MexLerfuString ls) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanBOI pappyDvs3 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs3 pappyErr9
Parsed _ _ pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanselbri pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
MexSelbri s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_4 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanTEhU pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'n' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"ni'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_4 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbansumti pappyDvs5 of
Parsed s pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
MexSumti s) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_5 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanTEhU pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'm' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"mo'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_5 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanPlusRule10 pappyDvs5 of
Parsed ms pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed _ pappyDvs9 pappyErr9 ->
Parsed (
MexArray ms) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_6 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanTEhU pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_6 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'j' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"jo'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_6 pappyErr1 =
case lojbangek d of
Parsed pcon pappyDvs3 pappyErr3 ->
case lojbanoperand pappyDvs3 of
Parsed o1 pappyDvs5 pappyErr5 ->
case lojbangik pappyDvs5 of
Parsed b pappyDvs7 pappyErr7 ->
case lojbanoperand3 pappyDvs7 of
Parsed o2 pappyDvs9 pappyErr9 ->
Parsed (
ConnectedMex True (pcon b) o1 o2) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_7 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_7 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_7 (max pappyErr3 pappyErr1)
pappyAlt1_7 pappyErr1 =
case lojbanqualifier d of
Parsed qual pappyDvs3 pappyErr3 ->
case lojbanoperand pappyDvs3 of
Parsed o pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
QualifiedMex qual o) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_8 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanLUhU pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_8 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_8 (max pappyErr3 pappyErr1)
pappyAlt1_8 pappyErr1 = NoParse pappyErr1
lojbannumberOrLerfuString :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbannumberOrLerfuString d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbannumber d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanlerfuString d of
Parsed ls pappyDvs3 pappyErr3 ->
Parsed (
MexLerfuString ls) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule26 :: LojbanDerivs -> Result LojbanDerivs ([Numeral])
lojbanParseStarRule26 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbannumeral d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule26 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbannumber :: LojbanDerivs -> Result LojbanDerivs (Mex)
lojbannumber d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed n pappyDvs3 pappyErr3 ->
case lojbannumeral pappyDvs3 of
NoParse pappyErr5 ->
Parsed (
MexInt n) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanPlusRule11 d of
Parsed ds pappyDvs5 pappyErr5 ->
Parsed (
let calc [] = 0
calc (d:ds) = (10*calc ds) + d
in calc (reverse ds)) pappyDvs5 pappyErr5
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
case lojbanPA d of
Parsed p pappyDvs3 pappyErr3 ->
case lojbanStarRule26 pappyDvs3 of
Parsed t pappyDvs5 pappyErr5 ->
Parsed (
MexNumeralString $ (PA p):t ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbannumeral :: LojbanDerivs -> Result LojbanDerivs (Numeral)
lojbannumeral d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanPA d of
Parsed p pappyDvs3 pappyErr3 ->
Parsed (
PA p) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanlerfuWord d of
Parsed l pappyDvs3 pappyErr3 ->
Parsed (
NumeralLerfu l) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule11 :: LojbanDerivs -> Result LojbanDerivs ([Int])
lojbanParsePlusRule11 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbandigit d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule11 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbandigit d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbandigit :: LojbanDerivs -> Result LojbanDerivs (Int)
lojbandigit d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanPA d of
Parsed "no" pappyDvs3 pappyErr3 ->
Parsed (
0) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_2 (max (ParseError (lojbanPos d) [Expected "no"]) pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanPA d of
Parsed "pa" pappyDvs3 pappyErr3 ->
Parsed (
1) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_3 (max (ParseError (lojbanPos d) [Expected "pa"]) pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanPA d of
Parsed "re" pappyDvs3 pappyErr3 ->
Parsed (
2) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_4 (max (ParseError (lojbanPos d) [Expected "re"]) pappyErr1)
pappyAlt1_4 pappyErr1 =
case lojbanPA d of
Parsed "ci" pappyDvs3 pappyErr3 ->
Parsed (
3) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_5 (max (ParseError (lojbanPos d) [Expected "ci"]) pappyErr1)
pappyAlt1_5 pappyErr1 =
case lojbanPA d of
Parsed "vo" pappyDvs3 pappyErr3 ->
Parsed (
4) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_6 (max (ParseError (lojbanPos d) [Expected "vo"]) pappyErr1)
pappyAlt1_6 pappyErr1 =
case lojbanPA d of
Parsed "mu" pappyDvs3 pappyErr3 ->
Parsed (
5) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_7 (max (ParseError (lojbanPos d) [Expected "mu"]) pappyErr1)
pappyAlt1_7 pappyErr1 =
case lojbanPA d of
Parsed "xa" pappyDvs3 pappyErr3 ->
Parsed (
6) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_8 (max (ParseError (lojbanPos d) [Expected "xa"]) pappyErr1)
pappyAlt1_8 pappyErr1 =
case lojbanPA d of
Parsed "ze" pappyDvs3 pappyErr3 ->
Parsed (
7) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_9 (max (ParseError (lojbanPos d) [Expected "ze"]) pappyErr1)
pappyAlt1_9 pappyErr1 =
case lojbanPA d of
Parsed "bi" pappyDvs3 pappyErr3 ->
Parsed (
8) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_10 (max (ParseError (lojbanPos d) [Expected "bi"]) pappyErr1)
pappyAlt1_10 pappyErr1 =
case lojbanPA d of
Parsed "so" pappyDvs3 pappyErr3 ->
Parsed (
9) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_11 (max (ParseError (lojbanPos d) [Expected "so"]) pappyErr1)
pappyAlt1_11 pappyErr1 =
case lojbanChar d of
Parsed c pappyDvs3 pappyErr3 ->
case (isDigit c) of
True ->
Parsed (
digitToInt c) pappyDvs3 (max pappyErr3 pappyErr1)
False -> pappyAlt1_12 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_12 (max pappyErr3 pappyErr1)
pappyAlt1_12 pappyErr1 = NoParse pappyErr1
lojbanxiLit :: LojbanDerivs -> Result LojbanDerivs (Int)
lojbanxiLit d =
case lojbanXI d of
Parsed _ pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed n pappyDvs3 pappyErr3 ->
case lojbannumeral pappyDvs3 of
NoParse pappyErr5 ->
Parsed (n) pappyDvs3 (maximum [pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanPlusRule11 pappyDvs1 of
Parsed ds pappyDvs5 pappyErr5 ->
Parsed (
let calc [] = 0
calc (d:ds) = (10*calc ds) + d
in calc (reverse ds)) pappyDvs5 pappyErr5
NoParse pappyErr5 -> NoParse pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule27 :: LojbanDerivs -> Result LojbanDerivs ([Lerfu])
lojbanParseStarRule27 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule27 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanlerfuWord d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbandigit d of
Parsed d pappyDvs7 pappyErr7 ->
Parsed (
LerfuChar $ head $ show d) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_3 (max pappyErr7 pappyErr5)
pappyAlt5_3 pappyErr5 =
case lojbanPA d of
Parsed p pappyDvs7 pappyErr7 ->
Parsed (
LerfuPA p) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_4 (max pappyErr7 pappyErr5)
pappyAlt5_4 pappyErr5 = NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanlerfuString :: LojbanDerivs -> Result LojbanDerivs ([Lerfu])
lojbanlerfuString d =
case lojbanlerfuWord d of
Parsed c pappyDvs1 pappyErr1 ->
case lojbanStarRule27 pappyDvs1 of
Parsed cs pappyDvs3 pappyErr3 ->
Parsed (
c:cs) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParselerfuWord :: LojbanDerivs -> Result LojbanDerivs (Lerfu)
lojbanParselerfuWord d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
case s of
"y'y" -> LerfuChar 'h'
s:"y" -> LerfuChar s
_ -> LerfuShift s) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'j' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"jo'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"je'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'y' pappyDvs7 _ ->
Parsed (
"jy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'r' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"ru'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'y' pappyDvs7 _ ->
Parsed (
"ry") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'g' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"ge'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"ga'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'y' pappyDvs7 _ ->
Parsed (
"gy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'l' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"lo'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'y' pappyDvs7 _ ->
Parsed (
"ly") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'n' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"na'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'y' pappyDvs7 _ ->
Parsed (
"ny") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 's' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'e' pappyDvs11 _ ->
Parsed (
"se'e") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'y' pappyDvs7 _ ->
Parsed (
"sy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 't' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'o' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"to'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'y' pappyDvs7 _ ->
Parsed (
"ty") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'y' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'y' pappyDvs9 _ ->
Parsed (
"y'y") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'b' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"by") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'c' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"cy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'd' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"dy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'f' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"fy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'k' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"ky") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'm' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"my") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'p' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"py") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'v' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"vy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'x' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"xy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'z' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'y' pappyDvs7 _ ->
Parsed (
"zy") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_2 pappyErr1 =
case lojbanVowel d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule13 pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanBU pappyDvs5 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
LerfuChar v ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanValsi d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanBU pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
LerfuValsi v ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 =
case pappyResult3 of
Parsed lau pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanlerfuWord pappyDvs5 of
Parsed l pappyDvs7 pappyErr7 ->
Parsed (
LerfuShifted lau l ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_5 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_5 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 'c' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'a' pappyDvs11 _ ->
Parsed (
"ce'a") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'l' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"lau") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'z' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"zai") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 't' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"tau") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_5 pappyErr1 =
case pappyResult3 of
Parsed s pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case lojbanlerfuString pappyDvs5 of
Parsed ls pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed s pappyDvs9 pappyErr9 ->
case lojbanpostClause pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
LerfuComposite ls ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr11 -> pappyAlt1_6 (maximum [pappyErr11,pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_6 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanChar pappyDvs7 of
Parsed 'f' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'o' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
Parsed (
"foi") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
NoParse pappyErr7 -> pappyAlt1_6 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_6 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_6 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar d of
Parsed 't' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"tei") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos d) [])
pappyAlt1_6 pappyErr1 = NoParse pappyErr1
lojbanParseek :: LojbanDerivs -> Result LojbanDerivs (LogJboConnective)
lojbanParseek d =
case pappyResult1 of
Parsed ln pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed se pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed conchar pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed rn pappyDvs7 pappyErr7 ->
Parsed (
LogJboConnective (ln /= Just "na")
(if (isJust se) && conchar=='u' then 'U' else conchar)
(isNothing rn) ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanNAI pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case lojbanA pappyDvs3 of
Parsed "a" pappyDvs9 pappyErr9 ->
Parsed (
'a') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_2 (max (ParseError (lojbanPos pappyDvs3) [Expected "a"]) pappyErr7)
pappyAlt7_2 pappyErr7 =
case lojbanA pappyDvs3 of
Parsed "e" pappyDvs9 pappyErr9 ->
Parsed (
'e') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_3 (max (ParseError (lojbanPos pappyDvs3) [Expected "e"]) pappyErr7)
pappyAlt7_3 pappyErr7 =
case lojbanA pappyDvs3 of
Parsed "o" pappyDvs9 pappyErr9 ->
Parsed (
'o') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_4 (max (ParseError (lojbanPos pappyDvs3) [Expected "o"]) pappyErr7)
pappyAlt7_4 pappyErr7 =
case lojbanA pappyDvs3 of
Parsed "u" pappyDvs9 pappyErr9 ->
Parsed (
'u') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_5 (max (ParseError (lojbanPos pappyDvs3) [Expected "u"]) pappyErr7)
pappyAlt7_5 pappyErr7 =
case lojbanA pappyDvs3 of
Parsed "ji" pappyDvs9 pappyErr9 ->
Parsed (
'i') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_6 (max (ParseError (lojbanPos pappyDvs3) [Expected "ji"]) pappyErr7)
pappyAlt7_6 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanSE pappyDvs1 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanNA d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3
lojbanParsegihek :: LojbanDerivs -> Result LojbanDerivs (LogJboConnective)
lojbanParsegihek d =
case pappyResult1 of
Parsed ln pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed se pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed conchar pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed rn pappyDvs7 pappyErr7 ->
Parsed (
LogJboConnective (ln /= Just "na")
(if (isJust se) && conchar=='u' then 'U' else conchar)
(isNothing rn) ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanNAI pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case lojbanGIhA pappyDvs3 of
Parsed "gi'a" pappyDvs9 pappyErr9 ->
Parsed (
'a') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_2 (max (ParseError (lojbanPos pappyDvs3) [Expected "gi'a"]) pappyErr7)
pappyAlt7_2 pappyErr7 =
case lojbanGIhA pappyDvs3 of
Parsed "gi'e" pappyDvs9 pappyErr9 ->
Parsed (
'e') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_3 (max (ParseError (lojbanPos pappyDvs3) [Expected "gi'e"]) pappyErr7)
pappyAlt7_3 pappyErr7 =
case lojbanGIhA pappyDvs3 of
Parsed "gi'o" pappyDvs9 pappyErr9 ->
Parsed (
'o') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_4 (max (ParseError (lojbanPos pappyDvs3) [Expected "gi'o"]) pappyErr7)
pappyAlt7_4 pappyErr7 =
case lojbanGIhA pappyDvs3 of
Parsed "gi'u" pappyDvs9 pappyErr9 ->
Parsed (
'u') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_5 (max (ParseError (lojbanPos pappyDvs3) [Expected "gi'u"]) pappyErr7)
pappyAlt7_5 pappyErr7 =
case lojbanGIhA pappyDvs3 of
Parsed "gi'i" pappyDvs9 pappyErr9 ->
Parsed (
'i') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_6 (max (ParseError (lojbanPos pappyDvs3) [Expected "gi'i"]) pappyErr7)
pappyAlt7_6 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanSE pappyDvs1 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanNA d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3
lojbanParsejek :: LojbanDerivs -> Result LojbanDerivs (LogJboConnective)
lojbanParsejek d =
case pappyResult1 of
Parsed ln pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed se pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed conchar pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed rn pappyDvs7 pappyErr7 ->
Parsed (
LogJboConnective (ln /= Just "na")
(if (isJust se) && conchar=='u' then 'U' else conchar)
(isNothing rn) ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanNAI pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case lojbanJA pappyDvs3 of
Parsed "ja" pappyDvs9 pappyErr9 ->
Parsed (
'a') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_2 (max (ParseError (lojbanPos pappyDvs3) [Expected "ja"]) pappyErr7)
pappyAlt7_2 pappyErr7 =
case lojbanJA pappyDvs3 of
Parsed "je" pappyDvs9 pappyErr9 ->
Parsed (
'e') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_3 (max (ParseError (lojbanPos pappyDvs3) [Expected "je"]) pappyErr7)
pappyAlt7_3 pappyErr7 =
case lojbanJA pappyDvs3 of
Parsed "jo" pappyDvs9 pappyErr9 ->
Parsed (
'o') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_4 (max (ParseError (lojbanPos pappyDvs3) [Expected "jo"]) pappyErr7)
pappyAlt7_4 pappyErr7 =
case lojbanJA pappyDvs3 of
Parsed "ju" pappyDvs9 pappyErr9 ->
Parsed (
'u') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_5 (max (ParseError (lojbanPos pappyDvs3) [Expected "ju"]) pappyErr7)
pappyAlt7_5 pappyErr7 =
case lojbanJA pappyDvs3 of
Parsed "je'i" pappyDvs9 pappyErr9 ->
Parsed (
'i') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_6 (max (ParseError (lojbanPos pappyDvs3) [Expected "je'i"]) pappyErr7)
pappyAlt7_6 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanSE pappyDvs1 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanNA d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3
lojbanParsejoik :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanParsejoik d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed se pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed joi pappyDvs5 pappyErr5 ->
case lojbanpostClause pappyDvs5 of
Parsed _ pappyDvs7 pappyErr7 ->
case pappyResult9 of
Parsed nai pappyDvs9 pappyErr9 ->
Parsed (
(fromMaybe "" se) ++ joi ++ (fromMaybe "" nai) ) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult9 =
case lojbanNAI pappyDvs7 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs7 pappyErr11
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanChar pappyDvs3 of
Parsed 'f' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
Parsed (
"fa'u") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'p' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
Parsed (
"pi'u") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'j' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"joi") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
Parsed (
"jo'u") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
Parsed 'e' pappyDvs13 _ ->
Parsed (
"jo'e") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'e' pappyDvs13 _ ->
Parsed (
"ju'e") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'c' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'o' pappyDvs13 _ ->
Parsed (
"ce'o") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ ->
Parsed (
"ce") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'k' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed '\'' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
Parsed (
"ku'a") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanSE d of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
pappyAlt1_2 pappyErr1 =
case lojbaninterval d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanGAhO d of
Parsed g1 pappyDvs3 pappyErr3 ->
case lojbaninterval pappyDvs3 of
Parsed i pappyDvs5 pappyErr5 ->
case lojbanGAhO pappyDvs5 of
Parsed g2 pappyDvs7 pappyErr7 ->
Parsed (
g1 ++ i ++ g2 ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_4 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParseinterval :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanParseinterval d =
case pappyResult1 of
Parsed se pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed bihi pappyDvs3 pappyErr3 ->
case lojbanpostClause pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed nai pappyDvs7 pappyErr7 ->
Parsed (
(fromMaybe "" se) ++ bihi ++ (fromMaybe "" nai) ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanNAI pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanChar pappyDvs1 of
Parsed 'm' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'i' pappyDvs11 _ ->
Parsed (
"mi'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'b' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed '\'' pappyDvs9 _ ->
case lojbanChar pappyDvs9 of
Parsed 'o' pappyDvs11 _ ->
Parsed (
"bi'o") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
Parsed 'i' pappyDvs11 _ ->
Parsed (
"bi'i") pappyDvs11 (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs1) [])
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanSE d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3
lojbanjoikEk :: LojbanDerivs -> Result LojbanDerivs (JekJoik)
lojbanjoikEk d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanek d of
Parsed jj pappyDvs3 pappyErr3 ->
Parsed (
JJJek jj ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanjoik d of
Parsed jj pappyDvs3 pappyErr3 ->
Parsed (
JJJoik jj ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanjoikJek :: LojbanDerivs -> Result LojbanDerivs (JekJoik)
lojbanjoikJek d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanjek d of
Parsed jj pappyDvs3 pappyErr3 ->
Parsed (
JJJek jj ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanjoik d of
Parsed jj pappyDvs3 pappyErr3 ->
Parsed (
JJJoik jj ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsegek :: LojbanDerivs -> Result LojbanDerivs (Bool -> Connective)
lojbanParsegek d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed se pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed conchar pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed ln pappyDvs7 pappyErr7 ->
Parsed (
jboConnLogOrQ Nothing . LogJboConnective (isNothing ln)
(if (isJust se) && conchar=='u' then 'U' else conchar) ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanNAI pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case lojbanGA pappyDvs3 of
Parsed "ga" pappyDvs9 pappyErr9 ->
Parsed (
'a') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_2 (max (ParseError (lojbanPos pappyDvs3) [Expected "ga"]) pappyErr7)
pappyAlt7_2 pappyErr7 =
case lojbanGA pappyDvs3 of
Parsed "ge" pappyDvs9 pappyErr9 ->
Parsed (
'e') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_3 (max (ParseError (lojbanPos pappyDvs3) [Expected "ge"]) pappyErr7)
pappyAlt7_3 pappyErr7 =
case lojbanGA pappyDvs3 of
Parsed "go" pappyDvs9 pappyErr9 ->
Parsed (
'o') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_4 (max (ParseError (lojbanPos pappyDvs3) [Expected "go"]) pappyErr7)
pappyAlt7_4 pappyErr7 =
case lojbanGA pappyDvs3 of
Parsed "gu" pappyDvs9 pappyErr9 ->
Parsed (
'u') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_5 (max (ParseError (lojbanPos pappyDvs3) [Expected "gu"]) pappyErr7)
pappyAlt7_5 pappyErr7 =
case lojbanGA pappyDvs3 of
Parsed "ge'i" pappyDvs9 pappyErr9 ->
Parsed (
'i') pappyDvs9 (max pappyErr9 pappyErr7)
_ -> pappyAlt7_6 (max (ParseError (lojbanPos pappyDvs3) [Expected "ge'i"]) pappyErr7)
pappyAlt7_6 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanSE d of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) d pappyErr5
pappyAlt1_2 pappyErr1 =
case lojbanjoik d of
Parsed joik pappyDvs3 pappyErr3 ->
case lojbanGI pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
\_ -> JboConnJoik Nothing joik ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbantag d of
Parsed tag pappyDvs3 pappyErr3 ->
case lojbangik pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
\_ -> jboConnLogOrQ (Just tag) (LogJboConnective True 'e' True) ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_4 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanParseguhek :: LojbanDerivs -> Result LojbanDerivs (Bool -> LogJboConnective)
lojbanParseguhek d =
case pappyResult1 of
Parsed se pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed conchar pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed ln pappyDvs5 pappyErr5 ->
Parsed (
LogJboConnective (isNothing ln)
(if (isJust se) && conchar=='u' then 'U' else conchar) ) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanNAI pappyDvs3 of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed (Just pappyVal7) pappyDvs7 pappyErr7
NoParse pappyErr7 -> Parsed (Nothing) pappyDvs3 pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos pappyDvs1) []) where
pappyAlt5_1 pappyErr5 =
case lojbanGUhA pappyDvs1 of
Parsed "gu'a" pappyDvs7 pappyErr7 ->
Parsed (
'a') pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_2 (max (ParseError (lojbanPos pappyDvs1) [Expected "gu'a"]) pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanGUhA pappyDvs1 of
Parsed "gu'e" pappyDvs7 pappyErr7 ->
Parsed (
'e') pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_3 (max (ParseError (lojbanPos pappyDvs1) [Expected "gu'e"]) pappyErr5)
pappyAlt5_3 pappyErr5 =
case lojbanGUhA pappyDvs1 of
Parsed "gu'o" pappyDvs7 pappyErr7 ->
Parsed (
'o') pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_4 (max (ParseError (lojbanPos pappyDvs1) [Expected "gu'o"]) pappyErr5)
pappyAlt5_4 pappyErr5 =
case lojbanGUhA pappyDvs1 of
Parsed "gu'u" pappyDvs7 pappyErr7 ->
Parsed (
'u') pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_5 (max (ParseError (lojbanPos pappyDvs1) [Expected "gu'u"]) pappyErr5)
pappyAlt5_5 pappyErr5 =
case lojbanGUhA pappyDvs1 of
Parsed "gu'i" pappyDvs7 pappyErr7 ->
Parsed (
'i') pappyDvs7 (max pappyErr7 pappyErr5)
_ -> pappyAlt5_6 (max (ParseError (lojbanPos pappyDvs1) [Expected "gu'i"]) pappyErr5)
pappyAlt5_6 pappyErr5 = NoParse pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanSE d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3
lojbangik :: LojbanDerivs -> Result LojbanDerivs (Bool)
lojbangik d =
case lojbanGI d of
Parsed _ pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed rn pappyDvs3 pappyErr3 ->
Parsed (
isNothing rn ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanNAI pappyDvs1 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
lojbantagFA :: LojbanDerivs -> Result LojbanDerivs (Int)
lojbantagFA d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanFA d of
Parsed _ pappyDvs3 pappyErr3 ->
case lojbanxiLit pappyDvs3 of
Parsed n pappyDvs5 pappyErr5 ->
Parsed (n) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanFA d of
Parsed "fa" pappyDvs3 pappyErr3 ->
Parsed (
1) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_3 (max (ParseError (lojbanPos d) [Expected "fa"]) pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanFA d of
Parsed "fe" pappyDvs3 pappyErr3 ->
Parsed (
2) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_4 (max (ParseError (lojbanPos d) [Expected "fe"]) pappyErr1)
pappyAlt1_4 pappyErr1 =
case lojbanFA d of
Parsed "fi" pappyDvs3 pappyErr3 ->
Parsed (
3) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_5 (max (ParseError (lojbanPos d) [Expected "fi"]) pappyErr1)
pappyAlt1_5 pappyErr1 =
case lojbanFA d of
Parsed "fo" pappyDvs3 pappyErr3 ->
Parsed (
4) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_6 (max (ParseError (lojbanPos d) [Expected "fo"]) pappyErr1)
pappyAlt1_6 pappyErr1 =
case lojbanFA d of
Parsed "fu" pappyDvs3 pappyErr3 ->
Parsed (
5) pappyDvs3 (max pappyErr3 pappyErr1)
_ -> pappyAlt1_7 (max (ParseError (lojbanPos d) [Expected "fu"]) pappyErr1)
pappyAlt1_7 pappyErr1 = NoParse pappyErr1
lojbanParseStarRule28 :: LojbanDerivs -> Result LojbanDerivs ([(Connective, Tag)])
lojbanParseStarRule28 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule28 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanjoikJek d of
Parsed jj pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed tag pappyDvs7 pappyErr7 ->
Parsed (
(jjJboCon Nothing jj,tag)) pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> NoParse (max pappyErr7 pappyErr5)
where
pappyResult7 =
case lojbanPlusRule12 pappyDvs5 of
Parsed dtus pappyDvs9 pappyErr9 ->
Parsed (
DecoratedTagUnits dtus) pappyDvs9 pappyErr9
NoParse pappyErr9 -> NoParse pappyErr9
NoParse pappyErr5 -> NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbantag :: LojbanDerivs -> Result LojbanDerivs (Tag)
lojbantag d =
case pappyResult1 of
Parsed tag pappyDvs1 pappyErr1 ->
case lojbanStarRule28 pappyDvs1 of
Parsed jekts pappyDvs3 pappyErr3 ->
Parsed (
foldl (\t1 -> \(con,t2) -> ConnectedTag con t1 t2) tag jekts ) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanPlusRule12 d of
Parsed dtus pappyDvs3 pappyErr3 ->
Parsed (
DecoratedTagUnits dtus) pappyDvs3 pappyErr3
NoParse pappyErr3 -> NoParse pappyErr3
lojbanParsePlusRule12 :: LojbanDerivs -> Result LojbanDerivs ([DecoratedTagUnit])
lojbanParsePlusRule12 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbandecoratedTagUnit d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule12 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbandecoratedTagUnit d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsedecoratedTagUnit :: LojbanDerivs -> Result LojbanDerivs (DecoratedTagUnit)
lojbanParsedecoratedTagUnit d =
case pappyResult1 of
Parsed nahe pappyDvs1 pappyErr1 ->
case pappyResult3 of
Parsed se pappyDvs3 pappyErr3 ->
case pappyResult5 of
Parsed tu pappyDvs5 pappyErr5 ->
case pappyResult7 of
Parsed nai pappyDvs7 pappyErr7 ->
Parsed (
DecoratedTagUnit nahe se (isJust nai) tu ) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> NoParse (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
where
pappyResult7 =
case lojbanNAI pappyDvs5 of
Parsed pappyVal9 pappyDvs9 pappyErr9 -> Parsed (Just pappyVal9) pappyDvs9 pappyErr9
NoParse pappyErr9 -> Parsed (Nothing) pappyDvs5 pappyErr9
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
pappyAlt7_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt7_1 pappyErr7 =
case pappyResult9 of
Parsed s pappyDvs9 pappyErr9 ->
Parsed (
TenseCmavo s) pappyDvs9 (max pappyErr9 pappyErr7)
NoParse pappyErr9 -> pappyAlt7_2 (max pappyErr9 pappyErr7)
where
pappyResult9 =
pappyAlt11_1 (ParseError (lojbanPos pappyDvs3) []) where
pappyAlt11_1 pappyErr11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr15 -> pappyAlt11_2 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr13 -> pappyAlt11_2 (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanChar pappyDvs3 of
Parsed 'b' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"ba") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'p' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"pu") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'c' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"ca") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt11_2 pappyErr11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr15 -> pappyAlt11_3 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr13 -> pappyAlt11_3 (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanChar pappyDvs3 of
Parsed 'z' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"zu") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'a' pappyDvs17 _ ->
Parsed (
"za") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'i' pappyDvs17 _ ->
Parsed (
"zi") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt11_3 pappyErr11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr15 -> pappyAlt11_4 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr13 -> pappyAlt11_4 (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanChar pappyDvs3 of
Parsed 'z' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'u' pappyDvs21 _ ->
Parsed (
"ze'u") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'a' pappyDvs21 _ ->
Parsed (
"ze'a") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'i' pappyDvs21 _ ->
Parsed (
"ze'i") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'e' pappyDvs21 _ ->
Parsed (
"ze'e") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt11_4 pappyErr11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr15 -> pappyAlt11_5 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr13 -> pappyAlt11_5 (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanChar pappyDvs3 of
Parsed 'v' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"vi") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'a' pappyDvs17 _ ->
Parsed (
"va") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'u' pappyDvs17 _ ->
Parsed (
"vu") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt11_5 pappyErr11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr15 -> pappyAlt11_6 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr13 -> pappyAlt11_6 (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanChar pappyDvs3 of
Parsed 'v' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'u' pappyDvs21 _ ->
Parsed (
"ve'u") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'a' pappyDvs21 _ ->
Parsed (
"ve'a") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'i' pappyDvs21 _ ->
Parsed (
"ve'i") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'e' pappyDvs21 _ ->
Parsed (
"ve'e") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt11_6 pappyErr11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr15 -> pappyAlt11_7 (maximum [pappyErr15,pappyErr13,pappyErr11])
NoParse pappyErr13 -> pappyAlt11_7 (max pappyErr13 pappyErr11)
where
pappyResult13 =
case lojbanChar pappyDvs3 of
Parsed 'v' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'i' pappyDvs21 _ ->
Parsed (
"vi'i") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'a' pappyDvs21 _ ->
Parsed (
"vi'a") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'u' pappyDvs21 _ ->
Parsed (
"vi'u") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
Parsed 'e' pappyDvs21 _ ->
Parsed (
"vi'e") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt11_7 pappyErr11 = NoParse pappyErr11
pappyAlt7_2 pappyErr7 =
case pappyResult9 of
Parsed s pappyDvs9 pappyErr9 ->
case lojbanpostClause pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
CAhA s) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_3 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_3 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanChar pappyDvs3 of
Parsed 'c' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"ca'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'p' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"pu'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'n' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'o' pappyDvs17 _ ->
Parsed (
"nu'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'k' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"ka'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt7_3 pappyErr7 =
case pappyResult9 of
Parsed s pappyDvs9 pappyErr9 ->
case lojbanpostClause pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
BAI s) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_4 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_4 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanChar pappyDvs3 of
Parsed 'd' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'o' pappyDvs17 _ ->
Parsed (
"du'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'i' pappyDvs17 _ ->
Parsed (
"du'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'o' pappyDvs17 _ ->
Parsed (
"di'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'e' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"de'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'o' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"do'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 's' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"si'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
Parsed (
"sau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'z' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
Parsed (
"zau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"zu'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'k' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ki'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'u' pappyDvs17 _ ->
Parsed (
"ki'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'o' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
Parsed (
"koi") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
Parsed (
"kai") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"ka'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ka'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"ku'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'c' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"cu'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ca'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'u' pappyDvs15 _ ->
Parsed (
"cau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'o' pappyDvs17 _ ->
Parsed (
"ci'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'e' pappyDvs17 _ ->
Parsed (
"ci'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'u' pappyDvs17 _ ->
Parsed (
"ci'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 't' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"tu'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"ti'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ti'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ta'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'i' pappyDvs15 _ ->
Parsed (
"tai") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'j' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"ji'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'o' pappyDvs17 _ ->
Parsed (
"ji'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'e' pappyDvs17 _ ->
Parsed (
"ji'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ja'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'e' pappyDvs17 _ ->
Parsed (
"ja'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'r' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"ri'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ri'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ra'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'a' pappyDvs17 _ ->
Parsed (
"ra'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'i' pappyDvs15 _ ->
Parsed (
"rai") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'n' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ni'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'm' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"mu'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'u' pappyDvs17 _ ->
Parsed (
"mu'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
Parsed (
"mau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ma'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'e' pappyDvs17 _ ->
Parsed (
"ma'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'e' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"me'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'e' pappyDvs17 _ ->
Parsed (
"me'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'v' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"va'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'o' pappyDvs17 _ ->
Parsed (
"va'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'p' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"pu'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'a' pappyDvs17 _ ->
Parsed (
"pu'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"pa'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
Parsed 'a' pappyDvs17 _ ->
Parsed (
"pa'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'o' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"po'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'o' pappyDvs17 _ ->
Parsed (
"pi'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'b' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
Parsed (
"bai") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
Parsed 'u' pappyDvs15 _ ->
Parsed (
"bau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"ba'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'e' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'i' pappyDvs17 _ ->
Parsed (
"be'i") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'f' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"fi'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
Parsed (
"fau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"fa'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'l' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'e' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"le'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"li'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'u' pappyDvs17 _ ->
Parsed (
"la'u") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'g' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'a' pappyDvs17 _ ->
Parsed (
"ga'a") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'u' pappyDvs15 _ ->
Parsed (
"gau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt7_4 pappyErr7 =
case pappyResult9 of
Parsed m pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed f pappyDvs11 pappyErr11 ->
case lojbanpostClause pappyDvs11 of
Parsed _ pappyDvs13 pappyErr13 ->
Parsed (
FAhA (isJust m) f ) pappyDvs13 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr13 -> pappyAlt7_5 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_5 (maximum [pappyErr11,pappyErr9,pappyErr7])
where
pappyResult11 =
case lojbanChar pappyDvs9 of
Parsed 'd' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
Parsed (
"du'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'b' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'e' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
Parsed (
"be'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'u' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
Parsed (
"bu'u") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'n' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'e' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
Parsed (
"ne'u") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
Parsed 'a' pappyDvs19 _ ->
Parsed (
"ne'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
Parsed 'i' pappyDvs19 _ ->
Parsed (
"ne'i") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'i' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
Parsed (
"ni'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'v' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
Parsed (
"vu'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'g' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'a' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
Parsed (
"ga'u") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 't' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
Parsed (
"ti'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'e' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'e' pappyDvs19 _ ->
Parsed (
"te'e") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'o' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
Parsed (
"to'o") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'c' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'a' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
Parsed (
"ca'u") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'z' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
Parsed (
"zu'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'o' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'i' pappyDvs19 _ ->
Parsed (
"zo'i") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
Parsed 'a' pappyDvs19 _ ->
Parsed (
"zo'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'e' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
Parsed (
"ze'o") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'r' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'i' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
Parsed (
"ri'u") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'u' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
Parsed (
"ru'u") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
Parsed 'e' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
Parsed (
"re'o") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'p' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'a' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
Parsed (
"pa'o") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
Parsed 'f' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'a' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed '\'' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
Parsed (
"fa'a") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
NoParse pappyErr9 -> pappyAlt7_5 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case pappyResult11 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs3 pappyErr11
where
pappyResult11 =
case pappyResult13 of
Parsed s pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (s) pappyDvs15 (max pappyErr15 pappyErr13)
NoParse pappyErr15 -> NoParse (max pappyErr15 pappyErr13)
NoParse pappyErr13 -> NoParse pappyErr13
where
pappyResult13 =
case lojbanChar pappyDvs3 of
Parsed 'm' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'o' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'i' pappyDvs21 _ ->
Parsed (
"mo'i") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt7_5 pappyErr7 =
case pappyResult9 of
Parsed f pappyDvs9 pappyErr9 ->
case lojbannumber pappyDvs9 of
Parsed q pappyDvs11 pappyErr11 ->
case pappyResult13 of
Parsed r pappyDvs13 pappyErr13 ->
case lojbanpostClause pappyDvs13 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (
ROI r (isJust f) q ) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr15 -> pappyAlt7_6 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr13 -> pappyAlt7_6 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
where
pappyResult13 =
case lojbanChar pappyDvs11 of
Parsed 'r' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed '\'' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed 'u' pappyDvs21 _ ->
Parsed (
"re'u") pappyDvs21 (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'o' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'i' pappyDvs19 _ ->
Parsed (
"roi") pappyDvs19 (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
NoParse pappyErr11 -> pappyAlt7_6 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_6 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanFEhE pappyDvs3 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs3 pappyErr11
pappyAlt7_6 pappyErr7 =
case pappyResult9 of
Parsed f pappyDvs9 pappyErr9 ->
case pappyResult11 of
Parsed s pappyDvs11 pappyErr11 ->
Parsed (
TAhE_ZAhO (isJust f) s ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_7 (maximum [pappyErr11,pappyErr9,pappyErr7])
where
pappyResult11 =
pappyAlt13_1 (ParseError (lojbanPos pappyDvs9) []) where
pappyAlt13_1 pappyErr13 =
case pappyResult15 of
Parsed s pappyDvs15 pappyErr15 ->
case lojbanpostClause pappyDvs15 of
Parsed _ pappyDvs17 pappyErr17 ->
Parsed (s) pappyDvs17 (maximum [pappyErr17,pappyErr15,pappyErr13])
NoParse pappyErr17 -> pappyAlt13_2 (maximum [pappyErr17,pappyErr15,pappyErr13])
NoParse pappyErr15 -> pappyAlt13_2 (max pappyErr15 pappyErr13)
where
pappyResult15 =
case lojbanChar pappyDvs9 of
Parsed 'r' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'i' pappyDvs23 _ ->
Parsed (
"ru'i") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 't' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'e' pappyDvs23 _ ->
Parsed (
"ta'e") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'd' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'i' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'i' pappyDvs23 _ ->
Parsed (
"di'i") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'n' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'o' pappyDvs23 _ ->
Parsed (
"na'o") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
pappyAlt13_2 pappyErr13 =
case pappyResult15 of
Parsed s pappyDvs15 pappyErr15 ->
case lojbanpostClause pappyDvs15 of
Parsed _ pappyDvs17 pappyErr17 ->
Parsed (s) pappyDvs17 (maximum [pappyErr17,pappyErr15,pappyErr13])
NoParse pappyErr17 -> pappyAlt13_3 (maximum [pappyErr17,pappyErr15,pappyErr13])
NoParse pappyErr15 -> pappyAlt13_3 (max pappyErr15 pappyErr13)
where
pappyResult15 =
case lojbanChar pappyDvs9 of
Parsed 'c' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'i' pappyDvs23 _ ->
Parsed (
"co'i") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
Parsed 'u' pappyDvs23 _ ->
Parsed (
"co'u") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
Parsed 'a' pappyDvs23 _ ->
Parsed (
"co'a") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
Parsed 'a' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'o' pappyDvs23 _ ->
Parsed (
"ca'o") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'p' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'u' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'o' pappyDvs23 _ ->
Parsed (
"pu'o") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'm' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'o' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'u' pappyDvs23 _ ->
Parsed (
"mo'u") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'd' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'e' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'a' pappyDvs23 _ ->
Parsed (
"de'a") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
Parsed 'i' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'a' pappyDvs23 _ ->
Parsed (
"di'a") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'b' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'o' pappyDvs23 _ ->
Parsed (
"ba'o") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
Parsed 'z' pappyDvs17 _ ->
case lojbanChar pappyDvs17 of
Parsed 'a' pappyDvs19 _ ->
case lojbanChar pappyDvs19 of
Parsed '\'' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'o' pappyDvs23 _ ->
Parsed (
"za'o") pappyDvs23 (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs19) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs9) [])
pappyAlt13_3 pappyErr13 = NoParse pappyErr13
NoParse pappyErr9 -> pappyAlt7_7 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanFEhE pappyDvs3 of
Parsed pappyVal11 pappyDvs11 pappyErr11 -> Parsed (Just pappyVal11) pappyDvs11 pappyErr11
NoParse pappyErr11 -> Parsed (Nothing) pappyDvs3 pappyErr11
pappyAlt7_7 pappyErr7 =
case pappyResult9 of
Parsed s pappyDvs9 pappyErr9 ->
case lojbanpostClause pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
case lojbanselbri pappyDvs11 of
Parsed s pappyDvs13 pappyErr13 ->
case pappyResult15 of
Parsed _ pappyDvs15 pappyErr15 ->
Parsed (
FIhO s ) pappyDvs15 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr15 -> pappyAlt7_8 (maximum [pappyErr15,pappyErr13,pappyErr11,pappyErr9,pappyErr7])
where
pappyResult15 =
case pappyResult17 of
Parsed pappyVal17 pappyDvs17 pappyErr17 -> Parsed (Just pappyVal17) pappyDvs17 pappyErr17
NoParse pappyErr17 -> Parsed (Nothing) pappyDvs13 pappyErr17
where
pappyResult17 =
case pappyResult19 of
Parsed s pappyDvs19 pappyErr19 ->
case lojbanpostClause pappyDvs19 of
Parsed _ pappyDvs21 pappyErr21 ->
Parsed (s) pappyDvs21 (max pappyErr21 pappyErr19)
NoParse pappyErr21 -> NoParse (max pappyErr21 pappyErr19)
NoParse pappyErr19 -> NoParse pappyErr19
where
pappyResult19 =
case lojbanChar pappyDvs13 of
Parsed 'f' pappyDvs21 _ ->
case lojbanChar pappyDvs21 of
Parsed 'e' pappyDvs23 _ ->
case lojbanChar pappyDvs23 of
Parsed '\'' pappyDvs25 _ ->
case lojbanChar pappyDvs25 of
Parsed 'u' pappyDvs27 _ ->
Parsed (
"fe'u") pappyDvs27 (ParseError (lojbanPos pappyDvs27) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs25) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs23) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs21) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
NoParse pappyErr13 -> pappyAlt7_8 (maximum [pappyErr13,pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_8 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_8 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanChar pappyDvs3 of
Parsed 'f' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'o' pappyDvs17 _ ->
Parsed (
"fi'o") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt7_8 pappyErr7 =
case pappyResult9 of
Parsed s pappyDvs9 pappyErr9 ->
case lojbanpostClause pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
CUhE ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_9 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_9 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanChar pappyDvs3 of
Parsed 'c' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'u' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed '\'' pappyDvs15 _ ->
case lojbanChar pappyDvs15 of
Parsed 'e' pappyDvs17 _ ->
Parsed (
"cu'e") pappyDvs17 (ParseError (lojbanPos pappyDvs17) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
Parsed 'n' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'a' pappyDvs13 _ ->
case lojbanChar pappyDvs13 of
Parsed 'u' pappyDvs15 _ ->
Parsed (
"nau") pappyDvs15 (ParseError (lojbanPos pappyDvs15) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt7_9 pappyErr7 =
case pappyResult9 of
Parsed s pappyDvs9 pappyErr9 ->
case lojbanpostClause pappyDvs9 of
Parsed _ pappyDvs11 pappyErr11 ->
Parsed (
KI ) pappyDvs11 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr11 -> pappyAlt7_10 (maximum [pappyErr11,pappyErr9,pappyErr7])
NoParse pappyErr9 -> pappyAlt7_10 (max pappyErr9 pappyErr7)
where
pappyResult9 =
case lojbanChar pappyDvs3 of
Parsed 'k' pappyDvs11 _ ->
case lojbanChar pappyDvs11 of
Parsed 'i' pappyDvs13 _ ->
Parsed (
"ki") pappyDvs13 (ParseError (lojbanPos pappyDvs13) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs11) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
pappyAlt7_10 pappyErr7 = NoParse pappyErr7
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
where
pappyResult3 =
case lojbanconvSE pappyDvs1 of
Parsed pappyVal5 pappyDvs5 pappyErr5 -> Parsed (Just pappyVal5) pappyDvs5 pappyErr5
NoParse pappyErr5 -> Parsed (Nothing) pappyDvs1 pappyErr5
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanNAhE d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed (Just pappyVal3) pappyDvs3 pappyErr3
NoParse pappyErr3 -> Parsed (Nothing) d pappyErr3
lojbanLojbanLetter :: LojbanDerivs -> Result LojbanDerivs (Char)
lojbanLojbanLetter d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanConsonant d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanVowel d of
Parsed pappyVal3 pappyDvs3 pappyErr3 -> Parsed pappyVal3 pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 =
case lojbanChar d of
Parsed c pappyDvs3 pappyErr3 ->
case (c `elem` "',") of
True ->
Parsed (c) pappyDvs3 (max pappyErr3 pappyErr1)
False -> pappyAlt1_4 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_4 (max pappyErr3 pappyErr1)
pappyAlt1_4 pappyErr1 = NoParse pappyErr1
lojbanVowel :: LojbanDerivs -> Result LojbanDerivs (Char)
lojbanVowel d =
case lojbanChar d of
Parsed c pappyDvs1 pappyErr1 ->
case (c `elem` "aeiouy") of
True ->
Parsed (c) pappyDvs1 pappyErr1
False -> NoParse pappyErr1
NoParse pappyErr1 -> NoParse pappyErr1
lojbanConsonant :: LojbanDerivs -> Result LojbanDerivs (Char)
lojbanConsonant d =
case lojbanChar d of
Parsed c pappyDvs1 pappyErr1 ->
case (c `elem` "bcdfgjklmnprstvxz") of
True ->
Parsed (c) pappyDvs1 pappyErr1
False -> NoParse pappyErr1
NoParse pappyErr1 -> NoParse pappyErr1
lojbanSpace :: LojbanDerivs -> Result LojbanDerivs (())
lojbanSpace d =
case lojbanChar d of
Parsed c pappyDvs1 pappyErr1 ->
case (isSpace c) of
True ->
Parsed (
()) pappyDvs1 pappyErr1
False -> NoParse pappyErr1
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsePlusRule13 :: LojbanDerivs -> Result LojbanDerivs ([()])
lojbanParsePlusRule13 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanSpace d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule13 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanSpace d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule14 :: LojbanDerivs -> Result LojbanDerivs ([Char])
lojbanParsePlusRule14 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanLojbanLetter d of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule14 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanLojbanLetter d of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanValsi :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanValsi d =
case lojbanPlusRule14 d of
Parsed cs pappyDvs1 pappyErr1 ->
case lojbanPlusRule13 pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (cs) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParsePlusRule15 :: LojbanDerivs -> Result LojbanDerivs ([Char])
lojbanParsePlusRule15 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanSpace d of
NoParse pappyErr3 ->
case pappyResult5 of
NoParse pappyErr5 ->
case lojbanChar d of
Parsed v pappyDvs7 pappyErr7 ->
case lojbanPlusRule15 pappyDvs7 of
Parsed vs pappyDvs9 pappyErr9 ->
Parsed (
v : vs) pappyDvs9 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr9 -> pappyAlt1_2 (maximum [pappyErr9,pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanChar d of
Parsed '.' pappyDvs7 _ ->
Parsed (
".") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos d) [])
Parsed _ _ pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
case lojbanSpace d of
NoParse pappyErr3 ->
case pappyResult5 of
NoParse pappyErr5 ->
case lojbanChar d of
Parsed v pappyDvs7 pappyErr7 ->
Parsed (
[v]) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_3 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_3 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanChar d of
Parsed '.' pappyDvs7 _ ->
Parsed (
".") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos d) [])
Parsed _ _ pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanWord :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanWord d =
case lojbanPlusRule15 d of
Parsed cs pappyDvs1 pappyErr1 ->
case lojbanPlusRule13 pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (cs) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule29 :: LojbanDerivs -> Result LojbanDerivs ([Char])
lojbanParseStarRule29 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case lojbanLojbanLetter d of
Parsed v pappyDvs3 pappyErr3 ->
case pappyResult5 of
NoParse pappyErr5 ->
case lojbanStarRule29 pappyDvs3 of
Parsed vs pappyDvs7 pappyErr7 ->
Parsed (
v : vs) pappyDvs7 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr7 -> pappyAlt1_2 (maximum [pappyErr7,pappyErr5,pappyErr3,pappyErr1])
Parsed _ _ pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
where
pappyResult5 =
case lojbanPlusRule13 pappyDvs3 of
Parsed _ pappyDvs7 pappyErr7 ->
Parsed (
()) pappyDvs7 pappyErr7
NoParse pappyErr7 -> NoParse pappyErr7
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanCMENE :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanCMENE d =
case lojbanStarRule29 d of
Parsed ls pappyDvs1 pappyErr1 ->
case lojbanConsonant pappyDvs1 of
Parsed c pappyDvs3 pappyErr3 ->
case lojbanPlusRule13 pappyDvs3 of
Parsed _ pappyDvs5 pappyErr5 ->
Parsed (
ls++[c]) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> NoParse (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanParseStarRule30 :: LojbanDerivs -> Result LojbanDerivs ([Char])
lojbanParseStarRule30 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanStarRule30 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanVowel d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanChar d of
r @ (Parsed '\'' _ _) -> r
_ -> pappyAlt5_3 pappyErr5
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
Parsed (
[]) d pappyErr1
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanParsePlusRule16 :: LojbanDerivs -> Result LojbanDerivs ([Char])
lojbanParsePlusRule16 d =
pappyAlt1_1 (ParseError (lojbanPos d) []) where
pappyAlt1_1 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
case lojbanPlusRule16 pappyDvs3 of
Parsed vs pappyDvs5 pappyErr5 ->
Parsed (
v : vs) pappyDvs5 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr5 -> pappyAlt1_2 (maximum [pappyErr5,pappyErr3,pappyErr1])
NoParse pappyErr3 -> pappyAlt1_2 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanVowel d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanChar d of
r @ (Parsed '\'' _ _) -> r
_ -> pappyAlt5_3 pappyErr5
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_2 pappyErr1 =
case pappyResult3 of
Parsed v pappyDvs3 pappyErr3 ->
Parsed (
[v]) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> pappyAlt1_3 (max pappyErr3 pappyErr1)
where
pappyResult3 =
pappyAlt5_1 (ParseError (lojbanPos d) []) where
pappyAlt5_1 pappyErr5 =
case lojbanVowel d of
Parsed pappyVal7 pappyDvs7 pappyErr7 -> Parsed pappyVal7 pappyDvs7 (max pappyErr7 pappyErr5)
NoParse pappyErr7 -> pappyAlt5_2 (max pappyErr7 pappyErr5)
pappyAlt5_2 pappyErr5 =
case lojbanChar d of
r @ (Parsed '\'' _ _) -> r
_ -> pappyAlt5_3 pappyErr5
pappyAlt5_3 pappyErr5 = NoParse pappyErr5
pappyAlt1_3 pappyErr1 = NoParse pappyErr1
lojbanpostClause :: LojbanDerivs -> Result LojbanDerivs (())
lojbanpostClause d =
case lojbanPlusRule13 d of
Parsed _ pappyDvs1 pappyErr1 ->
case lojbanBU pappyDvs1 of
NoParse pappyErr3 ->
Parsed (
()) pappyDvs1 (max pappyErr3 pappyErr1)
Parsed _ _ pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
lojbanA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'a' pappyDvs3 _ ->
Parsed (
"a") pappyDvs3 (ParseError (lojbanPos pappyDvs3) [])
Parsed 'e' pappyDvs3 _ ->
Parsed (
"e") pappyDvs3 (ParseError (lojbanPos pappyDvs3) [])
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ji") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'o' pappyDvs3 _ ->
Parsed (
"o") pappyDvs3 (ParseError (lojbanPos pappyDvs3) [])
Parsed 'u' pappyDvs3 _ ->
Parsed (
"u") pappyDvs3 (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanBO :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanBO d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
Parsed (
"bo") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanBOI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanBOI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"boi") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanParseBU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanParseBU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
Parsed (
"bu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanCEhE :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanCEhE d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ce'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanCU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanCU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
Parsed (
"cu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanDOhU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanDOhU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'd' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"do'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanFA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanFA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'f' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"fai") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"fa") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"fi'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"fi") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
Parsed (
"fe") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
Parsed (
"fo") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"fu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanFEhE :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanFEhE d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'f' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"fe'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanGA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanGA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ge'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"ge") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
Parsed (
"go") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
Parsed (
"ga") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"gu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanGAhO :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanGAhO d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ke'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ga'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanGEhU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanGEhU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ge'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanGI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanGI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
Parsed (
"gi") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanGIhA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanGIhA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"gi'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"gi'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"gi'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"gi'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"gi'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanGOI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanGOI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"no'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
Parsed (
"ne") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"goi") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'p' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"po'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"po'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"po") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
Parsed (
"pe") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanParseGOhA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanParseGOhA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
Parsed (
"mo") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"nei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"no'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"go'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"go'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"go'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"go'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"go'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'd' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
Parsed (
"du") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"bu'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"bu'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"bu'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"co'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanGUhA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanGUhA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"gu'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"gu'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"gu'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"gu'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"gu'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'i' pappyDvs3 _ ->
Parsed (
"i") pappyDvs3 (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanJA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanJA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"je'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"je") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
Parsed (
"jo") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
Parsed (
"ja") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"ju") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanKE :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanKE d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
Parsed (
"ke") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanKEhE :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanKEhE d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ke'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanParseKOhA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanParseKOhA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'd' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"da'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"da'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"da") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"di'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"di'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"di") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"de'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"de'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'i' pappyDvs7 _ ->
Parsed (
"dei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"de") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"do'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"do'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"do") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"mi'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"mi'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"mi") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ma'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"ma") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ko'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ko'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ko'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ko'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ko'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"ko") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ke'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'f' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"fo'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"fo'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"fo'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"fo'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"fo'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"vo'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"vo'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"vo'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"vo'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"vo'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'z' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"zi'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"zu'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"zo'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ce'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'r' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
Parsed (
"ru") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ri") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
Parsed (
"ra") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
Parsed (
"ta") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"tu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ti") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanKU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanKU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
Parsed (
"ku") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanKUhO :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanKUhO d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ku'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanLA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanLA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'l' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"lai") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"la'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"la") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanLEhU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanLEhU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'l' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"le'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanLI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanLI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"me'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'l' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
Parsed (
"li") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanLOhO :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanLOhO d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'l' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"lo'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanLUhU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanLUhU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'l' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"lu'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanMOI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanMOI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"mei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"moi") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 's' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"si'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"cu'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"va'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanNA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanNA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ja'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
Parsed (
"na") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanNAI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanNAI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"nai") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanNAhE :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanNAhE d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"to'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"je'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"na'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"no'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanNIhO :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanNIhO d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ni'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"no'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanNOI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanNOI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"voi") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"noi") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'p' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"poi") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanNUhI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanNUhI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"nu'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanNUhU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanNUhU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"nu'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanParsePA :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanParsePA d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'p' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"pi'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"pi") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"pai") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"pa") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'f' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"fi'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"fei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'z' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"za'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
Parsed (
"ze") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"me'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ma'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"mo'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"mu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ni'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"no'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"no") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ki'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ka'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ce'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ci'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"ci") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'r' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ra'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"rau") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"rei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"re") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
Parsed (
"ro") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'd' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"da'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"dau") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"du'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 's' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"so'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"so'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"so'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"so'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"so'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ ->
Parsed (
"so") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"su'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"su'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ji'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
Parsed (
"jau") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"te'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"tu'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"gai") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"vai") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
Parsed (
"vo") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'x' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
Parsed (
"xo") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
Parsed (
"xa") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
Parsed (
"bi") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanSE :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanSE d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 's' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
Parsed (
"se") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
Parsed (
"te") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
Parsed (
"ve") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'x' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
Parsed (
"xe") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanSEI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanSEI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 's' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"sei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ti'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanSEhU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanSEhU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 's' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"se'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanTEhU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanTEhU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"te'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanParseUI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanParseUI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'i' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed '\'' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'a' pappyDvs7 _ ->
Parsed (
"i'a") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'o' pappyDvs7 _ ->
Parsed (
"i'o") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'e' pappyDvs7 _ ->
Parsed (
"i'e") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"i'u") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'i' pappyDvs7 _ ->
Parsed (
"i'i") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
Parsed (
"ie") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
Parsed (
"ia") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ii") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"iu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
Parsed (
"io") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'a' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed '\'' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
Parsed (
"a'e") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
Parsed (
"a'a") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'i' pappyDvs7 _ ->
Parsed (
"a'i") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'o' pappyDvs7 _ ->
Parsed (
"a'o") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"a'u") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"au") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ai") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'u' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed '\'' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"u'i") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'o' pappyDvs7 _ ->
Parsed (
"u'o") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
Parsed (
"u'a") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"u'u") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'e' pappyDvs7 _ ->
Parsed (
"u'e") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
Parsed (
"uo") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
Parsed (
"ua") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ui") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
Parsed (
"uu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
Parsed (
"ue") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'o' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed '\'' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"o'i") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'e' pappyDvs7 _ ->
Parsed (
"o'e") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'o' pappyDvs7 _ ->
Parsed (
"o'o") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
Parsed (
"o'a") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"o'u") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
Parsed (
"oi") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'e' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed '\'' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'e' pappyDvs7 _ ->
Parsed (
"e'e") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'i' pappyDvs7 _ ->
Parsed (
"e'i") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'a' pappyDvs7 _ ->
Parsed (
"e'a") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'o' pappyDvs7 _ ->
Parsed (
"e'o") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"e'u") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
Parsed (
"ei") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'b' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ba'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ba'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"bi'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"be'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"bu'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'j' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ja'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ju'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ju'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"je'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"jo'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ji'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'c' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ca'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 's' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"su'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"se'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'i' pappyDvs9 _ ->
Parsed (
"se'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"se'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"sa'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"sa'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"sa'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"si'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 't' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ti'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ta'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ta'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"to'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'k' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ka'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"kau") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ke'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ku'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ki'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'z' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"za'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"zu'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"zo'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'p' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"pe'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"pe'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"pa'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'u' pappyDvs7 _ ->
Parsed (
"pau") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"po'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'r' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ru'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ra'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ro'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ro'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ro'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'u' pappyDvs9 _ ->
Parsed (
"ro'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'a' pappyDvs9 _ ->
Parsed (
"ro'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"re'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ri'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'l' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"li'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
Parsed 'o' pappyDvs9 _ ->
Parsed (
"li'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"la'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"le'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'm' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"mu'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'i' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'u' pappyDvs9 _ ->
Parsed (
"mi'u") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'd' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'o' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'a' pappyDvs9 _ ->
Parsed (
"do'a") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"da'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
Parsed 'i' pappyDvs7 _ ->
Parsed (
"dai") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"va'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"vu'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'n' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"na'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'f' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"fu'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'g' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'i' pappyDvs9 _ ->
Parsed (
"ga'i") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'e' pappyDvs9 _ ->
Parsed (
"ge'e") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
Parsed 'x' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'u' pappyDvs5 _ ->
Parsed (
"xu") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanVAU :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanVAU d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'a' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'u' pappyDvs7 _ ->
Parsed (
"vau") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanVEI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanVEI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"vei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanVEhO :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanVEhO d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'v' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed '\'' pappyDvs7 _ ->
case lojbanChar pappyDvs7 of
Parsed 'o' pappyDvs9 _ ->
Parsed (
"ve'o") pappyDvs9 (ParseError (lojbanPos pappyDvs9) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanXI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanXI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanpostClause pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'x' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'i' pappyDvs5 _ ->
Parsed (
"xi") pappyDvs5 (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
lojbanZEI :: LojbanDerivs -> Result LojbanDerivs (String)
lojbanZEI d =
case pappyResult1 of
Parsed s pappyDvs1 pappyErr1 ->
case lojbanPlusRule13 pappyDvs1 of
Parsed _ pappyDvs3 pappyErr3 ->
Parsed (s) pappyDvs3 (max pappyErr3 pappyErr1)
NoParse pappyErr3 -> NoParse (max pappyErr3 pappyErr1)
NoParse pappyErr1 -> NoParse pappyErr1
where
pappyResult1 =
case lojbanChar d of
Parsed 'z' pappyDvs3 _ ->
case lojbanChar pappyDvs3 of
Parsed 'e' pappyDvs5 _ ->
case lojbanChar pappyDvs5 of
Parsed 'i' pappyDvs7 _ ->
Parsed (
"zei") pappyDvs7 (ParseError (lojbanPos pappyDvs7) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs5) [])
_ -> NoParse (ParseError (lojbanPos pappyDvs3) [])
_ -> NoParse (ParseError (lojbanPos d) [])
|
lagleki/tersmu-0.2
|
Lojban.hs
|
gpl-3.0
| 612,863 | 423 | 46 | 246,822 | 156,505 | 75,858 | 80,647 | 11,157 | 407 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- |
-- Module : Network.Google.Resource.AndroidEnterprise.ManagedConfigurationsforDevice.List
-- Copyright : (c) 2015-2016 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Lists all the per-device managed configurations for the specified
-- device. Only the ID is set.
--
-- /See:/ <https://developers.google.com/android/work/play/emm-api Google Play EMM API Reference> for @androidenterprise.managedconfigurationsfordevice.list@.
module Network.Google.Resource.AndroidEnterprise.ManagedConfigurationsforDevice.List
(
-- * REST Resource
ManagedConfigurationsforDeviceListResource
-- * Creating a Request
, managedConfigurationsforDeviceList
, ManagedConfigurationsforDeviceList
-- * Request Lenses
, mcdlXgafv
, mcdlUploadProtocol
, mcdlEnterpriseId
, mcdlAccessToken
, mcdlUploadType
, mcdlUserId
, mcdlDeviceId
, mcdlCallback
) where
import Network.Google.AndroidEnterprise.Types
import Network.Google.Prelude
-- | A resource alias for @androidenterprise.managedconfigurationsfordevice.list@ method which the
-- 'ManagedConfigurationsforDeviceList' request conforms to.
type ManagedConfigurationsforDeviceListResource =
"androidenterprise" :>
"v1" :>
"enterprises" :>
Capture "enterpriseId" Text :>
"users" :>
Capture "userId" Text :>
"devices" :>
Capture "deviceId" Text :>
"managedConfigurationsForDevice" :>
QueryParam "$.xgafv" Xgafv :>
QueryParam "upload_protocol" Text :>
QueryParam "access_token" Text :>
QueryParam "uploadType" Text :>
QueryParam "callback" Text :>
QueryParam "alt" AltJSON :>
Get '[JSON]
ManagedConfigurationsForDeviceListResponse
-- | Lists all the per-device managed configurations for the specified
-- device. Only the ID is set.
--
-- /See:/ 'managedConfigurationsforDeviceList' smart constructor.
data ManagedConfigurationsforDeviceList =
ManagedConfigurationsforDeviceList'
{ _mcdlXgafv :: !(Maybe Xgafv)
, _mcdlUploadProtocol :: !(Maybe Text)
, _mcdlEnterpriseId :: !Text
, _mcdlAccessToken :: !(Maybe Text)
, _mcdlUploadType :: !(Maybe Text)
, _mcdlUserId :: !Text
, _mcdlDeviceId :: !Text
, _mcdlCallback :: !(Maybe Text)
}
deriving (Eq, Show, Data, Typeable, Generic)
-- | Creates a value of 'ManagedConfigurationsforDeviceList' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'mcdlXgafv'
--
-- * 'mcdlUploadProtocol'
--
-- * 'mcdlEnterpriseId'
--
-- * 'mcdlAccessToken'
--
-- * 'mcdlUploadType'
--
-- * 'mcdlUserId'
--
-- * 'mcdlDeviceId'
--
-- * 'mcdlCallback'
managedConfigurationsforDeviceList
:: Text -- ^ 'mcdlEnterpriseId'
-> Text -- ^ 'mcdlUserId'
-> Text -- ^ 'mcdlDeviceId'
-> ManagedConfigurationsforDeviceList
managedConfigurationsforDeviceList pMcdlEnterpriseId_ pMcdlUserId_ pMcdlDeviceId_ =
ManagedConfigurationsforDeviceList'
{ _mcdlXgafv = Nothing
, _mcdlUploadProtocol = Nothing
, _mcdlEnterpriseId = pMcdlEnterpriseId_
, _mcdlAccessToken = Nothing
, _mcdlUploadType = Nothing
, _mcdlUserId = pMcdlUserId_
, _mcdlDeviceId = pMcdlDeviceId_
, _mcdlCallback = Nothing
}
-- | V1 error format.
mcdlXgafv :: Lens' ManagedConfigurationsforDeviceList (Maybe Xgafv)
mcdlXgafv
= lens _mcdlXgafv (\ s a -> s{_mcdlXgafv = a})
-- | Upload protocol for media (e.g. \"raw\", \"multipart\").
mcdlUploadProtocol :: Lens' ManagedConfigurationsforDeviceList (Maybe Text)
mcdlUploadProtocol
= lens _mcdlUploadProtocol
(\ s a -> s{_mcdlUploadProtocol = a})
-- | The ID of the enterprise.
mcdlEnterpriseId :: Lens' ManagedConfigurationsforDeviceList Text
mcdlEnterpriseId
= lens _mcdlEnterpriseId
(\ s a -> s{_mcdlEnterpriseId = a})
-- | OAuth access token.
mcdlAccessToken :: Lens' ManagedConfigurationsforDeviceList (Maybe Text)
mcdlAccessToken
= lens _mcdlAccessToken
(\ s a -> s{_mcdlAccessToken = a})
-- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").
mcdlUploadType :: Lens' ManagedConfigurationsforDeviceList (Maybe Text)
mcdlUploadType
= lens _mcdlUploadType
(\ s a -> s{_mcdlUploadType = a})
-- | The ID of the user.
mcdlUserId :: Lens' ManagedConfigurationsforDeviceList Text
mcdlUserId
= lens _mcdlUserId (\ s a -> s{_mcdlUserId = a})
-- | The Android ID of the device.
mcdlDeviceId :: Lens' ManagedConfigurationsforDeviceList Text
mcdlDeviceId
= lens _mcdlDeviceId (\ s a -> s{_mcdlDeviceId = a})
-- | JSONP
mcdlCallback :: Lens' ManagedConfigurationsforDeviceList (Maybe Text)
mcdlCallback
= lens _mcdlCallback (\ s a -> s{_mcdlCallback = a})
instance GoogleRequest
ManagedConfigurationsforDeviceList
where
type Rs ManagedConfigurationsforDeviceList =
ManagedConfigurationsForDeviceListResponse
type Scopes ManagedConfigurationsforDeviceList =
'["https://www.googleapis.com/auth/androidenterprise"]
requestClient ManagedConfigurationsforDeviceList'{..}
= go _mcdlEnterpriseId _mcdlUserId _mcdlDeviceId
_mcdlXgafv
_mcdlUploadProtocol
_mcdlAccessToken
_mcdlUploadType
_mcdlCallback
(Just AltJSON)
androidEnterpriseService
where go
= buildClient
(Proxy ::
Proxy ManagedConfigurationsforDeviceListResource)
mempty
|
brendanhay/gogol
|
gogol-android-enterprise/gen/Network/Google/Resource/AndroidEnterprise/ManagedConfigurationsforDevice/List.hs
|
mpl-2.0
| 6,441 | 0 | 22 | 1,546 | 866 | 503 | 363 | 135 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- Module : Network.AWS.DataPipeline.QueryObjects
-- Copyright : (c) 2013-2014 Brendan Hay <[email protected]>
-- License : This Source Code Form is subject to the terms of
-- the Mozilla Public License, v. 2.0.
-- A copy of the MPL can be found in the LICENSE file or
-- you can obtain it at http://mozilla.org/MPL/2.0/.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : experimental
-- Portability : non-portable (GHC extensions)
--
-- Derived from AWS service descriptions, licensed under Apache 2.0.
-- | Queries a pipeline for the names of objects that match a specified set of
-- conditions.
--
-- The objects returned by 'QueryObjects' are paginated and then filtered by the
-- value you set for query. This means the action may return an empty result set
-- with a value set for marker. If 'HasMoreResults' is set to 'True', you should
-- continue to call 'QueryObjects', passing in the returned value for marker,
-- until 'HasMoreResults' returns 'False'.
--
-- <http://docs.aws.amazon.com/datapipeline/latest/APIReference/API_QueryObjects.html>
module Network.AWS.DataPipeline.QueryObjects
(
-- * Request
QueryObjects
-- ** Request constructor
, queryObjects
-- ** Request lenses
, qoLimit
, qoMarker
, qoPipelineId
, qoQuery
, qoSphere
-- * Response
, QueryObjectsResponse
-- ** Response constructor
, queryObjectsResponse
-- ** Response lenses
, qorHasMoreResults
, qorIds
, qorMarker
) where
import Network.AWS.Prelude
import Network.AWS.Request.JSON
import Network.AWS.DataPipeline.Types
import qualified GHC.Exts
data QueryObjects = QueryObjects
{ _qoLimit :: Maybe Int
, _qoMarker :: Maybe Text
, _qoPipelineId :: Text
, _qoQuery :: Maybe Query
, _qoSphere :: Text
} deriving (Eq, Read, Show)
-- | 'QueryObjects' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'qoLimit' @::@ 'Maybe' 'Int'
--
-- * 'qoMarker' @::@ 'Maybe' 'Text'
--
-- * 'qoPipelineId' @::@ 'Text'
--
-- * 'qoQuery' @::@ 'Maybe' 'Query'
--
-- * 'qoSphere' @::@ 'Text'
--
queryObjects :: Text -- ^ 'qoPipelineId'
-> Text -- ^ 'qoSphere'
-> QueryObjects
queryObjects p1 p2 = QueryObjects
{ _qoPipelineId = p1
, _qoSphere = p2
, _qoQuery = Nothing
, _qoMarker = Nothing
, _qoLimit = Nothing
}
-- | Specifies the maximum number of object names that 'QueryObjects' will return in
-- a single call. The default value is 100.
qoLimit :: Lens' QueryObjects (Maybe Int)
qoLimit = lens _qoLimit (\s a -> s { _qoLimit = a })
-- | The starting point for the results to be returned. The first time you call 'QueryObjects', this value should be empty. As long as the action returns 'HasMoreResults' as 'True', you can call 'QueryObjects' again and pass the marker value from the
-- response to retrieve the next set of results.
qoMarker :: Lens' QueryObjects (Maybe Text)
qoMarker = lens _qoMarker (\s a -> s { _qoMarker = a })
-- | Identifier of the pipeline to be queried for object names.
qoPipelineId :: Lens' QueryObjects Text
qoPipelineId = lens _qoPipelineId (\s a -> s { _qoPipelineId = a })
-- | Query that defines the objects to be returned. The 'Query' object can contain
-- a maximum of ten selectors. The conditions in the query are limited to
-- top-level String fields in the object. These filters can be applied to
-- components, instances, and attempts.
qoQuery :: Lens' QueryObjects (Maybe Query)
qoQuery = lens _qoQuery (\s a -> s { _qoQuery = a })
-- | Specifies whether the query applies to components or instances. Allowable
-- values: 'COMPONENT', 'INSTANCE', 'ATTEMPT'.
qoSphere :: Lens' QueryObjects Text
qoSphere = lens _qoSphere (\s a -> s { _qoSphere = a })
data QueryObjectsResponse = QueryObjectsResponse
{ _qorHasMoreResults :: Maybe Bool
, _qorIds :: List "ids" Text
, _qorMarker :: Maybe Text
} deriving (Eq, Ord, Read, Show)
-- | 'QueryObjectsResponse' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'qorHasMoreResults' @::@ 'Maybe' 'Bool'
--
-- * 'qorIds' @::@ ['Text']
--
-- * 'qorMarker' @::@ 'Maybe' 'Text'
--
queryObjectsResponse :: QueryObjectsResponse
queryObjectsResponse = QueryObjectsResponse
{ _qorIds = mempty
, _qorMarker = Nothing
, _qorHasMoreResults = Nothing
}
-- | If 'True', there are more results that can be obtained by a subsequent call to 'QueryObjects'.
qorHasMoreResults :: Lens' QueryObjectsResponse (Maybe Bool)
qorHasMoreResults =
lens _qorHasMoreResults (\s a -> s { _qorHasMoreResults = a })
-- | A list of identifiers that match the query selectors.
qorIds :: Lens' QueryObjectsResponse [Text]
qorIds = lens _qorIds (\s a -> s { _qorIds = a }) . _List
-- | The starting point for the results to be returned. As long as the action
-- returns 'HasMoreResults' as 'True', you can call 'QueryObjects' again and pass the
-- marker value from the response to retrieve the next set of results.
qorMarker :: Lens' QueryObjectsResponse (Maybe Text)
qorMarker = lens _qorMarker (\s a -> s { _qorMarker = a })
instance ToPath QueryObjects where
toPath = const "/"
instance ToQuery QueryObjects where
toQuery = const mempty
instance ToHeaders QueryObjects
instance ToJSON QueryObjects where
toJSON QueryObjects{..} = object
[ "pipelineId" .= _qoPipelineId
, "query" .= _qoQuery
, "sphere" .= _qoSphere
, "marker" .= _qoMarker
, "limit" .= _qoLimit
]
instance AWSRequest QueryObjects where
type Sv QueryObjects = DataPipeline
type Rs QueryObjects = QueryObjectsResponse
request = post "QueryObjects"
response = jsonResponse
instance FromJSON QueryObjectsResponse where
parseJSON = withObject "QueryObjectsResponse" $ \o -> QueryObjectsResponse
<$> o .:? "hasMoreResults"
<*> o .:? "ids" .!= mempty
<*> o .:? "marker"
instance AWSPager QueryObjects where
page rq rs
| stop (rs ^. qorHasMoreResults) = Nothing
| otherwise = Just $ rq
& qoMarker .~ rs ^. qorMarker
|
dysinger/amazonka
|
amazonka-datapipeline/gen/Network/AWS/DataPipeline/QueryObjects.hs
|
mpl-2.0
| 6,730 | 0 | 14 | 1,562 | 947 | 561 | 386 | 98 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- |
-- Module : Network.Google.Resource.AndroidEnterprise.WebApps.Insert
-- Copyright : (c) 2015-2016 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a new web app for the enterprise.
--
-- /See:/ <https://developers.google.com/android/work/play/emm-api Google Play EMM API Reference> for @androidenterprise.webapps.insert@.
module Network.Google.Resource.AndroidEnterprise.WebApps.Insert
(
-- * REST Resource
WebAppsInsertResource
-- * Creating a Request
, webAppsInsert
, WebAppsInsert
-- * Request Lenses
, waiXgafv
, waiUploadProtocol
, waiEnterpriseId
, waiAccessToken
, waiUploadType
, waiPayload
, waiCallback
) where
import Network.Google.AndroidEnterprise.Types
import Network.Google.Prelude
-- | A resource alias for @androidenterprise.webapps.insert@ method which the
-- 'WebAppsInsert' request conforms to.
type WebAppsInsertResource =
"androidenterprise" :>
"v1" :>
"enterprises" :>
Capture "enterpriseId" Text :>
"webApps" :>
QueryParam "$.xgafv" Xgafv :>
QueryParam "upload_protocol" Text :>
QueryParam "access_token" Text :>
QueryParam "uploadType" Text :>
QueryParam "callback" Text :>
QueryParam "alt" AltJSON :>
ReqBody '[JSON] WebApp :> Post '[JSON] WebApp
-- | Creates a new web app for the enterprise.
--
-- /See:/ 'webAppsInsert' smart constructor.
data WebAppsInsert =
WebAppsInsert'
{ _waiXgafv :: !(Maybe Xgafv)
, _waiUploadProtocol :: !(Maybe Text)
, _waiEnterpriseId :: !Text
, _waiAccessToken :: !(Maybe Text)
, _waiUploadType :: !(Maybe Text)
, _waiPayload :: !WebApp
, _waiCallback :: !(Maybe Text)
}
deriving (Eq, Show, Data, Typeable, Generic)
-- | Creates a value of 'WebAppsInsert' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'waiXgafv'
--
-- * 'waiUploadProtocol'
--
-- * 'waiEnterpriseId'
--
-- * 'waiAccessToken'
--
-- * 'waiUploadType'
--
-- * 'waiPayload'
--
-- * 'waiCallback'
webAppsInsert
:: Text -- ^ 'waiEnterpriseId'
-> WebApp -- ^ 'waiPayload'
-> WebAppsInsert
webAppsInsert pWaiEnterpriseId_ pWaiPayload_ =
WebAppsInsert'
{ _waiXgafv = Nothing
, _waiUploadProtocol = Nothing
, _waiEnterpriseId = pWaiEnterpriseId_
, _waiAccessToken = Nothing
, _waiUploadType = Nothing
, _waiPayload = pWaiPayload_
, _waiCallback = Nothing
}
-- | V1 error format.
waiXgafv :: Lens' WebAppsInsert (Maybe Xgafv)
waiXgafv = lens _waiXgafv (\ s a -> s{_waiXgafv = a})
-- | Upload protocol for media (e.g. \"raw\", \"multipart\").
waiUploadProtocol :: Lens' WebAppsInsert (Maybe Text)
waiUploadProtocol
= lens _waiUploadProtocol
(\ s a -> s{_waiUploadProtocol = a})
-- | The ID of the enterprise.
waiEnterpriseId :: Lens' WebAppsInsert Text
waiEnterpriseId
= lens _waiEnterpriseId
(\ s a -> s{_waiEnterpriseId = a})
-- | OAuth access token.
waiAccessToken :: Lens' WebAppsInsert (Maybe Text)
waiAccessToken
= lens _waiAccessToken
(\ s a -> s{_waiAccessToken = a})
-- | Legacy upload protocol for media (e.g. \"media\", \"multipart\").
waiUploadType :: Lens' WebAppsInsert (Maybe Text)
waiUploadType
= lens _waiUploadType
(\ s a -> s{_waiUploadType = a})
-- | Multipart request metadata.
waiPayload :: Lens' WebAppsInsert WebApp
waiPayload
= lens _waiPayload (\ s a -> s{_waiPayload = a})
-- | JSONP
waiCallback :: Lens' WebAppsInsert (Maybe Text)
waiCallback
= lens _waiCallback (\ s a -> s{_waiCallback = a})
instance GoogleRequest WebAppsInsert where
type Rs WebAppsInsert = WebApp
type Scopes WebAppsInsert =
'["https://www.googleapis.com/auth/androidenterprise"]
requestClient WebAppsInsert'{..}
= go _waiEnterpriseId _waiXgafv _waiUploadProtocol
_waiAccessToken
_waiUploadType
_waiCallback
(Just AltJSON)
_waiPayload
androidEnterpriseService
where go
= buildClient (Proxy :: Proxy WebAppsInsertResource)
mempty
|
brendanhay/gogol
|
gogol-android-enterprise/gen/Network/Google/Resource/AndroidEnterprise/WebApps/Insert.hs
|
mpl-2.0
| 4,939 | 0 | 19 | 1,195 | 786 | 457 | 329 | 115 | 1 |
module Main where
import System.Environment (getArgs)
import System.Directory
main :: IO ()
main = do args <- getArgs
mapM_ createDirectory args
|
tyoko-dev/coreutils-haskell
|
src/mkdir.hs
|
agpl-3.0
| 156 | 0 | 7 | 32 | 49 | 26 | 23 | 6 | 1 |
module StoryMode.Menus (
storyMode,
) where
import Data.Map (lookup, findWithDefault)
import Data.Initial
import System.FilePath
import Utils hiding (tryReadMVar)
import Base
import Editor.Pickle.LevelFile
import StoryMode.Types
import StoryMode.Configuration
import StoryMode.Episode
-- * story mode menu itself
-- | Menu for the story mode
storyMode :: Application -> Play -> Parent -> AppState
storyMode app play parent = NoGUIAppState $ io $ do
episodes <- loadEpisodes
return $ mkEpisodesMenu app play parent episodes 0
-- | a menu showing all available episodes
mkEpisodesMenu :: Application -> Play -> Parent -> [Episode LevelFile] -> Int -> AppState
mkEpisodesMenu app play parent episodes =
menuAppState app
(NormalMenu (p "Story Episodes") (Just $ p "choose an episode"))
(Just parent)
(map (mkMenuItem app play this) episodes)
where
this = mkEpisodesMenu app play parent episodes
mkMenuItem :: Application -> Play -> (Int -> Parent)
-> Episode LevelFile -> MenuItem
mkMenuItem app play parent e =
MenuItem (pv $ epTitle $ euid e) (\ i -> mkEpisodeMenu app play (parent i) e 0)
-- | a menu for one episode.
mkEpisodeMenu :: Application -> Play -> Parent
-> Episode LevelFile -> Int -> AppState
mkEpisodeMenu app play parent ep ps = NoGUIAppState $ do
scores <- io $ getScores
let passedIntro = hasPassedIntro (highScores scores) ep
introItem = mkItem scores False (intro ep)
restItems = if not passedIntro then [] else
let bodyItems = map (mkItem scores False) (body ep)
outroItem = mkItem scores True (outro ep)
in (bodyItems +: outroItem)
happyEndItem = if episodeCompleted scores
then pure $ mkItem scores False (happyEnd ep)
else []
creditsItem = MenuItem (renderable $ p "credits") (credits app . this)
return $ menuAppState app
(NormalMenu (p "Story Episodes") (Just $ p "choose a level"))
(Just parent)
(introItem :
restItems ++
happyEndItem ++
creditsItem :
[])
ps
where
episodeCompleted :: HighScoreFile -> Bool
episodeCompleted hsf =
let outroScore = Data.Map.lookup (levelUID $ outro ep) (highScores hsf)
in maybe False isPassedScore outroScore
mkItem :: HighScoreFile -> Bool -> LevelFile -> MenuItem
mkItem scores isOutro level = MenuItem
(showLevel scores isOutro level)
(\ i -> play (this i) level)
showLevel :: HighScoreFile -> Bool -> LevelFile -> Prose
showLevel scores isOutro = if isOutro
then showOutroLevelForMenu (highScores scores) ep
(findWithDefault initial (euid ep) (episodeScores scores))
else showLevelForMenu (highScores scores)
this = mkEpisodeMenu app play parent ep
hasPassedIntro :: Scores -> Episode LevelFile -> Bool
hasPassedIntro scores e =
maybe False isPassedScore $
Data.Map.lookup (levelUID $ intro e) scores
credits :: Application -> Parent -> AppState
credits app parent = NoGUIAppState $ io $ do
file <- getStoryModeDataFileName ("manual" </> "credits" <.> "txt")
prose <- pFile file
return $ scrollingAppState app prose parent
|
nikki-and-the-robots/nikki
|
src/StoryMode/Menus.hs
|
lgpl-3.0
| 3,249 | 0 | 18 | 802 | 991 | 503 | 488 | 72 | 4 |
ans (n:d) =
let s = sum d
a = s `div` n
in
a
main = do
c <- getContents
let i = map read $ lines c :: [Int]
o = ans i
print o
|
a143753/AOJ
|
0134.hs
|
apache-2.0
| 153 | 0 | 11 | 64 | 92 | 45 | 47 | 9 | 1 |
{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
{-| Module : QRadioButton.hs
Copyright : (c) David Harley 2010
Project : qtHaskell
Version : 1.1.4
Modified : 2010-09-02 17:02:15
Warning : this file is machine generated - do not modify.
--}
-----------------------------------------------------------------------------
module Qtc.Gui.QRadioButton (
QqRadioButton(..)
,qRadioButton_delete
,qRadioButton_deleteLater
)
where
import Foreign.C.Types
import Qth.ClassTypes.Core
import Qtc.Enums.Base
import Qtc.Enums.Gui.QPaintDevice
import Qtc.Enums.Core.Qt
import Qtc.Classes.Base
import Qtc.Classes.Qccs
import Qtc.Classes.Core
import Qtc.ClassTypes.Core
import Qth.ClassTypes.Core
import Qtc.Classes.Gui
import Qtc.ClassTypes.Gui
instance QuserMethod (QRadioButton ()) (()) (IO ()) where
userMethod qobj evid ()
= withObjectPtr qobj $ \cobj_qobj ->
qtc_QRadioButton_userMethod cobj_qobj (toCInt evid)
foreign import ccall "qtc_QRadioButton_userMethod" qtc_QRadioButton_userMethod :: Ptr (TQRadioButton a) -> CInt -> IO ()
instance QuserMethod (QRadioButtonSc a) (()) (IO ()) where
userMethod qobj evid ()
= withObjectPtr qobj $ \cobj_qobj ->
qtc_QRadioButton_userMethod cobj_qobj (toCInt evid)
instance QuserMethod (QRadioButton ()) (QVariant ()) (IO (QVariant ())) where
userMethod qobj evid qvoj
= withObjectRefResult $
withObjectPtr qobj $ \cobj_qobj ->
withObjectPtr qvoj $ \cobj_qvoj ->
qtc_QRadioButton_userMethodVariant cobj_qobj (toCInt evid) cobj_qvoj
foreign import ccall "qtc_QRadioButton_userMethodVariant" qtc_QRadioButton_userMethodVariant :: Ptr (TQRadioButton a) -> CInt -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
instance QuserMethod (QRadioButtonSc a) (QVariant ()) (IO (QVariant ())) where
userMethod qobj evid qvoj
= withObjectRefResult $
withObjectPtr qobj $ \cobj_qobj ->
withObjectPtr qvoj $ \cobj_qvoj ->
qtc_QRadioButton_userMethodVariant cobj_qobj (toCInt evid) cobj_qvoj
class QqRadioButton x1 where
qRadioButton :: x1 -> IO (QRadioButton ())
instance QqRadioButton (()) where
qRadioButton ()
= withQRadioButtonResult $
qtc_QRadioButton
foreign import ccall "qtc_QRadioButton" qtc_QRadioButton :: IO (Ptr (TQRadioButton ()))
instance QqRadioButton ((QWidget t1)) where
qRadioButton (x1)
= withQRadioButtonResult $
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton1 cobj_x1
foreign import ccall "qtc_QRadioButton1" qtc_QRadioButton1 :: Ptr (TQWidget t1) -> IO (Ptr (TQRadioButton ()))
instance QqRadioButton ((String)) where
qRadioButton (x1)
= withQRadioButtonResult $
withCWString x1 $ \cstr_x1 ->
qtc_QRadioButton2 cstr_x1
foreign import ccall "qtc_QRadioButton2" qtc_QRadioButton2 :: CWString -> IO (Ptr (TQRadioButton ()))
instance QqRadioButton ((String, QWidget t2)) where
qRadioButton (x1, x2)
= withQRadioButtonResult $
withCWString x1 $ \cstr_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QRadioButton3 cstr_x1 cobj_x2
foreign import ccall "qtc_QRadioButton3" qtc_QRadioButton3 :: CWString -> Ptr (TQWidget t2) -> IO (Ptr (TQRadioButton ()))
instance Qevent (QRadioButton ()) ((QEvent t1)) where
event x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_event_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_event_h" qtc_QRadioButton_event_h :: Ptr (TQRadioButton a) -> Ptr (TQEvent t1) -> IO CBool
instance Qevent (QRadioButtonSc a) ((QEvent t1)) where
event x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_event_h cobj_x0 cobj_x1
instance QhitButton (QRadioButton ()) ((Point)) where
hitButton x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withCPoint x1 $ \cpoint_x1_x cpoint_x1_y ->
qtc_QRadioButton_hitButton_qth cobj_x0 cpoint_x1_x cpoint_x1_y
foreign import ccall "qtc_QRadioButton_hitButton_qth" qtc_QRadioButton_hitButton_qth :: Ptr (TQRadioButton a) -> CInt -> CInt -> IO CBool
instance QhitButton (QRadioButtonSc a) ((Point)) where
hitButton x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withCPoint x1 $ \cpoint_x1_x cpoint_x1_y ->
qtc_QRadioButton_hitButton_qth cobj_x0 cpoint_x1_x cpoint_x1_y
instance QqhitButton (QRadioButton ()) ((QPoint t1)) where
qhitButton x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_hitButton cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_hitButton" qtc_QRadioButton_hitButton :: Ptr (TQRadioButton a) -> Ptr (TQPoint t1) -> IO CBool
instance QqhitButton (QRadioButtonSc a) ((QPoint t1)) where
qhitButton x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_hitButton cobj_x0 cobj_x1
instance QinitStyleOption (QRadioButton ()) ((QStyleOptionButton t1)) where
initStyleOption x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_initStyleOption cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_initStyleOption" qtc_QRadioButton_initStyleOption :: Ptr (TQRadioButton a) -> Ptr (TQStyleOptionButton t1) -> IO ()
instance QinitStyleOption (QRadioButtonSc a) ((QStyleOptionButton t1)) where
initStyleOption x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_initStyleOption cobj_x0 cobj_x1
instance QmouseMoveEvent (QRadioButton ()) ((QMouseEvent t1)) where
mouseMoveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mouseMoveEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_mouseMoveEvent_h" qtc_QRadioButton_mouseMoveEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQMouseEvent t1) -> IO ()
instance QmouseMoveEvent (QRadioButtonSc a) ((QMouseEvent t1)) where
mouseMoveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mouseMoveEvent_h cobj_x0 cobj_x1
instance QpaintEvent (QRadioButton ()) ((QPaintEvent t1)) where
paintEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_paintEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_paintEvent_h" qtc_QRadioButton_paintEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQPaintEvent t1) -> IO ()
instance QpaintEvent (QRadioButtonSc a) ((QPaintEvent t1)) where
paintEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_paintEvent_h cobj_x0 cobj_x1
instance QqsizeHint (QRadioButton ()) (()) where
qsizeHint x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_sizeHint_h cobj_x0
foreign import ccall "qtc_QRadioButton_sizeHint_h" qtc_QRadioButton_sizeHint_h :: Ptr (TQRadioButton a) -> IO (Ptr (TQSize ()))
instance QqsizeHint (QRadioButtonSc a) (()) where
qsizeHint x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_sizeHint_h cobj_x0
instance QsizeHint (QRadioButton ()) (()) where
sizeHint x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_sizeHint_qth_h cobj_x0 csize_ret_w csize_ret_h
foreign import ccall "qtc_QRadioButton_sizeHint_qth_h" qtc_QRadioButton_sizeHint_qth_h :: Ptr (TQRadioButton a) -> Ptr CInt -> Ptr CInt -> IO ()
instance QsizeHint (QRadioButtonSc a) (()) where
sizeHint x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_sizeHint_qth_h cobj_x0 csize_ret_w csize_ret_h
qRadioButton_delete :: QRadioButton a -> IO ()
qRadioButton_delete x0
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_delete cobj_x0
foreign import ccall "qtc_QRadioButton_delete" qtc_QRadioButton_delete :: Ptr (TQRadioButton a) -> IO ()
qRadioButton_deleteLater :: QRadioButton a -> IO ()
qRadioButton_deleteLater x0
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_deleteLater cobj_x0
foreign import ccall "qtc_QRadioButton_deleteLater" qtc_QRadioButton_deleteLater :: Ptr (TQRadioButton a) -> IO ()
instance QchangeEvent (QRadioButton ()) ((QEvent t1)) where
changeEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_changeEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_changeEvent_h" qtc_QRadioButton_changeEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQEvent t1) -> IO ()
instance QchangeEvent (QRadioButtonSc a) ((QEvent t1)) where
changeEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_changeEvent_h cobj_x0 cobj_x1
instance QcheckStateSet (QRadioButton ()) (()) where
checkStateSet x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_checkStateSet cobj_x0
foreign import ccall "qtc_QRadioButton_checkStateSet" qtc_QRadioButton_checkStateSet :: Ptr (TQRadioButton a) -> IO ()
instance QcheckStateSet (QRadioButtonSc a) (()) where
checkStateSet x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_checkStateSet cobj_x0
instance QfocusInEvent (QRadioButton ()) ((QFocusEvent t1)) where
focusInEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_focusInEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_focusInEvent_h" qtc_QRadioButton_focusInEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQFocusEvent t1) -> IO ()
instance QfocusInEvent (QRadioButtonSc a) ((QFocusEvent t1)) where
focusInEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_focusInEvent_h cobj_x0 cobj_x1
instance QfocusOutEvent (QRadioButton ()) ((QFocusEvent t1)) where
focusOutEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_focusOutEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_focusOutEvent_h" qtc_QRadioButton_focusOutEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQFocusEvent t1) -> IO ()
instance QfocusOutEvent (QRadioButtonSc a) ((QFocusEvent t1)) where
focusOutEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_focusOutEvent_h cobj_x0 cobj_x1
instance QkeyPressEvent (QRadioButton ()) ((QKeyEvent t1)) where
keyPressEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_keyPressEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_keyPressEvent_h" qtc_QRadioButton_keyPressEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQKeyEvent t1) -> IO ()
instance QkeyPressEvent (QRadioButtonSc a) ((QKeyEvent t1)) where
keyPressEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_keyPressEvent_h cobj_x0 cobj_x1
instance QkeyReleaseEvent (QRadioButton ()) ((QKeyEvent t1)) where
keyReleaseEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_keyReleaseEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_keyReleaseEvent_h" qtc_QRadioButton_keyReleaseEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQKeyEvent t1) -> IO ()
instance QkeyReleaseEvent (QRadioButtonSc a) ((QKeyEvent t1)) where
keyReleaseEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_keyReleaseEvent_h cobj_x0 cobj_x1
instance QmousePressEvent (QRadioButton ()) ((QMouseEvent t1)) where
mousePressEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mousePressEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_mousePressEvent_h" qtc_QRadioButton_mousePressEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQMouseEvent t1) -> IO ()
instance QmousePressEvent (QRadioButtonSc a) ((QMouseEvent t1)) where
mousePressEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mousePressEvent_h cobj_x0 cobj_x1
instance QmouseReleaseEvent (QRadioButton ()) ((QMouseEvent t1)) where
mouseReleaseEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mouseReleaseEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_mouseReleaseEvent_h" qtc_QRadioButton_mouseReleaseEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQMouseEvent t1) -> IO ()
instance QmouseReleaseEvent (QRadioButtonSc a) ((QMouseEvent t1)) where
mouseReleaseEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mouseReleaseEvent_h cobj_x0 cobj_x1
instance QnextCheckState (QRadioButton ()) (()) where
nextCheckState x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_nextCheckState cobj_x0
foreign import ccall "qtc_QRadioButton_nextCheckState" qtc_QRadioButton_nextCheckState :: Ptr (TQRadioButton a) -> IO ()
instance QnextCheckState (QRadioButtonSc a) (()) where
nextCheckState x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_nextCheckState cobj_x0
instance QtimerEvent (QRadioButton ()) ((QTimerEvent t1)) where
timerEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_timerEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_timerEvent" qtc_QRadioButton_timerEvent :: Ptr (TQRadioButton a) -> Ptr (TQTimerEvent t1) -> IO ()
instance QtimerEvent (QRadioButtonSc a) ((QTimerEvent t1)) where
timerEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_timerEvent cobj_x0 cobj_x1
instance QactionEvent (QRadioButton ()) ((QActionEvent t1)) where
actionEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_actionEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_actionEvent_h" qtc_QRadioButton_actionEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQActionEvent t1) -> IO ()
instance QactionEvent (QRadioButtonSc a) ((QActionEvent t1)) where
actionEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_actionEvent_h cobj_x0 cobj_x1
instance QaddAction (QRadioButton ()) ((QAction t1)) (IO ()) where
addAction x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_addAction cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_addAction" qtc_QRadioButton_addAction :: Ptr (TQRadioButton a) -> Ptr (TQAction t1) -> IO ()
instance QaddAction (QRadioButtonSc a) ((QAction t1)) (IO ()) where
addAction x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_addAction cobj_x0 cobj_x1
instance QcloseEvent (QRadioButton ()) ((QCloseEvent t1)) where
closeEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_closeEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_closeEvent_h" qtc_QRadioButton_closeEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQCloseEvent t1) -> IO ()
instance QcloseEvent (QRadioButtonSc a) ((QCloseEvent t1)) where
closeEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_closeEvent_h cobj_x0 cobj_x1
instance QcontextMenuEvent (QRadioButton ()) ((QContextMenuEvent t1)) where
contextMenuEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_contextMenuEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_contextMenuEvent_h" qtc_QRadioButton_contextMenuEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQContextMenuEvent t1) -> IO ()
instance QcontextMenuEvent (QRadioButtonSc a) ((QContextMenuEvent t1)) where
contextMenuEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_contextMenuEvent_h cobj_x0 cobj_x1
instance Qcreate (QRadioButton ()) (()) (IO ()) where
create x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_create cobj_x0
foreign import ccall "qtc_QRadioButton_create" qtc_QRadioButton_create :: Ptr (TQRadioButton a) -> IO ()
instance Qcreate (QRadioButtonSc a) (()) (IO ()) where
create x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_create cobj_x0
instance Qcreate (QRadioButton ()) ((QVoid t1)) (IO ()) where
create x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_create1 cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_create1" qtc_QRadioButton_create1 :: Ptr (TQRadioButton a) -> Ptr (TQVoid t1) -> IO ()
instance Qcreate (QRadioButtonSc a) ((QVoid t1)) (IO ()) where
create x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_create1 cobj_x0 cobj_x1
instance Qcreate (QRadioButton ()) ((QVoid t1, Bool)) (IO ()) where
create x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_create2 cobj_x0 cobj_x1 (toCBool x2)
foreign import ccall "qtc_QRadioButton_create2" qtc_QRadioButton_create2 :: Ptr (TQRadioButton a) -> Ptr (TQVoid t1) -> CBool -> IO ()
instance Qcreate (QRadioButtonSc a) ((QVoid t1, Bool)) (IO ()) where
create x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_create2 cobj_x0 cobj_x1 (toCBool x2)
instance Qcreate (QRadioButton ()) ((QVoid t1, Bool, Bool)) (IO ()) where
create x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_create3 cobj_x0 cobj_x1 (toCBool x2) (toCBool x3)
foreign import ccall "qtc_QRadioButton_create3" qtc_QRadioButton_create3 :: Ptr (TQRadioButton a) -> Ptr (TQVoid t1) -> CBool -> CBool -> IO ()
instance Qcreate (QRadioButtonSc a) ((QVoid t1, Bool, Bool)) (IO ()) where
create x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_create3 cobj_x0 cobj_x1 (toCBool x2) (toCBool x3)
instance Qdestroy (QRadioButton ()) (()) where
destroy x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_destroy cobj_x0
foreign import ccall "qtc_QRadioButton_destroy" qtc_QRadioButton_destroy :: Ptr (TQRadioButton a) -> IO ()
instance Qdestroy (QRadioButtonSc a) (()) where
destroy x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_destroy cobj_x0
instance Qdestroy (QRadioButton ()) ((Bool)) where
destroy x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_destroy1 cobj_x0 (toCBool x1)
foreign import ccall "qtc_QRadioButton_destroy1" qtc_QRadioButton_destroy1 :: Ptr (TQRadioButton a) -> CBool -> IO ()
instance Qdestroy (QRadioButtonSc a) ((Bool)) where
destroy x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_destroy1 cobj_x0 (toCBool x1)
instance Qdestroy (QRadioButton ()) ((Bool, Bool)) where
destroy x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_destroy2 cobj_x0 (toCBool x1) (toCBool x2)
foreign import ccall "qtc_QRadioButton_destroy2" qtc_QRadioButton_destroy2 :: Ptr (TQRadioButton a) -> CBool -> CBool -> IO ()
instance Qdestroy (QRadioButtonSc a) ((Bool, Bool)) where
destroy x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_destroy2 cobj_x0 (toCBool x1) (toCBool x2)
instance QdevType (QRadioButton ()) (()) where
devType x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_devType_h cobj_x0
foreign import ccall "qtc_QRadioButton_devType_h" qtc_QRadioButton_devType_h :: Ptr (TQRadioButton a) -> IO CInt
instance QdevType (QRadioButtonSc a) (()) where
devType x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_devType_h cobj_x0
instance QdragEnterEvent (QRadioButton ()) ((QDragEnterEvent t1)) where
dragEnterEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dragEnterEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_dragEnterEvent_h" qtc_QRadioButton_dragEnterEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQDragEnterEvent t1) -> IO ()
instance QdragEnterEvent (QRadioButtonSc a) ((QDragEnterEvent t1)) where
dragEnterEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dragEnterEvent_h cobj_x0 cobj_x1
instance QdragLeaveEvent (QRadioButton ()) ((QDragLeaveEvent t1)) where
dragLeaveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dragLeaveEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_dragLeaveEvent_h" qtc_QRadioButton_dragLeaveEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQDragLeaveEvent t1) -> IO ()
instance QdragLeaveEvent (QRadioButtonSc a) ((QDragLeaveEvent t1)) where
dragLeaveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dragLeaveEvent_h cobj_x0 cobj_x1
instance QdragMoveEvent (QRadioButton ()) ((QDragMoveEvent t1)) where
dragMoveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dragMoveEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_dragMoveEvent_h" qtc_QRadioButton_dragMoveEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQDragMoveEvent t1) -> IO ()
instance QdragMoveEvent (QRadioButtonSc a) ((QDragMoveEvent t1)) where
dragMoveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dragMoveEvent_h cobj_x0 cobj_x1
instance QdropEvent (QRadioButton ()) ((QDropEvent t1)) where
dropEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dropEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_dropEvent_h" qtc_QRadioButton_dropEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQDropEvent t1) -> IO ()
instance QdropEvent (QRadioButtonSc a) ((QDropEvent t1)) where
dropEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_dropEvent_h cobj_x0 cobj_x1
instance QenabledChange (QRadioButton ()) ((Bool)) where
enabledChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_enabledChange cobj_x0 (toCBool x1)
foreign import ccall "qtc_QRadioButton_enabledChange" qtc_QRadioButton_enabledChange :: Ptr (TQRadioButton a) -> CBool -> IO ()
instance QenabledChange (QRadioButtonSc a) ((Bool)) where
enabledChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_enabledChange cobj_x0 (toCBool x1)
instance QenterEvent (QRadioButton ()) ((QEvent t1)) where
enterEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_enterEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_enterEvent_h" qtc_QRadioButton_enterEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQEvent t1) -> IO ()
instance QenterEvent (QRadioButtonSc a) ((QEvent t1)) where
enterEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_enterEvent_h cobj_x0 cobj_x1
instance QfocusNextChild (QRadioButton ()) (()) where
focusNextChild x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_focusNextChild cobj_x0
foreign import ccall "qtc_QRadioButton_focusNextChild" qtc_QRadioButton_focusNextChild :: Ptr (TQRadioButton a) -> IO CBool
instance QfocusNextChild (QRadioButtonSc a) (()) where
focusNextChild x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_focusNextChild cobj_x0
instance QfocusNextPrevChild (QRadioButton ()) ((Bool)) where
focusNextPrevChild x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_focusNextPrevChild cobj_x0 (toCBool x1)
foreign import ccall "qtc_QRadioButton_focusNextPrevChild" qtc_QRadioButton_focusNextPrevChild :: Ptr (TQRadioButton a) -> CBool -> IO CBool
instance QfocusNextPrevChild (QRadioButtonSc a) ((Bool)) where
focusNextPrevChild x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_focusNextPrevChild cobj_x0 (toCBool x1)
instance QfocusPreviousChild (QRadioButton ()) (()) where
focusPreviousChild x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_focusPreviousChild cobj_x0
foreign import ccall "qtc_QRadioButton_focusPreviousChild" qtc_QRadioButton_focusPreviousChild :: Ptr (TQRadioButton a) -> IO CBool
instance QfocusPreviousChild (QRadioButtonSc a) (()) where
focusPreviousChild x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_focusPreviousChild cobj_x0
instance QfontChange (QRadioButton ()) ((QFont t1)) where
fontChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_fontChange cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_fontChange" qtc_QRadioButton_fontChange :: Ptr (TQRadioButton a) -> Ptr (TQFont t1) -> IO ()
instance QfontChange (QRadioButtonSc a) ((QFont t1)) where
fontChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_fontChange cobj_x0 cobj_x1
instance QheightForWidth (QRadioButton ()) ((Int)) where
heightForWidth x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_heightForWidth_h cobj_x0 (toCInt x1)
foreign import ccall "qtc_QRadioButton_heightForWidth_h" qtc_QRadioButton_heightForWidth_h :: Ptr (TQRadioButton a) -> CInt -> IO CInt
instance QheightForWidth (QRadioButtonSc a) ((Int)) where
heightForWidth x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_heightForWidth_h cobj_x0 (toCInt x1)
instance QhideEvent (QRadioButton ()) ((QHideEvent t1)) where
hideEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_hideEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_hideEvent_h" qtc_QRadioButton_hideEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQHideEvent t1) -> IO ()
instance QhideEvent (QRadioButtonSc a) ((QHideEvent t1)) where
hideEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_hideEvent_h cobj_x0 cobj_x1
instance QinputMethodEvent (QRadioButton ()) ((QInputMethodEvent t1)) where
inputMethodEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_inputMethodEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_inputMethodEvent" qtc_QRadioButton_inputMethodEvent :: Ptr (TQRadioButton a) -> Ptr (TQInputMethodEvent t1) -> IO ()
instance QinputMethodEvent (QRadioButtonSc a) ((QInputMethodEvent t1)) where
inputMethodEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_inputMethodEvent cobj_x0 cobj_x1
instance QinputMethodQuery (QRadioButton ()) ((InputMethodQuery)) where
inputMethodQuery x0 (x1)
= withQVariantResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_inputMethodQuery_h cobj_x0 (toCLong $ qEnum_toInt x1)
foreign import ccall "qtc_QRadioButton_inputMethodQuery_h" qtc_QRadioButton_inputMethodQuery_h :: Ptr (TQRadioButton a) -> CLong -> IO (Ptr (TQVariant ()))
instance QinputMethodQuery (QRadioButtonSc a) ((InputMethodQuery)) where
inputMethodQuery x0 (x1)
= withQVariantResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_inputMethodQuery_h cobj_x0 (toCLong $ qEnum_toInt x1)
instance QlanguageChange (QRadioButton ()) (()) where
languageChange x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_languageChange cobj_x0
foreign import ccall "qtc_QRadioButton_languageChange" qtc_QRadioButton_languageChange :: Ptr (TQRadioButton a) -> IO ()
instance QlanguageChange (QRadioButtonSc a) (()) where
languageChange x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_languageChange cobj_x0
instance QleaveEvent (QRadioButton ()) ((QEvent t1)) where
leaveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_leaveEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_leaveEvent_h" qtc_QRadioButton_leaveEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQEvent t1) -> IO ()
instance QleaveEvent (QRadioButtonSc a) ((QEvent t1)) where
leaveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_leaveEvent_h cobj_x0 cobj_x1
instance Qmetric (QRadioButton ()) ((PaintDeviceMetric)) where
metric x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_metric cobj_x0 (toCLong $ qEnum_toInt x1)
foreign import ccall "qtc_QRadioButton_metric" qtc_QRadioButton_metric :: Ptr (TQRadioButton a) -> CLong -> IO CInt
instance Qmetric (QRadioButtonSc a) ((PaintDeviceMetric)) where
metric x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_metric cobj_x0 (toCLong $ qEnum_toInt x1)
instance QqminimumSizeHint (QRadioButton ()) (()) where
qminimumSizeHint x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_minimumSizeHint_h cobj_x0
foreign import ccall "qtc_QRadioButton_minimumSizeHint_h" qtc_QRadioButton_minimumSizeHint_h :: Ptr (TQRadioButton a) -> IO (Ptr (TQSize ()))
instance QqminimumSizeHint (QRadioButtonSc a) (()) where
qminimumSizeHint x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_minimumSizeHint_h cobj_x0
instance QminimumSizeHint (QRadioButton ()) (()) where
minimumSizeHint x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_minimumSizeHint_qth_h cobj_x0 csize_ret_w csize_ret_h
foreign import ccall "qtc_QRadioButton_minimumSizeHint_qth_h" qtc_QRadioButton_minimumSizeHint_qth_h :: Ptr (TQRadioButton a) -> Ptr CInt -> Ptr CInt -> IO ()
instance QminimumSizeHint (QRadioButtonSc a) (()) where
minimumSizeHint x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_minimumSizeHint_qth_h cobj_x0 csize_ret_w csize_ret_h
instance QmouseDoubleClickEvent (QRadioButton ()) ((QMouseEvent t1)) where
mouseDoubleClickEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mouseDoubleClickEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_mouseDoubleClickEvent_h" qtc_QRadioButton_mouseDoubleClickEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQMouseEvent t1) -> IO ()
instance QmouseDoubleClickEvent (QRadioButtonSc a) ((QMouseEvent t1)) where
mouseDoubleClickEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_mouseDoubleClickEvent_h cobj_x0 cobj_x1
instance Qmove (QRadioButton ()) ((Int, Int)) where
move x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_move1 cobj_x0 (toCInt x1) (toCInt x2)
foreign import ccall "qtc_QRadioButton_move1" qtc_QRadioButton_move1 :: Ptr (TQRadioButton a) -> CInt -> CInt -> IO ()
instance Qmove (QRadioButtonSc a) ((Int, Int)) where
move x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_move1 cobj_x0 (toCInt x1) (toCInt x2)
instance Qmove (QRadioButton ()) ((Point)) where
move x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCPoint x1 $ \cpoint_x1_x cpoint_x1_y ->
qtc_QRadioButton_move_qth cobj_x0 cpoint_x1_x cpoint_x1_y
foreign import ccall "qtc_QRadioButton_move_qth" qtc_QRadioButton_move_qth :: Ptr (TQRadioButton a) -> CInt -> CInt -> IO ()
instance Qmove (QRadioButtonSc a) ((Point)) where
move x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCPoint x1 $ \cpoint_x1_x cpoint_x1_y ->
qtc_QRadioButton_move_qth cobj_x0 cpoint_x1_x cpoint_x1_y
instance Qqmove (QRadioButton ()) ((QPoint t1)) where
qmove x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_move cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_move" qtc_QRadioButton_move :: Ptr (TQRadioButton a) -> Ptr (TQPoint t1) -> IO ()
instance Qqmove (QRadioButtonSc a) ((QPoint t1)) where
qmove x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_move cobj_x0 cobj_x1
instance QmoveEvent (QRadioButton ()) ((QMoveEvent t1)) where
moveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_moveEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_moveEvent_h" qtc_QRadioButton_moveEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQMoveEvent t1) -> IO ()
instance QmoveEvent (QRadioButtonSc a) ((QMoveEvent t1)) where
moveEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_moveEvent_h cobj_x0 cobj_x1
instance QpaintEngine (QRadioButton ()) (()) where
paintEngine x0 ()
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_paintEngine_h cobj_x0
foreign import ccall "qtc_QRadioButton_paintEngine_h" qtc_QRadioButton_paintEngine_h :: Ptr (TQRadioButton a) -> IO (Ptr (TQPaintEngine ()))
instance QpaintEngine (QRadioButtonSc a) (()) where
paintEngine x0 ()
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_paintEngine_h cobj_x0
instance QpaletteChange (QRadioButton ()) ((QPalette t1)) where
paletteChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_paletteChange cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_paletteChange" qtc_QRadioButton_paletteChange :: Ptr (TQRadioButton a) -> Ptr (TQPalette t1) -> IO ()
instance QpaletteChange (QRadioButtonSc a) ((QPalette t1)) where
paletteChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_paletteChange cobj_x0 cobj_x1
instance Qrepaint (QRadioButton ()) (()) where
repaint x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_repaint cobj_x0
foreign import ccall "qtc_QRadioButton_repaint" qtc_QRadioButton_repaint :: Ptr (TQRadioButton a) -> IO ()
instance Qrepaint (QRadioButtonSc a) (()) where
repaint x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_repaint cobj_x0
instance Qrepaint (QRadioButton ()) ((Int, Int, Int, Int)) where
repaint x0 (x1, x2, x3, x4)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_repaint2 cobj_x0 (toCInt x1) (toCInt x2) (toCInt x3) (toCInt x4)
foreign import ccall "qtc_QRadioButton_repaint2" qtc_QRadioButton_repaint2 :: Ptr (TQRadioButton a) -> CInt -> CInt -> CInt -> CInt -> IO ()
instance Qrepaint (QRadioButtonSc a) ((Int, Int, Int, Int)) where
repaint x0 (x1, x2, x3, x4)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_repaint2 cobj_x0 (toCInt x1) (toCInt x2) (toCInt x3) (toCInt x4)
instance Qrepaint (QRadioButton ()) ((QRegion t1)) where
repaint x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_repaint1 cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_repaint1" qtc_QRadioButton_repaint1 :: Ptr (TQRadioButton a) -> Ptr (TQRegion t1) -> IO ()
instance Qrepaint (QRadioButtonSc a) ((QRegion t1)) where
repaint x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_repaint1 cobj_x0 cobj_x1
instance QresetInputContext (QRadioButton ()) (()) where
resetInputContext x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_resetInputContext cobj_x0
foreign import ccall "qtc_QRadioButton_resetInputContext" qtc_QRadioButton_resetInputContext :: Ptr (TQRadioButton a) -> IO ()
instance QresetInputContext (QRadioButtonSc a) (()) where
resetInputContext x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_resetInputContext cobj_x0
instance Qresize (QRadioButton ()) ((Int, Int)) (IO ()) where
resize x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_resize1 cobj_x0 (toCInt x1) (toCInt x2)
foreign import ccall "qtc_QRadioButton_resize1" qtc_QRadioButton_resize1 :: Ptr (TQRadioButton a) -> CInt -> CInt -> IO ()
instance Qresize (QRadioButtonSc a) ((Int, Int)) (IO ()) where
resize x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_resize1 cobj_x0 (toCInt x1) (toCInt x2)
instance Qqresize (QRadioButton ()) ((QSize t1)) where
qresize x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_resize cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_resize" qtc_QRadioButton_resize :: Ptr (TQRadioButton a) -> Ptr (TQSize t1) -> IO ()
instance Qqresize (QRadioButtonSc a) ((QSize t1)) where
qresize x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_resize cobj_x0 cobj_x1
instance Qresize (QRadioButton ()) ((Size)) (IO ()) where
resize x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCSize x1 $ \csize_x1_w csize_x1_h ->
qtc_QRadioButton_resize_qth cobj_x0 csize_x1_w csize_x1_h
foreign import ccall "qtc_QRadioButton_resize_qth" qtc_QRadioButton_resize_qth :: Ptr (TQRadioButton a) -> CInt -> CInt -> IO ()
instance Qresize (QRadioButtonSc a) ((Size)) (IO ()) where
resize x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCSize x1 $ \csize_x1_w csize_x1_h ->
qtc_QRadioButton_resize_qth cobj_x0 csize_x1_w csize_x1_h
instance QresizeEvent (QRadioButton ()) ((QResizeEvent t1)) where
resizeEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_resizeEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_resizeEvent_h" qtc_QRadioButton_resizeEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQResizeEvent t1) -> IO ()
instance QresizeEvent (QRadioButtonSc a) ((QResizeEvent t1)) where
resizeEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_resizeEvent_h cobj_x0 cobj_x1
instance QsetGeometry (QRadioButton ()) ((Int, Int, Int, Int)) where
setGeometry x0 (x1, x2, x3, x4)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_setGeometry1 cobj_x0 (toCInt x1) (toCInt x2) (toCInt x3) (toCInt x4)
foreign import ccall "qtc_QRadioButton_setGeometry1" qtc_QRadioButton_setGeometry1 :: Ptr (TQRadioButton a) -> CInt -> CInt -> CInt -> CInt -> IO ()
instance QsetGeometry (QRadioButtonSc a) ((Int, Int, Int, Int)) where
setGeometry x0 (x1, x2, x3, x4)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_setGeometry1 cobj_x0 (toCInt x1) (toCInt x2) (toCInt x3) (toCInt x4)
instance QqsetGeometry (QRadioButton ()) ((QRect t1)) where
qsetGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_setGeometry cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_setGeometry" qtc_QRadioButton_setGeometry :: Ptr (TQRadioButton a) -> Ptr (TQRect t1) -> IO ()
instance QqsetGeometry (QRadioButtonSc a) ((QRect t1)) where
qsetGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_setGeometry cobj_x0 cobj_x1
instance QsetGeometry (QRadioButton ()) ((Rect)) where
setGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCRect x1 $ \crect_x1_x crect_x1_y crect_x1_w crect_x1_h ->
qtc_QRadioButton_setGeometry_qth cobj_x0 crect_x1_x crect_x1_y crect_x1_w crect_x1_h
foreign import ccall "qtc_QRadioButton_setGeometry_qth" qtc_QRadioButton_setGeometry_qth :: Ptr (TQRadioButton a) -> CInt -> CInt -> CInt -> CInt -> IO ()
instance QsetGeometry (QRadioButtonSc a) ((Rect)) where
setGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCRect x1 $ \crect_x1_x crect_x1_y crect_x1_w crect_x1_h ->
qtc_QRadioButton_setGeometry_qth cobj_x0 crect_x1_x crect_x1_y crect_x1_w crect_x1_h
instance QsetMouseTracking (QRadioButton ()) ((Bool)) where
setMouseTracking x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_setMouseTracking cobj_x0 (toCBool x1)
foreign import ccall "qtc_QRadioButton_setMouseTracking" qtc_QRadioButton_setMouseTracking :: Ptr (TQRadioButton a) -> CBool -> IO ()
instance QsetMouseTracking (QRadioButtonSc a) ((Bool)) where
setMouseTracking x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_setMouseTracking cobj_x0 (toCBool x1)
instance QsetVisible (QRadioButton ()) ((Bool)) where
setVisible x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_setVisible_h cobj_x0 (toCBool x1)
foreign import ccall "qtc_QRadioButton_setVisible_h" qtc_QRadioButton_setVisible_h :: Ptr (TQRadioButton a) -> CBool -> IO ()
instance QsetVisible (QRadioButtonSc a) ((Bool)) where
setVisible x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_setVisible_h cobj_x0 (toCBool x1)
instance QshowEvent (QRadioButton ()) ((QShowEvent t1)) where
showEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_showEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_showEvent_h" qtc_QRadioButton_showEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQShowEvent t1) -> IO ()
instance QshowEvent (QRadioButtonSc a) ((QShowEvent t1)) where
showEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_showEvent_h cobj_x0 cobj_x1
instance QtabletEvent (QRadioButton ()) ((QTabletEvent t1)) where
tabletEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_tabletEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_tabletEvent_h" qtc_QRadioButton_tabletEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQTabletEvent t1) -> IO ()
instance QtabletEvent (QRadioButtonSc a) ((QTabletEvent t1)) where
tabletEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_tabletEvent_h cobj_x0 cobj_x1
instance QupdateMicroFocus (QRadioButton ()) (()) where
updateMicroFocus x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_updateMicroFocus cobj_x0
foreign import ccall "qtc_QRadioButton_updateMicroFocus" qtc_QRadioButton_updateMicroFocus :: Ptr (TQRadioButton a) -> IO ()
instance QupdateMicroFocus (QRadioButtonSc a) (()) where
updateMicroFocus x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_updateMicroFocus cobj_x0
instance QwheelEvent (QRadioButton ()) ((QWheelEvent t1)) where
wheelEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_wheelEvent_h cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_wheelEvent_h" qtc_QRadioButton_wheelEvent_h :: Ptr (TQRadioButton a) -> Ptr (TQWheelEvent t1) -> IO ()
instance QwheelEvent (QRadioButtonSc a) ((QWheelEvent t1)) where
wheelEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_wheelEvent_h cobj_x0 cobj_x1
instance QwindowActivationChange (QRadioButton ()) ((Bool)) where
windowActivationChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_windowActivationChange cobj_x0 (toCBool x1)
foreign import ccall "qtc_QRadioButton_windowActivationChange" qtc_QRadioButton_windowActivationChange :: Ptr (TQRadioButton a) -> CBool -> IO ()
instance QwindowActivationChange (QRadioButtonSc a) ((Bool)) where
windowActivationChange x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_windowActivationChange cobj_x0 (toCBool x1)
instance QchildEvent (QRadioButton ()) ((QChildEvent t1)) where
childEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_childEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_childEvent" qtc_QRadioButton_childEvent :: Ptr (TQRadioButton a) -> Ptr (TQChildEvent t1) -> IO ()
instance QchildEvent (QRadioButtonSc a) ((QChildEvent t1)) where
childEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_childEvent cobj_x0 cobj_x1
instance QconnectNotify (QRadioButton ()) ((String)) where
connectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QRadioButton_connectNotify cobj_x0 cstr_x1
foreign import ccall "qtc_QRadioButton_connectNotify" qtc_QRadioButton_connectNotify :: Ptr (TQRadioButton a) -> CWString -> IO ()
instance QconnectNotify (QRadioButtonSc a) ((String)) where
connectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QRadioButton_connectNotify cobj_x0 cstr_x1
instance QcustomEvent (QRadioButton ()) ((QEvent t1)) where
customEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_customEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QRadioButton_customEvent" qtc_QRadioButton_customEvent :: Ptr (TQRadioButton a) -> Ptr (TQEvent t1) -> IO ()
instance QcustomEvent (QRadioButtonSc a) ((QEvent t1)) where
customEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QRadioButton_customEvent cobj_x0 cobj_x1
instance QdisconnectNotify (QRadioButton ()) ((String)) where
disconnectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QRadioButton_disconnectNotify cobj_x0 cstr_x1
foreign import ccall "qtc_QRadioButton_disconnectNotify" qtc_QRadioButton_disconnectNotify :: Ptr (TQRadioButton a) -> CWString -> IO ()
instance QdisconnectNotify (QRadioButtonSc a) ((String)) where
disconnectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QRadioButton_disconnectNotify cobj_x0 cstr_x1
instance QeventFilter (QRadioButton ()) ((QObject t1, QEvent t2)) where
eventFilter x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QRadioButton_eventFilter_h cobj_x0 cobj_x1 cobj_x2
foreign import ccall "qtc_QRadioButton_eventFilter_h" qtc_QRadioButton_eventFilter_h :: Ptr (TQRadioButton a) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO CBool
instance QeventFilter (QRadioButtonSc a) ((QObject t1, QEvent t2)) where
eventFilter x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QRadioButton_eventFilter_h cobj_x0 cobj_x1 cobj_x2
instance Qreceivers (QRadioButton ()) ((String)) where
receivers x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QRadioButton_receivers cobj_x0 cstr_x1
foreign import ccall "qtc_QRadioButton_receivers" qtc_QRadioButton_receivers :: Ptr (TQRadioButton a) -> CWString -> IO CInt
instance Qreceivers (QRadioButtonSc a) ((String)) where
receivers x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QRadioButton_receivers cobj_x0 cstr_x1
instance Qsender (QRadioButton ()) (()) where
sender x0 ()
= withQObjectResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_sender cobj_x0
foreign import ccall "qtc_QRadioButton_sender" qtc_QRadioButton_sender :: Ptr (TQRadioButton a) -> IO (Ptr (TQObject ()))
instance Qsender (QRadioButtonSc a) (()) where
sender x0 ()
= withQObjectResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QRadioButton_sender cobj_x0
|
keera-studios/hsQt
|
Qtc/Gui/QRadioButton.hs
|
bsd-2-clause
| 47,316 | 0 | 14 | 7,528 | 15,099 | 7,657 | 7,442 | -1 | -1 |
-----------------------------------------------------------------------------
-- |
-- Module : Haddock.Backends.Html.Themes
-- Copyright : (c) Mark Lentczner 2010
-- License : BSD-like
--
-- Maintainer : [email protected]
-- Stability : experimental
-- Portability : portable
-----------------------------------------------------------------------------
module Haddock.Backends.Xhtml.Themes (
Themes,
getThemes,
cssFiles, styleSheet
)
where
import Haddock.Options
import Haddock.Backends.Xhtml.Types ( BaseURL, withBaseURL )
import Control.Monad (liftM)
import Data.Char (toLower)
import Data.Either (lefts, rights)
import Data.List (nub)
import Data.Maybe (isJust, listToMaybe)
import System.Directory
import System.FilePath
import Text.XHtml hiding ( name, title, p, quote, (</>) )
import qualified Text.XHtml as XHtml
--------------------------------------------------------------------------------
-- * CSS Themes
--------------------------------------------------------------------------------
data Theme = Theme {
themeName :: String,
themeHref :: String,
themeFiles :: [FilePath]
}
type Themes = [Theme]
type PossibleTheme = Either String Theme
type PossibleThemes = Either String Themes
-- | Find a theme by name (case insensitive match)
findTheme :: String -> Themes -> Maybe Theme
findTheme s = listToMaybe . filter ((== ls).lower.themeName)
where lower = map toLower
ls = lower s
-- | Standard theme used by default
standardTheme :: FilePath -> IO PossibleThemes
standardTheme libDir = liftM (liftEither (take 1)) (defaultThemes libDir)
-- | Default themes that are part of Haddock; added with @--built-in-themes@
-- The first theme in this list is considered the standard theme.
-- Themes are "discovered" by scanning the html sub-dir of the libDir,
-- and looking for directories with the extension .theme or .std-theme.
-- The later is, obviously, the standard theme.
defaultThemes :: FilePath -> IO PossibleThemes
defaultThemes libDir = do
themeDirs <- getDirectoryItems (libDir </> "html")
themes <- mapM directoryTheme $ discoverThemes themeDirs
return $ sequenceEither themes
where
discoverThemes paths =
filterExt ".std-theme" paths ++ filterExt ".theme" paths
filterExt ext = filter ((== ext).takeExtension)
-- | Build a theme from a single .css file
singleFileTheme :: FilePath -> IO PossibleTheme
singleFileTheme path =
if isCssFilePath path
then retRight $ Theme name file [path]
else errMessage "File extension isn't .css" path
where
name = takeBaseName path
file = takeFileName path
-- | Build a theme from a directory
directoryTheme :: FilePath -> IO PossibleTheme
directoryTheme path = do
items <- getDirectoryItems path
case filter isCssFilePath items of
[cf] -> retRight $ Theme (takeBaseName path) (takeFileName cf) items
[] -> errMessage "No .css file in theme directory" path
_ -> errMessage "More than one .css file in theme directory" path
-- | Check if we have a built in theme
doesBuiltInExist :: IO PossibleThemes -> String -> IO Bool
doesBuiltInExist pts s = fmap (either (const False) test) pts
where test = isJust . findTheme s
-- | Find a built in theme
builtInTheme :: IO PossibleThemes -> String -> IO PossibleTheme
builtInTheme pts s = either Left fetch <$> pts
where fetch = maybe (Left ("Unknown theme: " ++ s)) Right . findTheme s
--------------------------------------------------------------------------------
-- * CSS Theme Arguments
--------------------------------------------------------------------------------
-- | Process input flags for CSS Theme arguments
getThemes :: FilePath -> [Flag] -> IO PossibleThemes
getThemes libDir flags =
liftM concatEither (mapM themeFlag flags) >>= someTheme
where
themeFlag :: Flag -> IO (Either String Themes)
themeFlag (Flag_CSS path) = (liftM . liftEither) (:[]) (theme path)
themeFlag (Flag_BuiltInThemes) = builtIns
themeFlag _ = retRight []
theme :: FilePath -> IO PossibleTheme
theme path = pick path
[(doesFileExist, singleFileTheme),
(doesDirectoryExist, directoryTheme),
(doesBuiltInExist builtIns, builtInTheme builtIns)]
"Theme not found"
pick :: FilePath
-> [(FilePath -> IO Bool, FilePath -> IO PossibleTheme)] -> String
-> IO PossibleTheme
pick path [] msg = errMessage msg path
pick path ((test,build):opts) msg = do
pass <- test path
if pass then build path else pick path opts msg
someTheme :: Either String Themes -> IO (Either String Themes)
someTheme (Right []) = standardTheme libDir
someTheme est = return est
builtIns = defaultThemes libDir
errMessage :: String -> FilePath -> IO (Either String a)
errMessage msg path = return (Left msg')
where msg' = "Error: " ++ msg ++ ": \"" ++ path ++ "\"\n"
retRight :: a -> IO (Either String a)
retRight = return . Right
--------------------------------------------------------------------------------
-- * File Utilities
--------------------------------------------------------------------------------
getDirectoryItems :: FilePath -> IO [FilePath]
getDirectoryItems path =
map (combine path) . filter notDot <$> getDirectoryContents path
where notDot s = s /= "." && s /= ".."
isCssFilePath :: FilePath -> Bool
isCssFilePath path = takeExtension path == ".css"
--------------------------------------------------------------------------------
-- * Style Sheet Utilities
--------------------------------------------------------------------------------
cssFiles :: Themes -> [String]
cssFiles ts = nub $ concatMap themeFiles ts
styleSheet :: BaseURL -> Themes -> Html
styleSheet base_url ts = toHtml $ zipWith mkLink rels ts
where
rels = "stylesheet" : repeat "alternate stylesheet"
mkLink aRel t =
thelink
! [ href (withBaseURL base_url (themeHref t)), rel aRel, thetype "text/css",
XHtml.title (themeName t)
]
<< noHtml
--------------------------------------------------------------------------------
-- * Either Utilities
--------------------------------------------------------------------------------
-- These three routines are here because Haddock does not have access to the
-- Control.Monad.Error module which supplies the Functor and Monad instances
-- for Either String.
sequenceEither :: [Either a b] -> Either a [b]
sequenceEither es = maybe (Right $ rights es) Left (listToMaybe (lefts es))
liftEither :: (b -> c) -> Either a b -> Either a c
liftEither f = either Left (Right . f)
concatEither :: [Either a [b]] -> Either a [b]
concatEither = liftEither concat . sequenceEither
|
haskell/haddock
|
haddock-api/src/Haddock/Backends/Xhtml/Themes.hs
|
bsd-2-clause
| 6,722 | 0 | 14 | 1,227 | 1,602 | 844 | 758 | 107 | 6 |
module Prelude.Minimal (
-- * Basic data types
-- ** @Bool@
Bool(False, True),
(&&), (||), not, otherwise,
-- ** @Maybe@
Maybe(Nothing, Just),
fromMaybe, isNothing, isJust,
-- ** @Either@
Either(Left, Right),
isLeft, isRight,
-- ** @Tuple@
fst, snd, curry, uncurry,
-- ** @List@
head, last, tail, init, null, length, (!!),
reverse,
-- ** @Ordering@
Ordering(LT, EQ, GT),
-- * Type Classes
-- ** @Category@
Category(id, (.)),
-- ** @Monoid@
Monoid(mempty, mappend, mconcat),
(<>),
-- ** @Functor@
Functor(fmap, (<$)),
void, (<$>), ($>),
-- ** @Applicative@
Applicative(pure, (<*>), (*>), (<*)),
(<**>),
-- ** @Monad@
Monad((>>=), (>>)),
(=<<), (>=>), (<=<),join,
-- ** @Alternative@
Alternative(empty, (<|>), some, many),
optional, asum,
-- ** @MonadPlus@
MonadPlus (mzero, mplus),
guard, msum, mfilter,
-- ** @Foldable@
Foldable(fold, foldMap, foldr, foldr', foldl, foldl'),
toList, concat, concatMap,
and, or, any, all, sum, product, maximum, maximumBy,
minimum, minimumBy, elem, notElem, find,
-- ** @Traversable@
Traversable(traverse, sequenceA),
for,
-- ** Basic type classes
Eq((==), (/=)),
Ord(compare, (<), (<=), (>=), (>), max, min),
Enum(succ, pred, toEnum, fromEnum, enumFrom, enumFromThen,
enumFromTo, enumFromThenTo),
Bounded(minBound, maxBound),
-- * Miscellaneous functions
const, flip, ($), until,
asTypeOf, error, undefined,
seq, ($!),
-- * @Char@ and @String@
Char, String,
-- ** Converting to @String@
ShowS,
Show(showsPrec, showList, show),
shows,
showChar, showString, showParen,
-- ** Converting from @String@
ReadS,
Read(readsPrec, readList),
reads, readParen, read, lex,
-- * Basic Input and output
IO,
-- ** Simple I\/O operations
-- All I/O functions defined here are character oriented. The
-- treatment of the newline character will vary on different systems.
-- For example, two characters of input, return and linefeed, may
-- read as a single newline character. These functions cannot be
-- used portably for binary I/O.
-- *** Output functions
putChar,
putStr, putStrLn, print,
-- *** Input functions
getChar,
getLine, getContents, interact,
-- *** Files
FilePath,
readFile, writeFile, appendFile, readIO, readLn,
-- ** Exception handling in the I\/O monad
IOError, ioError, userError,
-- * Numbers
-- ** Numeric types
Int, Integer, Float, Double,
Rational,
-- ** Numeric type classes
Num((+), (-), (*), negate, abs, signum, fromInteger),
Real(toRational),
Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
Fractional((/), recip, fromRational),
Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
RealFrac(properFraction, truncate, round, ceiling, floor),
RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
encodeFloat, exponent, significand, scaleFloat, isNaN,
isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),
-- ** Numeric functions
subtract, even, odd, gcd, lcm, (^), (^^),
fromIntegral, realToFrac,
) where
import GHC.Base
import Data.Maybe
import Data.Either
import Data.Tuple
import Data.List
import Control.Category (Category(..))
import Data.Monoid
import Data.Functor
import Control.Applicative
import Control.Monad
import Data.Foldable
import Data.Traversable
import GHC.Enum
import GHC.Num
import GHC.Real
import GHC.Float
import GHC.Show
import Text.Read
import System.IO
import System.IO.Error
import Prelude (($!), seq)
|
duncanburke/prelude-minimal
|
Prelude/Minimal.hs
|
bsd-2-clause
| 3,848 | 0 | 6 | 932 | 910 | 703 | 207 | 141 | 0 |
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE OverloadedStrings #-}
module Main ( main ) where
import Control.Exception ( bracket )
import Data.Maybe ( fromMaybe )
import qualified Data.Set as Set
import Distribution.Nixpkgs.Fetch
import Distribution.Nixpkgs.Haskell
import Distribution.Nixpkgs.Haskell.FromCabal
import Distribution.Nixpkgs.Haskell.FromCabal.Configuration.GHC7102
import Distribution.Nixpkgs.Meta
import Distribution.PackageDescription ( FlagName(..), FlagAssignment )
import Distribution.Simple.Utils ( lowercase )
import Internal.HaskellPackage
import Internal.Lens
import Internal.Version
import Internal.PrettyPrinting hiding ( (<>) )
import Language.Nix
import Options.Applicative
import System.IO ( hFlush, stdout, stderr )
import qualified Text.PrettyPrint.ANSI.Leijen as P2 hiding ( (<$>), (<>) )
-- import Text.Show.Pretty
data Options = Options
{ optSha256 :: Maybe String
, optMaintainer :: [String]
, optPlatform :: [String]
, optHaddock :: Bool
, optDoCheck :: Bool
, optJailbreak :: Bool
, optRevision :: Maybe String
, optHyperlinkSource :: Bool
, optEnableLibraryProfiling :: Bool
, optEnableExecutableProfiling :: Bool
, optEnableProfiling :: Maybe Bool
, optHackageDb :: Maybe FilePath
, optNixShellOutput :: Bool
, optFlags :: [String]
, optUrl :: String
}
deriving (Show)
options :: Parser Options
options = Options
<$> optional (strOption $ long "sha256" <> metavar "HASH" <> help "sha256 hash of source tarball")
<*> many (strOption $ long "maintainer" <> metavar "MAINTAINER" <> help "maintainer of this package (may be specified multiple times)")
<*> many (strOption $ long "platform" <> metavar "PLATFORM" <> help "supported build platforms (may be specified multiple times)")
<*> flag True False (long "no-haddock" <> help "don't run Haddock when building this package")
<*> flag True False (long "no-check" <> help "don't run regression test suites of this package")
<*> switch (long "jailbreak" <> help "disregard version restrictions on build inputs")
<*> optional (strOption $ long "revision" <> help "revision to use when fetching from VCS")
<*> flag True False (long "no-hyperlink-source" <> help "don't generate pretty-printed source code for the documentation")
<*> switch (long "enable-library-profiling" <> help "enable library profiling in the generated build")
<*> switch (long "enable-executable-profiling" <> help "enable executable profiling in the generated build")
<*> optional (switch (long "enable-profiling" <> help "enable both library and executable profiling in the generated build"))
<*> optional (strOption $ long "hackage-db" <> metavar "PATH" <> help "path to the local hackage db in tar format")
<*> switch (long "shell" <> help "generate output suitable for nix-shell")
<*> many (strOption $ short 'f' <> long "flag" <> help "Cabal flag (may be specified multiple times)")
<*> strArgument (metavar "URI")
pinfo :: ParserInfo Options
pinfo = info
( helper
<*> infoOption ("cabal2nix " ++ version) (long "version" <> help "Show version number")
<*> options
)
( fullDesc
<> header "cabal2nix converts Cabal files into build instructions for Nix."
<> progDescDoc (Just (P2.vcat
[ P2.text ""
, P2.text "Recognized URI schemes:"
, P2.text ""
, P2.text " cabal://pkgname-pkgversion download the specified package from Hackage"
, P2.text " cabal://pkgname download latest version of this package from Hackage"
, P2.text " file:///local/path load the Cabal file from the local disk"
, P2.text " /local/path abbreviated version of file URI"
, P2.text " <git/svn/bzr/hg URL> download the source from the specified repository"
, P2.text ""
, P2.fillSep (map P2.text (words ( "If the URI refers to a cabal file, information for building the package "
++ "will be retrieved from that file, but hackage will be used as a source "
++ "for the derivation. Otherwise, the supplied URI will be used to as the "
++ "souce for the derivation and the information is taken from the cabal file "
++ "at the root of the downloaded source."
)))
]))
)
main :: IO ()
main = bracket (return ()) (\() -> hFlush stdout >> hFlush stderr) $ \() -> do
Options {..} <- execParser pinfo
pkg <- getPackage optHackageDb $ Source optUrl (fromMaybe "" optRevision) (maybe UnknownHash Guess optSha256)
let deriv :: Derivation
deriv = fromGenericPackageDescription (const True)
(\i -> Just (create binding (i, create path [i])))
(platform ghc7102)
(compilerInfo ghc7102)
(readFlagList optFlags)
[]
(pkgCabal pkg)
& src .~ pkgSource pkg
& runHaddock .~ optHaddock
& jailbreak .~ optJailbreak
& hyperlinkSource .~ optHyperlinkSource
& enableLibraryProfiling .~ (fromMaybe False optEnableProfiling || optEnableLibraryProfiling)
& enableExecutableProfiling .~ (fromMaybe False optEnableProfiling || optEnableExecutableProfiling)
& metaSection.maintainers .~ Set.fromList (map (create ident) optMaintainer)
& metaSection.platforms .~ Set.fromList optPlatform
& doCheck &&~ optDoCheck
& extraFunctionArgs . contains "stdenv" .~ True
shell :: Doc
shell = vcat
[ text "{ nixpkgs ? import <nixpkgs> {}, compiler ? \"default\" }:"
, text ""
, text "let"
, text ""
, text " inherit (nixpkgs) pkgs;"
, text ""
, hcat [ text " f = ", pPrint deriv, semi ]
, text ""
, text " haskellPackages = if compiler == \"default\""
, text " then pkgs.haskellPackages"
, text " else pkgs.haskell.packages.${compiler};"
, text ""
, text " drv = haskellPackages.callPackage f {};"
, text ""
, text "in"
, text ""
, text " if pkgs.lib.inNixShell then drv.env else drv"
]
-- putStrLn $ ppShow deriv
print (if optNixShellOutput then shell else pPrint deriv)
readFlagList :: [String] -> FlagAssignment
readFlagList = map tagWithValue
where tagWithValue ('-':fname) = (FlagName (lowercase fname), False)
tagWithValue fname = (FlagName (lowercase fname), True)
|
psibi/cabal2nix
|
src/cabal2nix.hs
|
bsd-3-clause
| 7,335 | 0 | 41 | 2,415 | 1,465 | 764 | 701 | -1 | -1 |
{-# LANGUAGE FlexibleContexts #-}
{-|
Module : PolyPaver.Eval
Description : evaluation of a formula over a box
Copyright : (c) Jan Duracz, Michal Konecny
License : BSD3
Maintainer : [email protected]
Stability : experimental
Portability : portable
Evaluation of a formula over a box.
-}
module PolyPaver.Eval
(
prepareForm,
prepareTerm,
evalForm,
evalTerm,
termIsIntegerType
)
where
import PolyPaver.Form
import PolyPaver.Subterms
import PolyPaver.Vars
import PolyPaver.APBox
import qualified PolyPaver.Logic as L
import qualified Numeric.ER.Real.Approx as RA
import Numeric.ER.Real.DefaultRepr
import Numeric.ER.RnToRm.DefaultRepr
import qualified Numeric.ER.RnToRm.Approx as FA
import qualified Numeric.ER.RnToRm.UnitDom.Approx as UFA
import qualified Numeric.ER.Real.Approx.Elementary as RAEL
import Numeric.ER.BasicTypes
import qualified Numeric.ER.BasicTypes.DomainBox as DBox
import Numeric.ER.Misc
import qualified Data.Set as Set
import qualified Data.Map as Map
import qualified Data.IntMap as IMap
import qualified Data.Ratio as Q
import Data.Hashable (Hashable, hash)
import qualified Data.Strict.Tuple as SP
prepareForm ::
(HasDefaultValue l, Eq l, Hashable l) =>
Form l -> Form Int
prepareForm form =
addHashesInForm $ expandRoundedOpsInForm form
prepareTerm ::
(HasDefaultValue l, Eq l, Hashable l) =>
Term l -> Term TermHash
prepareTerm term =
addHashesInTerm $ expandRoundedOpsInTerm term
{-|
Evaluate the truth value of a formula over a box.
Also, compute a formula that is equivalent to the original formula over this box but possibly simpler.
-}
evalForm ::
(L.TruthValue tv Int) =>
Int {-^ polynomial degree limit -} ->
Int {-^ polynomial term size limit -} ->
EffortIndex {-^ effort index for regulating model error -} ->
IRA BM {-^ minIntegrationStepSize -} ->
APBox BM {-^ domains of variables -} ->
-- (Int,Int) {-^ precision of emulated FP operations -} ->
Form TermHash {-^ form to evaluate, with hashes in all sub-terms -} ->
(tv,
(Form (Maybe (IRA BM)))) {-^ form with added range bounds in all terms -}
evalForm maxdeg maxsize ix minIntegrationStepSize apb@(APBox _ isIntVarMap _) origForm =
SP.snd $! evForm IMap.empty origForm
where
evTerm = evalTerm maxdeg maxsize ix minIntegrationStepSize apb
evForm prevValuesMap form =
case form of
Not arg -> evOp1 Not L.not arg
Or left right -> evOp2 Or (L.||) left right
And left right -> evOp2 And (L.&&) left right
Implies left right -> evOp2 Implies (L.~>) left right
Le lab left right -> evLess form lab left right
Leq lab left right -> evLeq form lab left right
Ge lab left right -> evLess form lab right left
Geq lab left right -> evLeq form lab right left
Eq lab left right ->
evForm prevValuesMap $ And
(Leq (lab ++ "<=") left right)
(Leq (lab ++ ">=") right left)
Neq lab left right ->
evForm prevValuesMap $ Or
(Le (lab ++ "<") left right)
(Le (lab ++ ">") right left)
ContainedIn lab left right ->
evOpT2 form True (ContainedIn lab) (\formWR -> flip $ L.includes lab formWR apb) left right
IsRange lab t lower upper ->
evForm prevValuesMap $ (Leq (lab ++ "LO") lower t) /\ (Leq (lab ++ "HI") t upper)
IsIntRange lab t lower upper ->
evForm prevValuesMap $ (IsInt lab t) /\ (IsRange lab t lower upper)
IsInt lab t@(Term (_,l)) ->
prevValuesMap SP.:!:
((L.fromBool lab l apb $ termIsIntegerType isIntVarMap t),
(IsInt lab tWithRanges))
where
(_ SP.:!: (_tVal, tWithRanges)) = evTerm False prevValuesMap t
where
evOp1 op opTV arg =
(newValuesMap SP.:!: (opTV argTV, op argWithRanges))
where
(newValuesMap SP.:!: (argTV, argWithRanges)) = evForm prevValuesMap arg
evOp2 op opTV left right =
(newValuesMap SP.:!: (opTV leftTV rightTV, op leftWithRanges rightWithRanges))
where
(intermValuesMap SP.:!: (leftTV, leftWithRanges)) = evForm prevValuesMap left
(newValuesMap SP.:!: (rightTV, rightWithRanges)) = evForm intermValuesMap right
evOpT2 form2 rightNeedsInnerRounding op opTV left right =
(newValuesMap SP.:!: (tv, formWithRanges))
where
tv = opTV form2 leftVal rightVal
formWithRanges = op leftWithRanges rightWithRanges
(intermValuesMap SP.:!: (leftVal, leftWithRanges)) =
evTerm False prevValuesMap left
(newValuesMap SP.:!: (rightVal, rightWithRanges)) =
evTerm rightNeedsInnerRounding intermValuesMap right
evLess form2 = evLessLeq form2 False Le L.less
evLeq form2 = evLessLeq form2 True Leq L.leq
evLessLeq _ isLeq formOp _logicOp lab (Term (PlusInfinity, l)) (Term (PlusInfinity, _)) =
(prevValuesMap SP.:!:
(L.fromBool lab l apb isLeq,
formOp lab plusInfinityTermWithRange plusInfinityTermWithRange))
evLessLeq _ isLeq formOp _logicOp lab (Term (MinusInfinity, l)) (Term (MinusInfinity, _)) =
(prevValuesMap SP.:!:
(L.fromBool lab l apb isLeq,
formOp lab minusInfinityTermWithRange minusInfinityTermWithRange))
evLessLeq _ _isLeq formOp _logicOp lab (Term (MinusInfinity, l)) (Term (PlusInfinity, _)) =
(prevValuesMap SP.:!:
(L.fromBool lab l apb True,
formOp lab minusInfinityTermWithRange plusInfinityTermWithRange))
evLessLeq _ _isLeq formOp _logicOp lab (Term (PlusInfinity, l)) (Term (MinusInfinity, _)) =
(prevValuesMap SP.:!:
(L.fromBool lab l apb False,
formOp lab plusInfinityTermWithRange minusInfinityTermWithRange))
evLessLeq _ _isLeq formOp _logicOp lab (Term (MinusInfinity, l)) right =
(prevValuesMap SP.:!:
(L.fromBool lab l apb True,
formOp lab minusInfinityTermWithRange rightWithRanges))
where
(_ SP.:!: (_rightVal, rightWithRanges)) = evTerm False prevValuesMap right
evLessLeq _ _isLeq formOp _logicOp lab left (Term (MinusInfinity, l)) =
(prevValuesMap SP.:!:
(L.fromBool lab l apb False,
formOp lab leftWithRanges minusInfinityTermWithRange))
where
(_ SP.:!: (_leftVal, leftWithRanges)) = evTerm False prevValuesMap left
evLessLeq _ _isLeq formOp _logicOp lab (Term (PlusInfinity, l)) right =
(prevValuesMap SP.:!:
(L.fromBool lab l apb False,
formOp lab plusInfinityTermWithRange rightWithRanges))
where
(_ SP.:!: (_rightVal, rightWithRanges)) = evTerm False prevValuesMap right
evLessLeq _ _isLeq formOp _logicOp lab left (Term (PlusInfinity, l)) =
(prevValuesMap SP.:!:
(L.fromBool lab l apb True,
formOp lab leftWithRanges plusInfinityTermWithRange))
where
(_ SP.:!: (_leftVal, leftWithRanges)) = evTerm False prevValuesMap left
evLessLeq form2 _ formOp logicOp lab left right =
evOpT2 form2 False (formOp lab) (\formWR -> logicOp lab formWR apb) left right
plusInfinityTermWithRange = (Term (PlusInfinity, Just $ 1/0))
minusInfinityTermWithRange = (Term (MinusInfinity, Just $ -1/0))
termIsIntegerType :: (IMap.IntMap Bool) -> Term l -> Bool
termIsIntegerType isIntVarMap (Term (t, _)) =
case t of
Lit val -> Q.denominator val == 1
Var varId _ -> case IMap.lookup varId isIntVarMap of Just res -> res; _ -> False
Plus left right -> termIsIntegerType2 left right
Minus left right -> termIsIntegerType2 left right
Neg arg -> termIsIntegerType isIntVarMap arg
Abs arg -> termIsIntegerType isIntVarMap arg
Min left right -> termIsIntegerType2 left right
Max left right -> termIsIntegerType2 left right
Times left right -> termIsIntegerType2 left right
IntPower left right -> termIsIntegerType2 left right
_ -> False
where
termIsIntegerType2 t1 t2 =
termIsIntegerType isIntVarMap t1 && termIsIntegerType isIntVarMap t2
evalTerm ::
Int {-^ polynomial degree limit -} ->
Int {-^ polynomial term size limit -} ->
EffortIndex {-^ effort index for regulating model error -} ->
IRA BM {-^ minIntegrationStepSize -} ->
APBox BM {-^ domains of variables -} ->
-- (Int,Int) {-^ precision of emulated FP operations -} ->
Bool {-^ should compute ranges using inner rounding? -} ->
(IMap.IntMap (FAPUOI BM, Term (Maybe (IRA BM)))) {-^ cache of memoised results -} ->
Term Int {-^ term to evaluate, with hashes in all sub-terms -} ->
SP.Pair (IMap.IntMap (FAPUOI BM, Term (Maybe (IRA BM))))
(FAPUOI BM, Term (Maybe (IRA BM)))
evalTerm
maxdeg maxsize ix minIntegrationStepSize ppbOrig -- fptype@(epsrelbits,epsabsbits)
needInnerRounding prevValuesMapOrig origTerm =
evTermBox ppbOrig prevValuesMapOrig origTerm
where
evTermBox apb prevValuesMap term@(Term (_, hashValue)) =
-- check whether the result for this term has been memoised:
case IMap.lookup hashValue prevValuesMap of
Just memoisedResult -> (prevValuesMap SP.:!: memoisedResult) -- memoised, reuse!
_ -> (newValuesMapWithResult SP.:!: result) -- not memoised, compute and memoise!
where
newValuesMapWithResult = IMap.insert hashValue result newValuesMap
result = (valueFA, Term (term', Just valueRA))
valueRA
| needInnerRounding = ilRA RA.\/ ihRA
| otherwise = valueRAOuter
[ilRA] = FA.getRangeApprox il
[ihRA] = FA.getRangeApprox ih
[valueRAOuter] = FA.getRangeApprox valueFA
((_ol, _oh), (il, ih)) = RA.oiBounds valueFA
(newValuesMap SP.:!: (valueFA, term')) = evTermBox' apb prevValuesMap term
evTermBox' apb@(APBox box isIntVarMap namesMap) prevValuesMap (Term (term', _)) =
case term' of
Pi -> (prevValuesMap SP.:!: (setSizes $ RAEL.pi 10, Pi))
Lit val -> (prevValuesMap SP.:!: (rationalToFA val, Lit val))
PlusInfinity ->
unsafePrint
("Warning: Currently PolyPaver cannot prove a statement that has an infinity in a sub-expression.")
(prevValuesMap SP.:!: (setSizes $ UFA.const [1/0], PlusInfinity))
MinusInfinity ->
unsafePrint
("Warning: Currently PolyPaver cannot prove a statement that has an infinity in a sub-expression.")
(prevValuesMap SP.:!: (setSizes $ UFA.const [-1/0], MinusInfinity))
Var varid varName ->
(prevValuesMap SP.:!: (fa, Var varid varName))
where
fa =
case isZero r of
True -> -- domain of var thin, so var is a const
setSizes $ UFA.const [c]
False -> -- domain of var not thin, so safe to proj
setSizes $ UFA.affine [c] (Map.singleton varid [r])
(c, r) =
case IMap.lookup varid box of
Just v -> v
Nothing ->
error $
"variable " ++ show varName ++ "(" ++ show varid
++ ") not in box " ++ show box
isZero cf = cf `RA.equalReals` 0 == Just True
Plus left right -> evOp2 Plus (+) left right
Minus left right -> evOp2 Minus (-) left right
Neg arg -> evOp1 Neg negate arg
Abs arg -> evOp1 Abs absOp arg
where
-- absOp = RAEL.abs ix
absOp = setSizes . RAEL.abs ix . setSizes0
Min left right -> evOp2 Min min left right
Max left right -> evOp2 Max max left right
Times left right -> evOp2 Times (*) left right
Square arg -> evOp1 Square (\a -> intPowerOp a 2) arg
IntPower left right -> evOp2 IntPower intPowerOp left right
Recip arg -> evOp1 Recip recip arg
Over left right -> evOp2 Over divOp left right
where
divOp = (/)
-- divOp l r = l * (UFA.const (map recip $ FA.getRangeApprox r))
-- the above poor man's division is surprisingly 2x slower than the ordinary division
-- at least for erfriemann -d 1
Sqrt arg -> evOp1 Sqrt (RAEL.sqrt (fromInteger $ toInteger ix)) arg
Exp arg -> evOp1 Exp (RAEL.exp ix) arg
-- ix $ -- (fromInteger $ 3*(toInteger maxdeg)+10) $
Sin arg -> evOp1 Sin (RAEL.sin ix) arg
Cos arg -> evOp1 Cos (RAEL.cos ix) arg
Atan arg -> evOp1 Atan (RAEL.atan ix) arg
Hull left right -> evOp2 Hull (RA.\/) left right
Integral ivarId ivarName lower upper integrand ->
evIntegral ivarId ivarName lower upper integrand
FEpsAbs epsrelbits epsabsbits ->
(prevValuesMap SP.:!: (rationalToFA $ 2^^(- epsabsbits), FEpsAbs epsrelbits epsabsbits))
FEpsRel epsrelbits epsabsbits ->
(prevValuesMap SP.:!: (rationalToFA $ 2^^(- epsrelbits), FEpsRel epsrelbits epsabsbits))
_ ->
error $ "Eval: evalTerm applied on a term with an unsupported operation: " ++ show term'
where
setSizes :: FAPUOI BM -> FAPUOI BM
setSizes = FA.setMaxDegree maxdeg . FA.setMaxSize maxsize
setSizes0 = FA.setMaxDegree 0
rationalToFA = setSizes . fromRational
evOp1 opT opFA arg =
(newValuesMap SP.:!: (opFA argFA, opT argWithRanges))
where
(newValuesMap SP.:!: (argFA, argWithRanges)) = evTermBox apb prevValuesMap arg
evOp2 opT opFA left right =
(newValuesMap SP.:!: (opFA leftFA rightFA, opT leftWithRanges rightWithRanges))
where
(intermValuesMap SP.:!: (leftFA, leftWithRanges)) = evTermBox apb prevValuesMap left
(newValuesMap SP.:!: (rightFA, rightWithRanges)) = evTermBox apb intermValuesMap right
intPowerOp b e
| eL <= eR =
(pwr eL) RA.\/ (pwr eR)
| otherwise =
error $ "Exponent of IntPower does not permit a non-negative integer value: " ++ show e
where
_ = [b,e]
pwr n = b ^ n
eL = max 0 eLP
(eLP, eR) = shrinkIntervalToIntegerBounds eRA
[eRA] = FA.getRangeApprox e
evIntegral ivarId ivarName lo hi integrand =
-- unsafePrint
-- (
-- "evIntegral:"
-- ++ "\n term = " ++ showTerm (Term (term, Nothing))
-- ++ "\n apb = " ++ show apb
-- ++ "\n loRange = " ++ show loRange
-- ++ "\n hiRange = " ++ show hiRange
-- ++ "\n segments = " ++ show segments
-- ++ "\n primitiveFunctionLo = " ++ show primitiveFunctionLo
-- ++ "\n primitiveFunctionHi = " ++ show primitiveFunctionHi
-- )
-- $
case RA.isExact integrationDom of
False ->
case ivarId `Set.member` (getTermFreeVars integrand) of
True -> -- nonconstant integrand
(newValuesMap SP.:!:
(setSizes $ primitiveFunctionHi-primitiveFunctionLo,
termWithRanges2))
-- case 0 `RA.leqReals` integrandEnclosure of
-- Just True ->
-- (FA.setMaxDegree maxdeg $ primitiveFunctionHi-primitiveFunctionLo,
-- termWithRanges)
-- _ ->
---- (UFA.bottomApprox, termWithRanges)
-- integrand
-- evTermBox' apb $ (hi - lo)
False -> -- constant integrand
evTermBox' apb prevValuesMap $
Term (integrandTimesWidth, hash integrandTimesWidth)
where
integrandTimesWidth = Times integrand (Term (hiMinusLo, hash hiMinusLo))
hiMinusLo = Minus hi lo
True -> -- integrating over measure zero set
(newValuesMap SP.:!: (0, termWithRanges2))
where
termWithRanges2 =
Integral ivarId ivarName loWithRanges hiWithRanges integrandWithRangesLastSegment
primitiveFunctionLo =
-- unsafePrintReturn "primitiveFunctionLo = " $
composeBoundEnclosure primitiveFunctionFirstSegment loBoundEnclosureInUnit
primitiveFunctionHi =
-- unsafePrintReturn "primitiveFunctionHi = " $
composeBoundEnclosure primitiveFunctionLastSegment hiBoundEnclosureInUnit
loBoundEnclosureInUnit = boundIntoUnit (head segments) loBoundEnclosure
hiBoundEnclosureInUnit = boundIntoUnit (last segments) hiBoundEnclosure
boundIntoUnit segment fn =
(fn - constFA) * invslopeFA
where
constFA = setSizes $ UFA.const [constRA]
invslopeFA = setSizes $ UFA.const [1/slopeRA]
(constRA, slopeRA) = centerRadiusFromEndpoints $ RA.bounds segment
composeBoundEnclosure primitiveFunction boundEnclosure =
-- the following relies on the assumption that primitiveFunction is isotone
RA.fromOIBounds ((rol,roh), (ril, rih))
where
((rol,_ ),(_ ,_ )) = RA.oiBounds $ composeThinBound ol
((_ ,roh),(_ ,_ )) = RA.oiBounds $ composeThinBound oh
((_ ,_ ),(ril,_ )) = RA.oiBounds $ composeThinBound il
((_ ,_ ),(_ ,rih)) = RA.oiBounds $ composeThinBound ih
((ol,oh),(il,ih)) = RA.oiBounds boundEnclosure
composeThinBound b =
UFA.composeWithThin primitiveFunction $ Map.fromList [(ivarId, b)]
primitiveFunctionFirstSegment = head primitiveFunctionSegments
primitiveFunctionLastSegment = last primitiveFunctionSegments
primitiveFunctionSegments =
integratePiecewise
(0 :: Int) -- ix
(zip integrandEnclosuresOverSegments segments)
ivarId
0 -- value of primitive function at the left endpoint
integrandWithRangesLastSegment = last integrandWithRangesOverSegments
(integrandEnclosuresOverSegments, integrandWithRangesOverSegments) =
unzip $ map evaluateIntegrandOnSegment segments
evaluateIntegrandOnSegment segment =
SP.snd $ -- forget memoised results for integrand as its values are over a different box
evTermBox segmentAPB IMap.empty integrand
where
segmentAPB =
-- | skewed = error "Paralellepiped solving not yet supported for the integral operator."
(APBox segmentBox
(IMap.insert ivarId False isIntVarMap)
(IMap.insert ivarId ivarName namesMap))
segmentBox =
DBox.insert ivarId segmentCenterRadius box
segmentCenterRadius = centerRadius
where
[(_, centerRadius)] = IMap.toList ivbox
(APBox ivbox _ _) =
boxFromEndpoints isIntVarMap namesMap [(ivarId, RA.bounds segment)]
segments
| loRangeIntersectsHiRange = [integrationDom]
| otherwise =
loRangeIfNonempty ++
midSegments ++
hiRangeIfNonempty
where
loRangeIntersectsHiRange = not $ loRangeHi < hiRangeLo
midSegments = bisect (loRangeHi, hiRangeLo)
hiRangeIfNonempty
| hiRangeLo < hiRangeHi = [hiRange]
| otherwise = []
loRangeIfNonempty
| loRangeLo < loRangeHi = [loRange]
| otherwise = []
(loRangeLo, loRangeHi) = RA.bounds loRange
(hiRangeLo, hiRangeHi) = RA.bounds hiRange
bisect (lo2,hi2)
| (minIntegrationStepSize < hi2 - lo2) =
(bisect (lo2, mid)) ++
(bisect (mid, hi2))
| otherwise = [RA.fromBounds (lo2, hi2)]
where
mid = fst $ RA.bounds $ (hi2 + lo2) / 2
-- minIntegrationStepSize
-- | useBounds > 0 = useBounds
---- | useBox > 0 = useBox -- TODO
-- | otherwise = useIx
-- where
-- useBounds = snd $ RA.bounds $ max (loRangeHi - loRangeLo) (hiRangeHi - hiRangeLo)
-- useIx = snd $ RA.bounds $ (hiRangeLo - loRangeHi) / (fromInteger $ toInteger ix)
integrationDom = loRange RA.\/ hiRange
[loRange] = FA.getRangeApprox loBoundEnclosure
[hiRange] = FA.getRangeApprox hiBoundEnclosure
(intermValuesMap SP.:!: (loBoundEnclosure, loWithRanges)) = evTermBox apb prevValuesMap lo
(newValuesMap SP.:!: (hiBoundEnclosure, hiWithRanges)) = evTermBox apb intermValuesMap hi
integratePiecewise _ix integrandEnclosuresSegments _ivarId fnAtLeftEndpoint =
aux fnAtLeftEndpoint integrandEnclosuresSegments
where
aux _ [] = []
aux fnInit ((integrandEnclosure, segment) : rest) =
-- unsafePrint
-- (
-- "integratePiecewise: aux:"
-- ++ "\n segment = " ++ show segment
-- ++ "\n slopeRA = " ++ show slopeRA
-- ++ "\n fnInit = " ++ show fnInit
-- ++ "\n integrandEnclosure = " ++ show integrandEnclosure
-- ++ "\n primitiveFunctionUFA = " ++ show primitiveFunctionUFA
-- ++ "\n primitiveFunction = " ++ show primitiveFunction
-- ++ "\n fnFinal = " ++ show fnFinal
-- ) $
primitiveFunction : (aux fnFinal rest)
where
fnFinal =
setSizes $
FA.partialEval substitution primitiveFunction
where
substitution = DBox.singleton ivarId (1)
primitiveFunction =
fnInit +
((UFA.const [slopeRA]) * primitiveFunctionUFA)
primitiveFunctionUFA =
UFA.integrate
ix
integrandEnclosure
ivarId
(-1) -- an integration start point
0 -- value of primitive function at the above start point
(_constRA, slopeRA) = centerRadiusFromEndpoints segmentBounds
segmentBounds@(_segmentLE, _segmentRE) = RA.bounds segment
{--- Expansion that eliminates rounded ops ---}
expandRoundedOpsInForm ::
(HasDefaultValue l, Eq l) =>
Form l -> Form l
expandRoundedOpsInForm form =
case form of
Not arg -> expOp1 Not arg
Or left right -> expOp2 Or left right
And left right -> expOp2 And left right
Implies left right -> expOp2 Implies left right
Le lab left right -> expT2 Le lab left right
Leq lab left right -> expT2 Leq lab left right
Ge lab left right -> expT2 Ge lab right left
Geq lab left right -> expT2 Geq lab right left
Eq lab left right -> expT2 Eq lab left right
Neq lab left right -> expT2 Neq lab left right
ContainedIn lab left right -> expT2 ContainedIn lab left right
IsRange lab t lower upper -> expT3 IsRange lab t lower upper
IsIntRange lab t lower upper -> expT3 IsIntRange lab t lower upper
IsInt lab t -> expT1 IsInt lab t
where
expOp1 op arg = op (expandRoundedOpsInForm arg)
expOp2 op arg1 arg2 = op (expandRoundedOpsInForm arg1) (expandRoundedOpsInForm arg2)
expT1 op lab t = op lab (expandRoundedOpsInTerm t)
expT2 op lab t1 t2 = op lab (expandRoundedOpsInTerm t1) (expandRoundedOpsInTerm t2)
expT3 op lab t1 t2 t3 = op lab (expandRoundedOpsInTerm t1) (expandRoundedOpsInTerm t2) (expandRoundedOpsInTerm t3)
expandRoundedOpsInTerm ::
(HasDefaultValue l, Eq l) =>
Term l -> Term l
expandRoundedOpsInTerm term@(Term (term', l)) =
case term' of
Hull t1 t2 -> expOp2 Hull t1 t2
Plus t1 t2 -> expOp2 Plus t1 t2
Minus t1 t2 -> expOp2 Minus t1 t2
Neg t -> expOp1 Neg t
Times t1 t2 -> expOp2 Times t1 t2
Square t -> expOp1 Square t
IntPower t1 t2 -> expOp2 IntPower t1 t2
Recip t -> expOp1 Recip t
Over t1 t2 -> expOp2 Over t1 t2
Abs t -> expOp1 Abs t
Min t1 t2 -> expOp2 Min t1 t2
Max t1 t2 -> expOp2 Max t1 t2
Sqrt t -> expOp1 Sqrt t
Exp t -> expOp1 Exp t
Sin t -> expOp1 Sin t
Cos t -> expOp1 Cos t
Atan t -> expOp1 Atan t
Integral ivarId ivarName lower upper integrand ->
expOp3 (Integral ivarId ivarName) lower upper integrand
FEpsiAbs rel abse -> fEpsiAbs rel abse
FEpsiRel rel abse -> fEpsiRel rel abse
FRound rel abse arg -> fround2 rel abse (expandRoundedOpsInTerm arg)
FPlus rel abse left right -> fround2 rel abse (leftDone + rightDone)
where
leftDone = expandRoundedOpsInTerm left
rightDone = expandRoundedOpsInTerm right
FMinus rel abse left right -> fround2 rel abse (leftDone - rightDone)
where
leftDone = expandRoundedOpsInTerm left
rightDone = expandRoundedOpsInTerm right
FTimes rel abse left right -> fround2 rel abse (leftDone * rightDone)
where
leftDone = expandRoundedOpsInTerm left
rightDone = expandRoundedOpsInTerm right
FOver rel abse left right -> fround2 rel abse (leftDone / rightDone)
where
leftDone = expandRoundedOpsInTerm left
rightDone = expandRoundedOpsInTerm right
FSquare rel abse arg -> fround2 rel abse (square argDone)
where
argDone = expandRoundedOpsInTerm arg
FSqrt rel abse arg -> fround2 rel abse $ (1+2*epsiRel) * (sqrt argDone)
where
epsiRel = fEpsiRel rel abse
argDone = expandRoundedOpsInTerm arg
FSin rel abse arg -> fround2 rel abse $ (1+2*epsiRel) * (sin argDone)
where
epsiRel = fEpsiRel rel abse
argDone = expandRoundedOpsInTerm arg
FCos rel abse arg -> fround2 rel abse $ (1+2*epsiRel) * (cos argDone)
where
epsiRel = fEpsiRel rel abse
argDone = expandRoundedOpsInTerm arg
FExp rel abse arg -> fround2 rel abse $ (1+4*epsiRel) * (exp argDone)
where
epsiRel = fEpsiRel rel abse
argDone = expandRoundedOpsInTerm arg
_ -> term
where
fEpsiRel rel abse = plusMinus $ termOp0 $ FEpsRel rel abse
fEpsiAbs rel abse = plusMinus $ termOp0 $ FEpsAbs rel abse
fround2 rel abse argDone = ((1 + epsiRel) * argDone) + epsiAbs
where
epsiRel = plusMinus $ termOp0 $ FEpsRel rel abse
epsiAbs = plusMinus $ termOp0 $ FEpsAbs rel abse
expOp1 op arg =
Term (op (expandRoundedOpsInTerm arg), l)
expOp2 op arg1 arg2 =
Term (op (expandRoundedOpsInTerm arg1) (expandRoundedOpsInTerm arg2), l)
expOp3 op arg1 arg2 arg3 =
Term (op (expandRoundedOpsInTerm arg1) (expandRoundedOpsInTerm arg2) (expandRoundedOpsInTerm arg3), l)
|
michalkonecny/polypaver
|
src/PolyPaver/Eval.hs
|
bsd-3-clause
| 29,309 | 0 | 21 | 10,541 | 7,018 | 3,602 | 3,416 | 456 | 32 |
module Andromeda.Types.Language.ControlFlow ( module X ) where
import Andromeda.Types.Language.ControlFlow.ControlFlow as X
|
graninas/Andromeda
|
src/Andromeda/Types/Language/ControlFlow.hs
|
bsd-3-clause
| 125 | 0 | 4 | 12 | 24 | 18 | 6 | 2 | 0 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
--
-- Regs.hs --- SPI peripheral registers for the STM32
--
-- Copyright (C) 2013, Galois, Inc.
-- All Rights Reserved.
--
module Ivory.BSP.STM32.Peripheral.SPI.Regs where
import Ivory.Language
import Ivory.BSP.STM32.Peripheral.SPI.RegTypes
----------------------------------------------------------------------
-- SPI Registers
[ivory|
bitdata SPI_CR1 :: Bits 16 = spi_cr1
{ spi_cr1_bidimode :: Bit
, spi_cr1_bidioe :: Bit
, spi_cr1_crcen :: Bit
, spi_cr1_crcnext :: Bit
, spi_cr1_dff :: Bit
, spi_cr1_rxonly :: Bit
, spi_cr1_ssm :: Bit
, spi_cr1_ssi :: Bit
, spi_cr1_lsbfirst :: Bit
, spi_cr1_spe :: Bit
, spi_cr1_br :: SPIBaud
, spi_cr1_mstr :: Bit
, spi_cr1_cpol :: Bit
, spi_cr1_cpha :: Bit
}
bitdata SPI_CR2 :: Bits 16 = spi_cr2
{ _ :: Bits 8
, spi_cr2_txeie :: Bit
, spi_cr2_rxneie :: Bit
, spi_cr2_errie :: Bit
, _ :: Bits 2
, spi_cr2_ssoe :: Bit
, spi_cr2_txdmaen :: Bit
, spi_cr2_rxdmaen :: Bit
}
bitdata SPI_SR :: Bits 16 = spi_sr
{ _ :: Bits 7
, spi_sr_fre :: Bit
, spi_sr_bsy :: Bit
, spi_sr_ovr :: Bit
, spi_sr_modf :: Bit
, spi_sr_crcerr :: Bit
, spi_sr_udr :: Bit
, spi_sr_chside :: Bit
, spi_sr_txe :: Bit
, spi_sr_rxne :: Bit
}
bitdata SPI_DR :: Bits 16 = spi_dr
{ _ :: Bits 8
, spi_dr_data :: Bits 8
}
|]
|
GaloisInc/ivory-tower-stm32
|
ivory-bsp-stm32/src/Ivory/BSP/STM32/Peripheral/SPI/Regs.hs
|
bsd-3-clause
| 1,653 | 0 | 4 | 523 | 43 | 35 | 8 | 8 | 0 |
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
module Purescript.Ide.Externs
(
ExternParse,
ExternDecl(..),
Fixity(..),
readExternFile,
parseExternDecl,
typeParse
) where
import Data.Char (digitToInt)
import Data.Text (Text ())
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Text.Parsec
import Text.Parsec.Text
type ExternParse = Either ParseError [ExternDecl]
data Fixity = Infix | Infixl | Infixr deriving(Show, Eq)
data ExternDecl
= FunctionDecl { functionName :: Text
, functionType :: Text}
| FixityDeclaration Fixity
Int
Text
| Dependency { dependencyModule :: Text
, dependencyNames :: Text}
| ModuleDecl Text
[Text]
| DataDecl Text
Text
deriving (Show,Eq)
-- | Parses an extern file into the ExternDecl format.
readExternFile :: FilePath -> IO ExternParse
readExternFile fp = readExtern <$> (T.lines <$> T.readFile fp)
readExtern:: [Text] -> ExternParse
readExtern strs = mapM (parse parseExternDecl "") clean
where
clean = removeComments strs
removeComments :: [Text] -> [Text]
removeComments = filter (not . T.isPrefixOf "--")
parseExternDecl :: Parser ExternDecl
parseExternDecl =
try parseDependency <|> try parseFixityDecl <|> try parseFunctionDecl <|>
try parseDataDecl <|> try parseModuleDecl <|>
return (ModuleDecl "" [])
parseDependency :: Parser ExternDecl
parseDependency = do
string "import "
module' <- many1 (noneOf " ")
spaces
names <- many1 anyChar
eof
return $ Dependency (T.pack module') (T.pack names)
parseFixityDecl :: Parser ExternDecl
parseFixityDecl = do
fixity <- parseFixity
spaces
priority <- digitToInt <$> digit
spaces
symbol <- many1 anyChar
eof
return (FixityDeclaration fixity priority (T.pack symbol))
parseFixity :: Parser Fixity
parseFixity =
(try (string "infixr") >> return Infixr) <|>
(try (string "infixl") >> return Infixl) <|>
(string "infix" >> return Infix)
parseFunctionDecl :: Parser ExternDecl
parseFunctionDecl = do
string "foreign import"
spaces
(name, type') <- parseType
eof
return (FunctionDecl (T.pack name) (T.pack type'))
parseDataDecl :: Parser ExternDecl
parseDataDecl = do
string "foreign import data"
spaces
(name, kind) <- parseType
eof
return $ DataDecl (T.pack name) (T.pack kind)
parseModuleDecl :: Parser ExternDecl
parseModuleDecl = do
string "module"
spaces
name <- many1 (noneOf " ")
return (ModuleDecl (T.pack name) [])
parseType :: Parser (String, String)
parseType = do
name <- many1 (noneOf " ")
spaces
string "::"
spaces
type' <- many1 anyChar
return (name, type')
typeParse :: Text -> Either Text (Text, Text)
typeParse t = case parse parseType "" t of
Right (x,y) -> Right (T.pack x, T.pack y)
Left err -> Left (T.pack (show err))
|
passy/psc-ide
|
lib/Purescript/Ide/Externs.hs
|
bsd-3-clause
| 3,059 | 0 | 12 | 765 | 968 | 491 | 477 | 97 | 2 |
module MB.Types
( Blog(..)
, StartupConfig(..)
, BlogM
, GenEvent(..)
, GenState(..)
, Post(..)
, Template
, ChangeSummary(..)
, Page(..)
, Processor(..)
, RenderCause(..)
, BlogInputFS(..)
, BlogOutputFS(..)
, BlogInputFSState(..)
, nullProcessor
, noChanges
, theBlog
, theConfig
, notify
, runBlogM
, blogOutputFS
, blogInputFS
)
where
import Control.Concurrent.Chan
import Control.Monad.Reader
import Data.Time.Clock (UTCTime)
import Data.Monoid
import Data.List (nub)
import System.FilePath ((</>))
import Network.Socket (HostName, PortNumber)
import qualified Text.Pandoc as Pandoc
import Text.StringTemplate
( StringTemplate
)
data StartupConfig = StartupConfig { dataDirectory :: FilePath
, initDataDirectory :: Bool
, forceRegeneration :: Bool
, htmlOutputDirectory :: FilePath
, configFilePath :: FilePath
, listenAddr :: Maybe (HostName, PortNumber)
, overrideBaseUrl :: Maybe String
}
deriving (Show, Eq)
blogOutputFS :: StartupConfig -> BlogOutputFS
blogOutputFS c =
let base = htmlOutputDirectory c
images = base </> "generated-images"
posts = base </> "posts"
in BlogOutputFS { ofsBaseDir = base
, ofsPostHtmlDir = posts
, ofsImageDir = images
, ofsHtmlTempDir = base </> "tmp"
, ofsImagePath = \fn -> images </> fn
, ofsIndexHtml = base </> "index.html"
, ofsRssXml = base </> "feed.xml"
, ofsListHtml = posts </> "index.html"
, ofsPostFinalHtml = \p -> posts </> postHtmlFilename p
}
blogInputFS :: StartupConfig -> BlogInputFS
blogInputFS c =
let base = dataDirectory c
templates = base </> "templates"
posts = base </> "posts"
in BlogInputFS { ifsBaseDir = base
, ifsPostSourceDir = posts
, ifsTemplateDir = templates
, ifsPostIndexPath = posts </> "posts-index"
, ifsConfigPath = base </> "blog.cfg"
, ifsAssetDir = base </> "assets"
, ifsPageTemplatePath = templates </> "pageTemplate.html"
, ifsListTemplatePath = templates </> "listTemplate.html"
, ifsPostTemplatePath = templates </> "postTemplate.html"
, ifsRssTemplatePath = templates </> "rssTemplate.xml"
}
data GenState =
GenState { stBlog :: Blog
, stChan :: Chan GenEvent
, stConfig :: StartupConfig
}
data GenEvent = PostRender Post [RenderCause]
| Finished
data RenderCause = Config
| PostIndex
| Template
| PostModified
| Forced
deriving (Eq, Show)
type BlogM a = ReaderT GenState IO a
theBlog :: BlogM Blog
theBlog = asks stBlog
theConfig :: BlogM StartupConfig
theConfig = asks stConfig
notify :: GenEvent -> BlogM ()
notify ev = do
ch <- asks stChan
liftIO $ writeChan ch ev
runBlogM :: Blog -> Chan GenEvent -> StartupConfig -> BlogM a -> IO a
runBlogM b ch conf act = runReaderT act (GenState b ch conf)
type Template = StringTemplate String
data BlogInputFS =
BlogInputFS { ifsBaseDir :: FilePath
, ifsPostSourceDir :: FilePath
, ifsAssetDir :: FilePath
, ifsTemplateDir :: FilePath
, ifsConfigPath :: FilePath
, ifsPostIndexPath :: FilePath
, ifsPageTemplatePath :: FilePath
, ifsListTemplatePath :: FilePath
, ifsPostTemplatePath :: FilePath
, ifsRssTemplatePath :: FilePath
}
data BlogOutputFS =
BlogOutputFS { ofsBaseDir :: FilePath
, ofsPostHtmlDir :: FilePath
, ofsImageDir :: FilePath
, ofsHtmlTempDir :: FilePath
, ofsImagePath :: String -> FilePath
, ofsIndexHtml :: FilePath
, ofsRssXml :: FilePath
, ofsListHtml :: FilePath
, ofsPostFinalHtml :: Post -> FilePath
}
data BlogInputFSState =
BlogInputFSState { ifsPostIndexMTime :: UTCTime
, ifsConfigMTime :: UTCTime
, ifsBaselineMTime :: UTCTime
, ifsTemplateMTime :: UTCTime
}
data Blog = Blog { inputFS :: BlogInputFS
, outputFS :: BlogOutputFS
, inputFSState :: BlogInputFSState
, baseUrl :: String
, title :: String
, authorName :: String
, authorEmail :: String
, blogPosts :: [Post]
, processors :: [Processor]
}
data Post = Post { postTitle :: [Pandoc.Inline]
, postPath :: String
, postFilename :: String
, postModificationTime :: UTCTime
, postModificationString :: String
, postAst :: Pandoc.Pandoc
, postTeXMacros :: String
, postAuthors :: [String]
, postDate :: Maybe String
, postBaseName :: String
, postUrl :: String
, postHtmlFilename :: String
}
deriving (Eq)
data Page = BlogPost
| Index
data Processor =
Processor { applyWriterOptions :: Maybe (Pandoc.WriterOptions -> Pandoc.WriterOptions)
, preProcessPost :: Maybe (Post -> BlogM Post)
, postProcessPost :: Maybe (FilePath -> Page -> BlogM ())
, pageHead :: Maybe String
, buildPostTitle :: Maybe (Page -> [Pandoc.Inline] -> [Pandoc.Inline])
, rawPostTitle :: Maybe ([Pandoc.Inline] -> String)
, checkDataDir :: Maybe (BlogM ())
, installAssets :: Maybe (BlogM ())
}
nullProcessor :: Processor
nullProcessor =
Processor Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
-- Summarize changes in files so we know what to do during the
-- regeneration phase. postsChanged and configChanged are the primary
-- measurements, but knowing whether other metadata files changed
-- (like templates) is useful for the "listen" mode of mb.
data ChangeSummary =
ChangeSummary { postsChanged :: [String]
, configChanged :: Bool
, templatesChanged :: [FilePath]
, postIndexChanged :: Bool
, assetsChanged :: [FilePath]
}
deriving (Show)
noChanges :: ChangeSummary
noChanges = ChangeSummary [] False [] False []
instance Monoid ChangeSummary where
mempty = noChanges
a `mappend` b =
ChangeSummary { postsChanged = nub $ postsChanged a ++ postsChanged b
, configChanged = configChanged a || configChanged b
, templatesChanged = templatesChanged a `mappend` templatesChanged b
, postIndexChanged = postIndexChanged a || postIndexChanged b
, assetsChanged = assetsChanged a `mappend` assetsChanged b
}
|
jtdaugherty/mathblog
|
src/MB/Types.hs
|
bsd-3-clause
| 7,574 | 0 | 14 | 2,871 | 1,542 | 911 | 631 | 173 | 1 |
module Problem8 where
import Data.Char (digitToInt)
import Data.Function (on)
import Data.List (maximumBy)
--
-- Problem 8: Largest product in a series
--
-- The four adjacent digits in the 1000-digit number that have the greatest
-- product are 9 × 9 × 8 × 9 = 5832.
--
-- Find the thirteen adjacent digits in the 1000-digit number that have the
-- greatest product. What is the value of this product?
problem8 :: Int
-- problem8 = maximumBy (compare `on` permProduct) (perms 13 digits) where
problem8 = maximum $ map permProduct $ perms 13 digits where
permProduct perm = product $ map digitToInt perm
perms len xs@(y:ys) = let perm = take len xs in
if length perm < len then []
else perm : perms len ys
digits =
"73167176531330624919225119674426574742355349194934\
\96983520312774506326239578318016984801869478851843\
\85861560789112949495459501737958331952853208805511\
\12540698747158523863050715693290963295227443043557\
\66896648950445244523161731856403098711121722383113\
\62229893423380308135336276614282806444486645238749\
\30358907296290491560440772390713810515859307960866\
\70172427121883998797908792274921901699720888093776\
\65727333001053367881220235421809751254540594752243\
\52584907711670556013604839586446706324415722155397\
\53697817977846174064955149290862569321978468622482\
\83972241375657056057490261407972968652414535100474\
\82166370484403199890008895243450658541227588666881\
\16427171479924442928230863465674813919123162824586\
\17866458359124566529476545682848912883142607690042\
\24219022671055626321111109370544217506941658960408\
\07198403850962455444362981230987879927244284909188\
\84580156166097919133875499200524063689912560717606\
\05886116467109405077541002256983155200055935729725\
\71636269561882670428252483600823257530420752963450"
|
c0deaddict/project-euler
|
src/Part1/Problem8.hs
|
bsd-3-clause
| 1,916 | 0 | 11 | 288 | 155 | 86 | 69 | 12 | 2 |
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ViewPatterns #-}
-- | Main stack tool entry point.
module Main where
import Control.Exception
import Control.Monad (join)
import Control.Monad.IO.Class (liftIO)
import Control.Monad.Logger
import Control.Monad.Reader (asks)
import Data.Char (toLower)
import Data.List
import qualified Data.List as List
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Maybe (isJust)
import Data.Monoid
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Network.HTTP.Client
import Options.Applicative.Builder.Extra
import Options.Applicative.Simple
import Options.Applicative.Types (readerAsk)
import Path (toFilePath)
import qualified Paths_stack as Meta
import Plugins
import Plugins.Commands
import Stack.Build
import Stack.Build.Types
import Stack.Config
import Stack.Constants
import qualified Stack.Docker as Docker
import Stack.Fetch
import Stack.GhcPkg (envHelper)
import qualified Stack.PackageIndex
import Stack.Path
import Stack.Setup
import Stack.Types
import Stack.Types.StackT
import System.Environment (getArgs, getProgName)
import System.Exit
import System.FilePath (searchPathSeparator)
import System.IO (stderr)
import qualified System.Process as P
import qualified System.Process.Read
-- | Commandline dispatcher.
main :: IO ()
main =
do plugins <- findPlugins (T.pack stackProgName)
tryRunPlugin plugins
Docker.checkVersions
progName <- getProgName
args <- getArgs
execExtraHelp args
dockerHelpOptName
(Docker.dockerOptsParser True)
("Only showing --" ++ Docker.dockerCmdName ++ "* options.")
(level,run) <-
simpleOptions
$(simpleVersion Meta.version)
"stack - The Haskell Tool Stack"
""
(extraHelpOption progName (Docker.dockerCmdName ++ "*") dockerHelpOptName <*> globalOpts)
(do addCommand "build"
"Build the project(s) in this directory/configuration"
(buildCmd DoNothing)
buildOpts
addCommand "test"
"Build and test the project(s) in this directory/configuration"
(buildCmd DoTests)
buildOpts
addCommand "bench"
"Build and benchmark the project(s) in this directory/configuration"
(buildCmd DoBenchmarks)
buildOpts
addCommand "haddock"
"Generate haddocks for the project(s) in this directory/configuration"
(buildCmd DoHaddock)
buildOpts
addCommand "setup"
"Get the appropriate ghc for your project"
setupCmd
setupParser
addCommand "unpack"
"Unpack one or more packages locally"
unpackCmd
(some $ strArgument $ metavar "PACKAGE")
addCommand "update"
"Update the package index"
updateCmd
(pure ())
addCommand "exec"
"Execute a command"
execCmd
((,)
<$> strArgument (metavar "[--] CMD")
<*> many (strArgument (metavar "ARGS")))
addCommand "ghc"
"Run ghc"
execCmd
((,)
<$> pure "ghc"
<*> many (strArgument (metavar "ARGS")))
addCommand "ghci"
"Run ghci"
execCmd
((,)
<$> pure "ghci"
<*> many (strArgument (metavar "ARGS")))
addCommand "runghc"
"Run runghc"
execCmd
((,)
<$> pure "runghc"
<*> many (strArgument (metavar "ARGS")))
addCommand "clean"
"Clean the local packages"
cleanCmd
(pure ())
addCommand "deps"
"Install dependencies"
depsCmd
((,)
<$> (some (argument readPackageName
(metavar "[PACKAGES]")))
<*> (flag False True (long "dry-run" <>
help "Don't build anything, just prepare to")))
addSubCommands
"path"
"Print path information for certain things"
(do addCommand "ghc"
"Print path to the ghc executable in use"
pathCmd
(pure PathGhc)
addCommand "log"
"Print path to the log directory in use"
pathCmd
(pure PathLog)
addCommand "package-db"
"Print the package databases in use"
pathCmd
(pure PathPackageDb))
addSubCommands
Docker.dockerCmdName
"Subcommands specific to Docker use"
(do addCommand Docker.dockerPullCmdName
"Pull latest version of Docker image from registry"
dockerPullCmd
(pure ())
addCommand "reset"
"Reset the Docker sandbox"
dockerResetCmd
(flag False True (long "keep-home" <>
help "Do not delete sandbox's home directory"))
addCommand Docker.dockerCleanupCmdName
"Clean up Docker images and containers"
dockerCleanupCmd
dockerCleanupOpts
addCommand "exec"
"Execute a command in a Docker container without setting up Haskell environment first"
dockerExecCmd
((,) <$> strArgument (metavar "[--] CMD")
<*> many (strArgument (metavar "ARGS"))))
commandsFromPlugins plugins pluginShouldHaveRun)
run level `catch` \e -> do
-- This special handler stops "stack: " from being printed before the
-- exception
case fromException e of
Just ec -> exitWith ec
Nothing -> do
print e
exitFailure
where
dockerHelpOptName = Docker.dockerCmdName ++ "-help"
pathCmd :: PathArg -> GlobalOpts -> IO ()
pathCmd pathArg go@GlobalOpts{..} = do
(manager,lc) <- loadConfigWithOpts go
buildConfig <- runStackLoggingT manager globalLogLevel (lcLoadBuildConfig lc ExecStrategy)
runStackT manager globalLogLevel buildConfig (pathString pathArg) >>= putStrLn
-- Try to run a plugin
tryRunPlugin :: Plugins -> IO ()
tryRunPlugin plugins = do
args <- getArgs
case dropWhile (List.isPrefixOf "-") args of
((T.pack -> name):args')
| isJust (lookupPlugin plugins name) -> do
callPlugin plugins name args' `catch` onPluginErr
exitSuccess
_ -> return ()
-- TODO(danburton): use logger
onPluginErr :: PluginException -> IO ()
onPluginErr (PluginNotFound _ name) = do
T.hPutStr stderr $ "Stack plugin not found: " <> name
exitFailure
onPluginErr (PluginExitFailure _ i) = do
exitWith (ExitFailure i)
-- TODO(danburton): improve this, although it should never happen
pluginShouldHaveRun :: Plugin -> GlobalOpts -> IO ()
pluginShouldHaveRun _plugin _globalOpts = do
fail "Plugin should have run"
data SetupCmdOpts = SetupCmdOpts
{ scoGhcVersion :: !(Maybe Version)
, scoForceReinstall :: !Bool
}
setupParser :: Parser SetupCmdOpts
setupParser = SetupCmdOpts
<$> (optional $ argument readVersion (metavar "VERSION"))
<*> boolFlags False
"reinstall"
"Reinstall GHC, even if available (implies no-system-ghc)"
idm
where
readVersion = do
s <- readerAsk
case parseVersionFromString s of
Nothing -> readerError $ "Invalid version: " ++ s
Just x -> return x
setupCmd :: SetupCmdOpts -> GlobalOpts -> IO ()
setupCmd SetupCmdOpts{..} go@GlobalOpts{..} = do
(manager,lc) <- loadConfigWithOpts go
runStackLoggingT manager globalLogLevel $
Docker.rerunWithOptionalContainer
(lcConfig lc)
(lcProjectRoot lc)
(runStackLoggingT manager globalLogLevel $ do
(ghc, mstack) <-
case scoGhcVersion of
Just v -> return (v, Nothing)
Nothing -> do
bc <- lcLoadBuildConfig lc ThrowException
return (bcGhcVersion bc, Just $ bcStackYaml bc)
mpaths <- runStackT manager globalLogLevel (lcConfig lc) $ ensureGHC SetupOpts
{ soptsInstallIfMissing = True
, soptsUseSystem = globalSystemGhc && not scoForceReinstall
, soptsExpected = ghc
, soptsStackYaml = mstack
, soptsForceReinstall = scoForceReinstall
}
case mpaths of
Nothing -> $logInfo "GHC on PATH would be used"
Just paths -> $logInfo $ "Would add the following to PATH: "
<> T.pack (intercalate [searchPathSeparator] paths)
)
withBuildConfig :: GlobalOpts
-> NoBuildConfigStrategy
-> StackT BuildConfig IO ()
-> IO ()
withBuildConfig go@GlobalOpts{..} strat inner = do
(manager, lc) <- loadConfigWithOpts go
runStackLoggingT manager globalLogLevel $
Docker.rerunWithOptionalContainer (lcConfig lc) (lcProjectRoot lc) $ do
bconfig1 <- runStackLoggingT manager globalLogLevel $
lcLoadBuildConfig lc strat
bconfig2 <- runStackT manager globalLogLevel bconfig1 $
setupEnv globalSystemGhc globalInstallGhc
runStackT manager globalLogLevel bconfig2 inner
cleanCmd :: () -> GlobalOpts -> IO ()
cleanCmd () go = withBuildConfig go ThrowException clean
-- | Install dependencies
depsCmd :: ([PackageName], Bool) -> GlobalOpts -> IO ()
depsCmd (names, dryRun) go@GlobalOpts{..} = withBuildConfig go ExecStrategy $
Stack.Build.build BuildOpts
{ boptsTargets = Right names
, boptsLibProfile = False
, boptsExeProfile = False
, boptsEnableOptimizations = Nothing
, boptsFinalAction = DoNothing
, boptsDryrun = dryRun
, boptsGhcOptions = []
, boptsFlags = Map.empty
}
-- | Parser for package names
readPackageName :: ReadM PackageName
readPackageName = do
s <- readerAsk
case parsePackageNameFromString s of
Nothing -> readerError $ "Invalid package name: " ++ s
Just x -> return x
-- | Parser for package:[-]flag
readFlag :: ReadM (Map PackageName (Map FlagName Bool))
readFlag = do
s <- readerAsk
case break (== ':') s of
(pn, ':':mflag) -> do
pn' <-
case parsePackageNameFromString pn of
Nothing -> readerError $ "Invalid package name: " ++ pn
Just x -> return x
let (b, flagS) =
case mflag of
'-':x -> (False, x)
_ -> (True, mflag)
flagN <-
case parseFlagNameFromString flagS of
Nothing -> readerError $ "Invalid flag name: " ++ flagS
Just x -> return x
return $ Map.singleton pn' $ Map.singleton flagN b
_ -> readerError "Must have a colon"
-- | Build the project.
buildCmd :: FinalAction -> BuildOpts -> GlobalOpts -> IO ()
buildCmd finalAction opts go@GlobalOpts{..} = withBuildConfig go CreateConfig $
Stack.Build.build opts { boptsFinalAction = finalAction }
-- | Unpack packages to the filesystem
unpackCmd :: [String] -> GlobalOpts -> IO ()
unpackCmd names go@GlobalOpts{..} = do
(manager,lc) <- loadConfigWithOpts go
runStackLoggingT manager globalLogLevel $
Docker.rerunWithOptionalContainer (lcConfig lc) (lcProjectRoot lc) $
runStackT manager globalLogLevel (lcConfig lc) $ do
menv <- getMinimalEnvOverride
Stack.Fetch.unpackPackages menv "." names
-- | Update the package index
updateCmd :: () -> GlobalOpts -> IO ()
updateCmd () go@GlobalOpts{..} = do
(manager,lc) <- loadConfigWithOpts go
runStackLoggingT manager globalLogLevel $
Docker.rerunWithOptionalContainer (lcConfig lc) (lcProjectRoot lc) $
runStackT manager globalLogLevel (lcConfig lc) $
getMinimalEnvOverride >>= Stack.PackageIndex.updateAllIndices
-- | Execute a command
execCmd :: (String, [String]) -> GlobalOpts -> IO ()
execCmd (cmd, args) go@GlobalOpts{..} = withBuildConfig go ExecStrategy $ do
config <- asks getConfig
liftIO $ do
menv <- configEnvOverride config
EnvSettings
{ esIncludeLocals = True
, esIncludeGhcPackagePath = True
}
cmd' <- join $ System.Process.Read.findExecutable menv cmd
let cp = (P.proc (toFilePath cmd') args)
{ P.env = envHelper menv
, P.delegate_ctlc = True
}
(Nothing, Nothing, Nothing, ph) <- P.createProcess cp
ec <- P.waitForProcess ph
exitWith ec
-- | Pull the current Docker image.
dockerPullCmd :: () -> GlobalOpts -> IO ()
dockerPullCmd _ go@GlobalOpts{..} = do
(manager,lc) <- liftIO $ loadConfigWithOpts go
runStackLoggingT manager globalLogLevel $ Docker.preventInContainer $
Docker.pull (lcConfig lc)
-- | Reset the Docker sandbox.
dockerResetCmd :: Bool -> GlobalOpts -> IO ()
dockerResetCmd keepHome go@GlobalOpts{..} = do
(manager,lc) <- liftIO (loadConfigWithOpts go)
runStackLoggingT manager globalLogLevel $ Docker.preventInContainer $
Docker.reset (lcProjectRoot lc) keepHome
-- | Cleanup Docker images and containers.
dockerCleanupCmd :: Docker.CleanupOpts -> GlobalOpts -> IO ()
dockerCleanupCmd cleanupOpts go@GlobalOpts{..} = do
(manager,lc) <- liftIO $ loadConfigWithOpts go
runStackLoggingT manager globalLogLevel $ Docker.preventInContainer $
Docker.cleanup (lcConfig lc) cleanupOpts
-- | Execute a command
dockerExecCmd :: (String, [String]) -> GlobalOpts -> IO ()
dockerExecCmd (cmd,args) go@GlobalOpts{..} = do
(manager,lc) <- liftIO $ loadConfigWithOpts go
runStackLoggingT manager globalLogLevel $ Docker.preventInContainer $
Docker.rerunCmdWithRequiredContainer (lcConfig lc)
(lcProjectRoot lc)
(return (cmd,args,lcConfig lc))
-- | Parser for build arguments.
buildOpts :: Parser BuildOpts
buildOpts = BuildOpts <$> target <*> libProfiling <*> exeProfiling <*>
optimize <*> finalAction <*> dryRun <*> ghcOpts <*> flags
where optimize =
maybeBoolFlags "optimizations" "optimizations for TARGETs and all its dependencies" idm
target =
fmap (Left . map T.pack)
(many (strArgument
(metavar "TARGET" <>
help "If none specified, use all packages defined in current directory")))
libProfiling =
boolFlags False
"library-profiling"
"library profiling for TARGETs and all its dependencies"
idm
exeProfiling =
boolFlags False
"executable-profiling"
"library profiling for TARGETs and all its dependencies"
idm
finalAction = pure DoNothing
dryRun = flag False True (long "dry-run" <>
help "Don't build anything, just prepare to")
ghcOpts =
many (fmap T.pack
(strOption (long "ghc-options" <>
metavar "OPTION" <>
help "Additional options passed to GHC")))
flags =
fmap (Map.unionsWith Map.union) $ many
(option readFlag
( long "flag"
<> metavar "PACKAGE:[-]FLAG"
<> help "Override flags set in stack.yaml (applies to local packages and extra-deps)"
))
-- | Parser for docker cleanup arguments.
dockerCleanupOpts :: Parser Docker.CleanupOpts
dockerCleanupOpts =
Docker.CleanupOpts <$>
(flag' Docker.CleanupInteractive
(short 'i' <>
long "interactive" <>
help "Show cleanup plan in editor and allow changes (default)") <|>
flag' Docker.CleanupImmediate
(short 'y' <>
long "immediate" <>
help "Immediately execute cleanup plan") <|>
flag' Docker.CleanupDryRun
(short 'n' <>
long "dry-run" <>
help "Display cleanup plan but do not execute") <|>
pure Docker.CleanupInteractive) <*>
opt (Just 14) "known-images" "LAST-USED" <*>
opt Nothing "unknown-images" "CREATED" <*>
opt (Just 0) "dangling-images" "CREATED" <*>
opt Nothing "stopped-containers" "CREATED" <*>
opt Nothing "running-containers" "CREATED"
where opt def' name mv =
fmap Just
(option auto
(long name <>
metavar (mv ++ "-DAYS-AGO") <>
help ("Remove " ++
toDescr name ++
" " ++
map toLower (toDescr mv) ++
" N days ago" ++
case def' of
Just n -> " (default " ++ show n ++ ")"
Nothing -> ""))) <|>
flag' Nothing
(long ("no-" ++ name) <>
help ("Do not remove " ++
toDescr name ++
case def' of
Just _ -> ""
Nothing -> " (default)")) <|>
pure def'
toDescr = map (\c -> if c == '-' then ' ' else c)
-- | Parser for global command-line options.
globalOpts :: Parser GlobalOpts
globalOpts =
GlobalOpts
<$> logLevelOpt
<*> configOptsParser False
<*> boolFlags True
"system-ghc"
"using the system installed GHC (on the PATH) if available and a matching version"
idm
<*> boolFlags True
"install-ghc"
"downloading and installing GHC if necessary (can be done manually with stack setup)"
idm
-- | Parse for a logging level.
logLevelOpt :: Parser LogLevel
logLevelOpt =
fmap parse
(strOption (long "verbosity" <>
metavar "VERBOSITY" <>
help "Verbosity: silent, error, warn, info, debug")) <|>
flag defaultLogLevel
verboseLevel
(short 'v' <> long "verbose" <>
help ("Enable verbose mode: verbosity level \"" <> showLevel verboseLevel <> "\""))
where verboseLevel = LevelDebug
showLevel l =
case l of
LevelDebug -> "debug"
LevelInfo -> "info"
LevelWarn -> "warn"
LevelError -> "error"
LevelOther x -> T.unpack x
parse s =
case s of
"debug" -> LevelDebug
"info" -> LevelInfo
"warn" -> LevelWarn
"error" -> LevelError
_ -> LevelOther (T.pack s)
-- | Default logging level should be something useful but not crazy.
defaultLogLevel :: LogLevel
defaultLogLevel = LevelInfo
-- | Parsed global command-line options.
data GlobalOpts = GlobalOpts
{ globalLogLevel :: LogLevel -- ^ Log level
, globalConfigMonoid :: ConfigMonoid -- ^ Config monoid, for passing into 'loadConfig'
, globalSystemGhc :: Bool -- ^ Use system GHC if available and correct version?
, globalInstallGhc :: Bool -- ^ Install GHC if missing
} deriving (Show)
-- | Load the configuration with a manager. Convenience function used
-- throughout this module.
loadConfigWithOpts :: GlobalOpts -> IO (Manager,LoadConfig (StackLoggingT IO))
loadConfigWithOpts GlobalOpts{..} = do
manager <- newTLSManager
lc <- runStackLoggingT
manager
globalLogLevel
(loadConfig globalConfigMonoid)
return (manager,lc)
|
mietek/stack
|
src/main/Main.hs
|
bsd-3-clause
| 21,663 | 0 | 23 | 8,114 | 4,486 | 2,256 | 2,230 | 475 | 9 |
{-
Wrap.hs (adapted from wrap.c which is (c) Silicon Graphics, Inc)
Copyright (c) Sven Panne 2002-2005 <[email protected]>
This file is part of HOpenGL and distributed under a BSD-style license
See the file libraries/GLUT/LICENSE
This program texture maps a checkerboard image onto two rectangles. This
program demonstrates the wrapping modes, if the texture coordinates fall
outside 0.0 and 1.0. Interaction: Pressing the 's' and 'S' keys switch the
wrapping between clamping and repeating for the s parameter. The 't' and 'T'
keys control the wrapping for the t parameter.
Texture objects are only used when GL_EXT_texture_object is supported.
-}
import Control.Monad ( when )
import Data.Maybe ( isJust, listToMaybe )
import Data.Bits ( (.&.) )
import Foreign ( withArray )
import System.Exit ( exitWith, ExitCode(ExitSuccess) )
import Graphics.UI.GLUT
-- Create checkerboard image
checkImageSize :: TextureSize2D
checkImageSize = TextureSize2D 64 64
withCheckImage :: TextureSize2D -> GLsizei -> (GLubyte -> (Color4 GLubyte))
-> (PixelData (Color4 GLubyte) -> IO ()) -> IO ()
withCheckImage (TextureSize2D w h) n f act =
withArray [ f c |
i <- [ 0 .. w - 1 ],
j <- [ 0 .. h - 1 ],
let c | (i .&. n) == (j .&. n) = 0
| otherwise = 255 ] $
act. PixelData RGBA UnsignedByte
myInit :: IO (Maybe TextureObject)
myInit = do
clearColor $= Color4 0 0 0 0
shadeModel $= Flat
depthFunc $= Just Less
rowAlignment Unpack $= 1
exts <- get glExtensions
mbTexName <- if "GL_EXT_texture_object" `elem` exts
then fmap listToMaybe $ genObjectNames 1
else return Nothing
when (isJust mbTexName) $ textureBinding Texture2D $= mbTexName
textureWrapMode Texture2D S $= (Repeated, Repeat)
textureWrapMode Texture2D T $= (Repeated, Repeat)
textureFilter Texture2D $= ((Nearest, Nothing), Nearest)
withCheckImage checkImageSize 0x8 (\c -> Color4 c c c 255) $
texImage2D Nothing NoProxy 0 RGBA' checkImageSize 0
return mbTexName
display :: Maybe TextureObject -> DisplayCallback
display mbTexName = do
clear [ ColorBuffer, DepthBuffer ]
texture Texture2D $= Enabled
textureFunction $= Decal
when (isJust mbTexName) $ textureBinding Texture2D $= mbTexName
-- resolve overloading, not needed in "real" programs
let texCoord2f = texCoord :: TexCoord2 GLfloat -> IO ()
vertex3f = vertex :: Vertex3 GLfloat -> IO ()
renderPrimitive Quads $ do
texCoord2f (TexCoord2 0 0); vertex3f (Vertex3 (-2.0) (-1.0) 0.0 )
texCoord2f (TexCoord2 0 3); vertex3f (Vertex3 (-2.0) 1.0 0.0 )
texCoord2f (TexCoord2 3 3); vertex3f (Vertex3 0.0 1.0 0.0 )
texCoord2f (TexCoord2 3 0); vertex3f (Vertex3 0.0 (-1.0) 0.0 )
texCoord2f (TexCoord2 0 0); vertex3f (Vertex3 1.0 (-1.0) 0.0 )
texCoord2f (TexCoord2 0 3); vertex3f (Vertex3 1.0 1.0 0.0 )
texCoord2f (TexCoord2 3 3); vertex3f (Vertex3 2.41421 1.0 (-1.41421))
texCoord2f (TexCoord2 3 0); vertex3f (Vertex3 2.41421 (-1.0) (-1.41421))
flush
texture Texture2D $= Disabled
reshape :: ReshapeCallback
reshape size@(Size w h) = do
viewport $= (Position 0 0, size)
matrixMode $= Projection
loadIdentity
perspective 60 (fromIntegral w / fromIntegral h) 1 30
matrixMode $= Modelview 0
loadIdentity
translate (Vector3 0 0 (-3.6 :: GLfloat))
keyboard :: KeyboardMouseCallback
keyboard (Char 's' ) Down _ _ = setClamping S Clamp
keyboard (Char 'S' ) Down _ _ = setClamping S Repeat
keyboard (Char 't' ) Down _ _ = setClamping T Clamp
keyboard (Char 'T' ) Down _ _ = setClamping T Repeat
keyboard (Char '\27') Down _ _ = exitWith ExitSuccess
keyboard _ _ _ _ = return ()
setClamping :: TextureCoordName -> Clamping -> IO ()
setClamping coord clamp = do
textureWrapMode Texture2D coord $= (Repeated, clamp);
postRedisplay Nothing
main :: IO ()
main = do
(progName, _args) <- getArgsAndInitialize
initialDisplayMode $= [ SingleBuffered, RGBMode, WithDepthBuffer ]
initialWindowSize $= Size 250 250
initialWindowPosition $= Position 100 100
createWindow progName
mbTexName <- myInit
displayCallback $= display mbTexName
reshapeCallback $= Just reshape
keyboardMouseCallback $= Just keyboard
mainLoop
|
FranklinChen/hugs98-plus-Sep2006
|
packages/GLUT/examples/RedBook/Wrap.hs
|
bsd-3-clause
| 4,458 | 0 | 18 | 1,088 | 1,360 | 659 | 701 | 85 | 2 |
{-# LANGUAGE FlexibleInstances, GeneralizedNewtypeDeriving, TypeSynonymInstances #-}
module Folly.DSL
( module Folly.FOL
, module Folly.DSL
) where
import Control.Monad
import Control.Monad.State
import Control.Applicative hiding (empty)
import Folly.FOL hiding
((===),(!=),(&),(/\),(\/),(==>),(<=>),mkBinOp,forall',exists')
newtype Folly a = Folly { runFolly :: State [String] a }
deriving (Monad,MonadState [String],Functor,Applicative)
run :: Folly a -> a
run m = evalState (runFolly m) vars
where vars = ((`replicateM` "XYZABCUVW") =<< [1..])
newVar :: Folly String
newVar = do
v:vs <- get
put vs
return v
constant :: String -> Folly Term
constant n = return (Fun n [])
unary :: String -> Folly Term -> Folly Term
unary n = liftM (Fun n . pure)
binary :: String -> Folly Term -> Folly Term -> Folly Term
binary n = liftM2 (\x y -> Fun n [x,y])
trinary :: String -> Folly Term -> Folly Term -> Folly Term -> Folly Term
trinary n = liftM3 (\x y z -> Fun n [x,y,z])
satsbokstav:: String -> Folly Formula
satsbokstav n = return (Rel n [])
predicate :: String -> Folly Term -> Folly Formula
predicate n = liftM (Rel n . pure)
relation :: String -> Folly Term -> Folly Term -> Folly Formula
relation n = liftM2 (\x y -> Rel n [x,y])
trinaryRel :: String -> Folly Term -> Folly Term -> Folly Term -> Folly Formula
trinaryRel n = liftM3 (\x y z -> Rel n [x,y,z])
mkBinOp :: BinOp -> Folly Formula -> Folly Formula -> Folly Formula
mkBinOp op = liftM2 (\f g -> BinOp f op g)
infix 4 ===
infix 4 !=
infixr 3 &
infixr 3 /\
infixr 2 \/
infixr 1 ==>
infix 1 <=>
(==>), (&), (/\), (\/), (<=>) :: Folly Formula -> Folly Formula -> Folly Formula
(==>) = mkBinOp (:=>)
(&) = mkBinOp (:&)
(/\) = mkBinOp (:&)
(\/) = mkBinOp (:|)
(<=>) = mkBinOp (:<=>)
(===),(!=) :: Folly Term -> Folly Term -> Folly Formula
(===) = liftM2 (\ f g -> EqOp f (:==) g)
(!=) = liftM2 (\ f g -> EqOp f (:!=) g)
neg :: Folly Formula -> Folly Formula
neg = fmap Neg
axiom,conjecture,question,lemma,hypothesis,definition :: String -> Folly Formula -> Decl
[axiom,conjecture,question,lemma,hypothesis,definition] =
map (\ t s f -> Decl t s (run f))
[ Axiom, Conjecture, Question, Lemma, Hypothesis, Definition ]
axiom',conjecture',question',lemma',hypothesis',definition' :: Folly Formula -> Decl
[axiom',conjecture',question',lemma',hypothesis',definition']
= map ($ "x") [axiom,conjecture,question,lemma,hypothesis,definition]
class Quantifier t where
quantifier
:: Quant -- ^ quantifier, Forall or Exists
-> [String] -- ^ accumulated used variables
-> t -- ^ Formula or (Term -> t)
-> Folly Formula -- ^ resulting formula
instance Quantifier (Folly Formula) where
quantifier q acc f = Quant q (reverse acc) <$> f
instance Quantifier r => Quantifier (Folly Term -> r) where
quantifier q acc f = do
v <- newVar
quantifier q (v:acc) (f (return (Var v)))
forall' :: Quantifier t => t -> Folly Formula
forall' = quantifier Forall []
exists' :: Quantifier t => t -> Folly Formula
exists' = quantifier Exists []
-- * Combinators
commutativeOver (~~) (#) x y = (x # y) ~~ (y # x)
commutative = commutativeOver (===)
associativeOver (~~) (#) x y z = (x # (y # z)) ~~ ((x # y) # z)
associative = associativeOver (===)
identityOver (~~) (#) c x = (x # c) ~~ x /\ (c # x) ~~ x
identity = identityOver (===)
isZeroOver (~~) (#) c x = (x # c) ~~ c /\ (c # x) ~~ c
isZero = isZeroOver (===)
distributesOver (~~) (*) (+) x y z = (x * (y + z)) ~~ ((x * y) + (x * z))
distributes = distributesOver (===)
|
danr/folly
|
Folly/DSL.hs
|
bsd-3-clause
| 3,629 | 0 | 14 | 789 | 1,610 | 899 | 711 | 88 | 1 |
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE RecursiveDo #-}
{-# LANGUAGE Trustworthy #-}
module GHC.Event.NoIO(
ensureIOManagerIsRunning
, ioManagerCapabilitiesChanged
, threadDelay
, registerDelay
, threadWaitRead
, threadWaitReadSTM
, threadWaitWrite
, threadWaitWriteSTM
, closeFdWith
)
where
import Data.Maybe(Maybe(..))
import Foreign.Marshal.Alloc
import Foreign.Storable(peek)
import Foreign.StablePtr(StablePtr, newStablePtr, deRefStablePtr, freeStablePtr)
import GHC.Base
import GHC.Conc.Sync(TVar, atomically, newTVar, writeTVar, forkIO, STM, yield)
import GHC.MVar(MVar, newEmptyMVar, takeMVar, putMVar)
import Foreign.C.String
import Foreign.Ptr
import System.Posix.Types(Fd)
ensureIOManagerIsRunning :: IO ()
ensureIOManagerIsRunning =
do ptr <- malloc
_ <- forkIO (ioManager ptr)
return ()
ioManager :: Ptr (StablePtr (IO ())) -> IO ()
ioManager ptr =
forever $ do waitTime <- waitForWaiter ptr
if waitTime == 0
then runWaiter
else do yield
waitTime <- waitForWaiter ptr
if waitTime == 0
then runWaiter
else sleepUntilWaiter waitTime
where
runWaiter =
do sp <- peek ptr
action <- deRefStablePtr sp
_ <- forkIO action
return ()
forever :: (Monad m) => m a -> m b
{-# INLINE forever #-}
forever a = let a' = a >> a' in a'
ioManagerCapabilitiesChanged :: IO ()
ioManagerCapabilitiesChanged = return ()
-- The following two functions are obvious candidates for mdo/fixIO,
-- but importing either causes circular dependency problems
threadDelay :: Int -> IO ()
threadDelay usecs =
do wait <- newEmptyMVar
spMV <- newEmptyMVar
sp <- newStablePtr (do putMVar wait ()
sp' <- takeMVar spMV
freeStablePtr sp')
putMVar spMV sp
registerWaiter usecs sp
takeMVar wait
registerDelay :: Int -> IO (TVar Bool)
registerDelay usecs =
do t <- atomically $ newTVar False
spMV <- newEmptyMVar
sp <- newStablePtr (do atomically (writeTVar t True)
sp' <- takeMVar spMV
freeStablePtr sp')
putMVar spMV sp
registerWaiter usecs sp
return t
threadWaitRead :: Fd -> IO ()
threadWaitRead _ = return ()
threadWaitWrite :: Fd -> IO ()
threadWaitWrite _ = return ()
threadWaitReadSTM :: Fd -> IO (STM (), IO ())
threadWaitReadSTM _ = return (return (), return ())
threadWaitWriteSTM :: Fd -> IO (STM (), IO ())
threadWaitWriteSTM _ = return (return (), return ())
closeFdWith :: (Fd -> IO ()) -> Fd -> IO ()
closeFdWith close fd = close fd
foreign import ccall unsafe "registerWaiter"
registerWaiter :: Int -> StablePtr (IO ()) -> IO ()
foreign import ccall unsafe "waitForWaiter"
waitForWaiter :: Ptr (StablePtr (IO ())) -> IO Word
foreign import ccall safe "sleepUntilWaiter"
sleepUntilWaiter :: Word -> IO ()
|
GaloisInc/halvm-ghc
|
libraries/base/GHC/Event/NoIO.hs
|
bsd-3-clause
| 3,137 | 0 | 14 | 886 | 939 | 470 | 469 | 85 | 3 |
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE TemplateHaskell #-}
module NN.Backend.Torch.Torch where
import Data.Word
import Gen.Caffe.ConvolutionParameter as CP
import Gen.Caffe.DropoutParameter as DP
import Gen.Caffe.InnerProductParameter as IP
import Gen.Caffe.LayerParameter as LP
import Gen.Caffe.PoolingParameter as PP
import Gen.Caffe.PoolingParameter.PoolMethod as PP
import Control.Applicative
import Control.Lens
import Data.Graph.Inductive.Graph hiding ((&))
import Language.Lua.Syntax hiding (Concat)
import NN.Backend.Torch.Lua
import NN.DSL
-- Modules are either sequential or criterion - which are treated
-- differently by Torch
data Module a = Criterion a | Inner a deriving (Functor, Show)
data TorchModule = TorchModule Name Name [Exp] deriving (Show)
inners :: [Module a] -> [a]
inners xs = [a | Inner a <- xs]
criteria :: [Module a] -> [a]
criteria xs = [a | Criterion a <- xs]
torchExp :: TorchModule -> Exp
torchExp module' = PrefixExp (PEFunCall (construct module'))
where
construct (TorchModule luaModule torchModule args) =
NormalFunCall (PEVar (SelectName (var luaModule) torchModule)) (Args args)
convolutionImpl :: Maybe Word32 -> String
convolutionImpl Nothing = "SpatialConvolutionMM"
convolutionImpl (Just kW) = if kW > 5 then "SpatialConvolutionFFT" else "SpatialConvolutionMM"
torchModules :: LayerParameter -> [Module TorchModule]
torchModules lp = go (layerTy lp)
where
nn name' args = Inner $ TorchModule "nn" name' (toLua <$> args)
criterion name' = Criterion $ TorchModule "nn" name' []
nn' name' = nn name' ([] :: [Float])
-- Ugly case anaysis, sorry.
go Pool = [nn ty' [kW, kH, dW, dH]]
where
kW = poolP PP.kernel_size
kH = kW
dW = poolP PP.stride
dH = dW
ty' = case poolP PP.pool of
Just MAX -> "SpatialMaxPooling"
Just AVE -> "SpatialAveragePooling"
_ -> error "Unsupported Pooling Type"
poolP f = lp ^?! LP.pooling_param._Just ^?! f
go Conv = [nn (convolutionImpl kW) [nInputPlane, nOutputPlane, kW, kH, dW, dH, padding]]
where
kW = convP CP.kernel_size
kH = kW
dW = convP CP.stride
dH = dW
padding = convP CP.pad
-- TODO - propagation pass to size the layers
nInputPlane = Nothing
nOutputPlane = convP CP.num_output
convP f = lp ^?! LP.convolution_param._Just ^?! f
go ReLU = [nn' "Threshold"]
go IP = [nn "Linear" [nInput, nOutput]]
where
-- TODO - propagation pass to size the layers
nInput = Nothing
nOutput = lp ^?! LP.inner_product_param._Just ^?! IP.num_output
go Dropout = [nn "Dropout" [ratio]] where
Just ratio = lp ^?! LP.dropout_param._Just ^?! DP.dropout_ratio
go SoftmaxWithLoss = [nn' "LogSoftMax", criterion "ClassNLLCriterion"]
go Concat = [] -- Handled by flattening implementation
go ty' = error $ "Unhandled layer type: " ++ show ty'
torchLayers :: [LayerTy]
torchLayers = [Pool, Conv, ReLU, IP, Dropout, SoftmaxWithLoss, Concat]
clean :: Net -> Net
clean gr = foldl (flip delNode) gr toDelete
where
toDelete = filter (\n -> layerTy (label n) `notElem` torchLayers) (nodes gr)
label n = lab' (context gr n)
|
ajtulloch/dnngraph
|
NN/Backend/Torch/Torch.hs
|
bsd-3-clause
| 3,617 | 0 | 13 | 1,090 | 1,004 | 550 | 454 | -1 | -1 |
{-# LANGUAGE RecordWildCards #-}
-----------------------------------------------------------------------------
-- |
-- Module : XMonad.Hooks.DynamicIcons
-- Description : Dynamically update workspace names based on its contents\/windows on it.
-- Copyright : (c) Will Pierlot <[email protected]>
-- License : BSD3-style (see LICENSE)
--
-- Maintainer : Will Pierlot <[email protected]>
-- Stability : unstable
-- Portability : unportable
--
-- Dynamically augment workspace names logged to a status bar
-- based on the contents (windows) of the workspace.
-----------------------------------------------------------------------------
module XMonad.Hooks.DynamicIcons (
-- * Usage
-- $usage
-- * Creating Dynamic Icons
iconsPP, dynamicLogIconsWithPP, appIcon,
-- * Customization
dynamicIconsPP, getWorkspaceIcons,
IconConfig(..),
iconsFmtAppend, iconsFmtReplace, wrapUnwords,
iconsGetAll, iconsGetFocus,
) where
import XMonad
import qualified XMonad.StackSet as S
import qualified Data.Map as M
import XMonad.Hooks.StatusBar.PP
import XMonad.Prelude (for, maybeToList, (<&>), (<=<), (>=>))
-- $usage
-- Dynamically augment Workspace's 'WorkspaceId' as shown on a status bar
-- based on the 'Window's inside the Workspace.
--
-- Icons are specified by a @Query [String]@, which is something like a
-- 'ManageHook' (and uses the same syntax) that returns a list of 'String's
-- (icons). This 'Query' is evaluated for each window and the results are
-- joined together. 'appIcon' is a useful shortcut here.
--
-- For example:
--
-- > myIcons :: Query [String]
-- > myIcons = composeAll
-- > [ className =? "discord" --> appIcon "\xfb6e"
-- > , className =? "Discord" --> appIcon "\xf268"
-- > , className =? "Firefox" --> appIcon "\63288"
-- > , className =? "Spotify" <||> className =? "spotify" --> appIcon "阮"
-- > ]
--
-- then you can add it to your "XMonad.Hooks.StatusBar" config:
--
-- > myBar = statusBarProp "xmobar" (iconsPP myIcons myPP)
-- > main = xmonad . withSB myBar $ … $ def
--
-- Here is an example of this
--
-- <<https://user-images.githubusercontent.com/300342/111010930-36a54300-8398-11eb-8aec-b3059b04fa31.png>>
--
-- Note: You can use any string you want here.
-- The example shown here uses NerdFont Icons to represent open applications.
--
-- If you want to customize formatting and/or combine this with other
-- 'PP' extensions like "XMonad.Util.ClickableWorkspaces", here's a more
-- advanced example how to do that:
--
-- > myIconConfig = def{ iconConfigIcons = myIcons, iconConfigFmt = iconsFmtAppend concat }
-- > myBar = statusBarProp "xmobar" (clickablePP =<< dynamicIconsPP myIconConfig myPP)
-- > main = xmonad . withSB myBar . … $ def
--
-- This can be also used with "XMonad.Hooks.DynamicLog":
--
-- > main = xmonad $ … $ def
-- > { logHook = dynamicLogIconsWithPP myIcons xmobarPP
-- > , … }
--
-- or with more customziation:
--
-- > myIconConfig = def{ iconConfigIcons = myIcons, iconConfigFmt = iconsFmtAppend concat }
-- > main = xmonad $ … $ def
-- > { logHook = xmonadPropLog =<< dynamicLogString =<< clickablePP =<<
-- > dynamicIconsPP myIconConfig xmobarPP
-- > , … }
-- | Shortcut for configuring single icons.
appIcon :: String -> Query [String]
appIcon = pure . pure
-- | Adjusts the 'PP' and then runs 'dynamicLogWithPP'
dynamicLogIconsWithPP :: Query [String] -- ^ The 'IconSet' to use
-> PP -- ^ The 'PP' to alter
-> X () -- ^ The resulting 'X' action
dynamicLogIconsWithPP q = dynamicLogWithPP <=< iconsPP q
-- | Adjusts the 'PP' with the given 'IconSet'
iconsPP :: Query [String] -- ^ The 'IconSet' to use
-> PP -- ^ The 'PP' to alter
-> X PP -- ^ The resulting 'X PP'
iconsPP q = dynamicIconsPP def{ iconConfigIcons = q }
-- | Modify a pretty-printer, 'PP', to augment
-- workspace names with icons based on the contents (windows) of the workspace.
dynamicIconsPP :: IconConfig -> PP -> X PP
dynamicIconsPP ic pp = getWorkspaceIcons ic <&> \ren -> pp{ ppRename = ppRename pp >=> ren }
-- | Returns a function for 'ppRename' that augments workspaces with icons
-- according to the provided 'IconConfig'.
getWorkspaceIcons :: IconConfig -> X (String -> WindowSpace -> String)
getWorkspaceIcons conf@IconConfig{..} = fmt <$> getWorkspaceIcons' conf
where
fmt icons s w = iconConfigFmt s (M.findWithDefault [] (S.tag w) icons)
getWorkspaceIcons' :: IconConfig -> X (M.Map WorkspaceId [String])
getWorkspaceIcons' IconConfig{..} = do
ws <- gets (S.workspaces . windowset)
is <- for ws $ foldMap (runQuery iconConfigIcons) <=< iconConfigFilter . S.stack
pure $ M.fromList (zip (map S.tag ws) is)
-- | Datatype for expanded 'Icon' configurations
data IconConfig = IconConfig
{ iconConfigIcons :: Query [String]
-- ^ What icons to use for each window.
, iconConfigFmt :: WorkspaceId -> [String] -> String
-- ^ How to format the result, see 'iconsFmtReplace', 'iconsFmtAppend'.
, iconConfigFilter :: Maybe (S.Stack Window) -> X [Window]
-- ^ Which windows (icons) to show.
}
instance Default IconConfig where
def = IconConfig
{ iconConfigIcons = mempty
, iconConfigFmt = iconsFmtReplace (wrapUnwords "{" "}")
, iconConfigFilter = iconsGetAll
}
-- | 'iconConfigFmt' that replaces the workspace name with icons, if any.
--
-- First parameter specifies how to concatenate multiple icons. Useful values
-- include: 'concat', 'unwords', 'wrapUnwords'.
--
-- ==== __Examples__
--
-- >>> iconsFmtReplace concat "1" []
-- "1"
--
-- >>> iconsFmtReplace concat "1" ["A", "B"]
-- "AB"
--
-- >>> iconsFmtReplace (wrapUnwords "{" "}") "1" ["A", "B"]
-- "{A B}"
iconsFmtReplace :: ([String] -> String) -> WorkspaceId -> [String] -> String
iconsFmtReplace cat ws is | null is = ws
| otherwise = cat is
-- | 'iconConfigFmt' that appends icons to the workspace name.
--
-- First parameter specifies how to concatenate multiple icons. Useful values
-- include: 'concat', 'unwords', 'wrapUnwords'.
--
-- ==== __Examples__
--
-- >>> iconsFmtAppend concat "1" []
-- "1"
--
-- >>> iconsFmtAppend concat "1" ["A", "B"]
-- "1:AB"
iconsFmtAppend :: ([String] -> String) -> WorkspaceId -> [String] -> String
iconsFmtAppend cat ws is | null is = ws
| otherwise = ws ++ ':' : cat is
-- | Join words with spaces, and wrap the result in delimiters unless there
-- was exactly one element.
--
-- ==== __Examples__
--
-- >>> wrapUnwords "{" "}" ["A", "B"]
-- "{A B}"
--
-- >>> wrapUnwords "{" "}" ["A"]
-- "A"
--
-- >>> wrapUnwords "{" "}" []
-- ""
wrapUnwords :: String -> String -> [String] -> String
wrapUnwords _ _ [x] = x
wrapUnwords l r xs = wrap l r (unwords xs)
-- | 'iconConfigFilter' that shows all windows of every workspace.
iconsGetAll :: Maybe (S.Stack Window) -> X [Window]
iconsGetAll = pure . S.integrate'
-- | 'iconConfigFilter' that shows only the focused window for each workspace.
iconsGetFocus :: Maybe (S.Stack Window) -> X [Window]
iconsGetFocus = pure . maybeToList . fmap S.focus
|
xmonad/xmonad-contrib
|
XMonad/Hooks/DynamicIcons.hs
|
bsd-3-clause
| 7,155 | 0 | 13 | 1,403 | 981 | 582 | 399 | -1 | -1 |
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TypeSynonymInstances #-}
-- | Keeps the tracing API calls separate from the Tracer implementation,
-- which allows us to avoid a nasty import cycle between tracing and
-- the messaging primitives that rely on it, and also between the node
-- controller (which requires access to the tracing related elements of
-- our RemoteTable) and the Debug module, which requires @forkProcess@.
-- This module is also used by the management agent, which relies on the
-- tracing infrastructure's messaging fabric.
module Control.Distributed.Process.Management.Internal.Trace.Primitives
( -- * Sending Trace Data
traceLog
, traceLogFmt
, traceMessage
-- * Configuring A Tracer
, defaultTraceFlags
, enableTrace
, enableTraceAsync
, disableTrace
, disableTraceAsync
, getTraceFlags
, setTraceFlags
, setTraceFlagsAsync
, traceOnly
, traceOn
, traceOff
, withLocalTracer
, withRegisteredTracer
) where
import Control.Applicative
import Control.Distributed.Process.Internal.Primitives
( whereis
, newChan
, receiveChan
, die
)
import Control.Distributed.Process.Management.Internal.Trace.Types
( TraceArg(..)
, TraceFlags(..)
, TraceOk(..)
, TraceSubject(..)
, defaultTraceFlags
)
import qualified Control.Distributed.Process.Management.Internal.Trace.Types as Tracer
( traceLog
, traceLogFmt
, traceMessage
, enableTrace
, enableTraceSync
, disableTrace
, disableTraceSync
, setTraceFlags
, setTraceFlagsSync
, getTraceFlags
, getCurrentTraceClient
)
import Control.Distributed.Process.Internal.Types
( Process
, ProcessId
, LocalProcess(..)
, LocalNode(localEventBus)
, SendPort
, MxEventBus(..)
)
import Control.Distributed.Process.Serializable
import Control.Monad.IO.Class (liftIO)
import Control.Monad.Reader (ask)
import qualified Data.Set as Set (fromList)
import Prelude
--------------------------------------------------------------------------------
-- Main API --
--------------------------------------------------------------------------------
-- | Converts a list of identifiers (that can be
-- mapped to process ids), to a 'TraceSubject'.
class Traceable a where
uod :: [a] -> TraceSubject
instance Traceable ProcessId where
uod = TraceProcs . Set.fromList
instance Traceable String where
uod = TraceNames . Set.fromList
-- | Turn tracing for for a subset of trace targets.
traceOnly :: Traceable a => [a] -> Maybe TraceSubject
traceOnly = Just . uod
-- | Trace all targets.
traceOn :: Maybe TraceSubject
traceOn = Just TraceAll
-- | Trace no targets.
traceOff :: Maybe TraceSubject
traceOff = Nothing
-- | Enable tracing to the supplied process.
enableTraceAsync :: ProcessId -> Process ()
enableTraceAsync pid = withLocalTracer $ \t -> liftIO $ Tracer.enableTrace t pid
-- TODO: refactor _Sync versions of trace configuration functions...
-- | Enable tracing to the supplied process and wait for a @TraceOk@
-- response from the trace coordinator process.
enableTrace :: ProcessId -> Process ()
enableTrace pid =
withLocalTracerSync $ \t sp -> Tracer.enableTraceSync t sp pid
-- | Disable the currently configured trace.
disableTraceAsync :: Process ()
disableTraceAsync = withLocalTracer $ \t -> liftIO $ Tracer.disableTrace t
-- | Disable the currently configured trace and wait for a @TraceOk@
-- response from the trace coordinator process.
disableTrace :: Process ()
disableTrace =
withLocalTracerSync $ \t sp -> Tracer.disableTraceSync t sp
getTraceFlags :: Process TraceFlags
getTraceFlags = do
(sp, rp) <- newChan
withLocalTracer $ \t -> liftIO $ Tracer.getTraceFlags t sp
receiveChan rp
-- | Set the given flags for the current tracer.
setTraceFlagsAsync :: TraceFlags -> Process ()
setTraceFlagsAsync f = withLocalTracer $ \t -> liftIO $ Tracer.setTraceFlags t f
-- | Set the given flags for the current tracer and wait for a @TraceOk@
-- response from the trace coordinator process.
setTraceFlags :: TraceFlags -> Process ()
setTraceFlags f =
withLocalTracerSync $ \t sp -> Tracer.setTraceFlagsSync t sp f
-- | Send a log message to the internal tracing facility. If tracing is
-- enabled, this will create a custom trace log event.
--
traceLog :: String -> Process ()
traceLog s = withLocalTracer $ \t -> liftIO $ Tracer.traceLog t s
-- | Send a log message to the internal tracing facility, using the given
-- list of printable 'TraceArg's interspersed with the preceding delimiter.
--
traceLogFmt :: String -> [TraceArg] -> Process ()
traceLogFmt d ls = withLocalTracer $ \t -> liftIO $ Tracer.traceLogFmt t d ls
-- | Send an arbitrary 'Message' to the tracer process.
traceMessage :: Serializable m => m -> Process ()
traceMessage msg = withLocalTracer $ \t -> liftIO $ Tracer.traceMessage t msg
withLocalTracer :: (MxEventBus -> Process ()) -> Process ()
withLocalTracer act = do
node <- processNode <$> ask
act (localEventBus node)
withLocalTracerSync :: (MxEventBus -> SendPort TraceOk -> IO ()) -> Process ()
withLocalTracerSync act = do
(sp, rp) <- newChan
withLocalTracer $ \t -> liftIO $ (act t sp)
TraceOk <- receiveChan rp
return ()
withRegisteredTracer :: (ProcessId -> Process a) -> Process a
withRegisteredTracer act = do
(sp, rp) <- newChan
withLocalTracer $ \t -> liftIO $ Tracer.getCurrentTraceClient t sp
currentTracer <- receiveChan rp
case currentTracer of
Nothing -> do mTP <- whereis "tracer.initial"
-- NB: this should NOT ever happen, but forcing pattern matches
-- is not considered cool in later versions of MonadFail
case mTP of
Just p' -> act p'
Nothing -> die $ "System Invariant Violation: Tracer Process "
++ "Name Not Found (whereis tracer.initial)"
(Just p) -> act p
|
haskell-distributed/distributed-process
|
src/Control/Distributed/Process/Management/Internal/Trace/Primitives.hs
|
bsd-3-clause
| 5,940 | 0 | 16 | 1,180 | 1,155 | 643 | 512 | 116 | 3 |
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleContexts #-}
module EFA.Signal.Record where
import qualified EFA.Signal.Signal as S
import qualified EFA.Signal.Data as D
import qualified EFA.Signal.Vector as V
import EFA.Signal.Signal
(TC(TC),
Range(Range),
Scalar,
Signal,
FSignal,
TSignal,
-- TSigL,
UTSignal,
TSignal,
TSample,
PSample,
PSample1,
PSample2,
-- TSamp,
-- PSamp,
-- PSamp1L,
-- PSamp2LL,
FDistrib)
-- UTDistr,
-- FDistr)
import EFA.Signal.Typ (Typ,
A,
D,
P,
T,
Tt,
UT,
F,
--D
)
import EFA.Signal.Data (Data(Data),
(:>),
Nil)
import qualified EFA.Equation.Arithmetic as Arith
import EFA.Equation.Arithmetic
(Sum, (~+), (~-), Product, (~*), (~/), Constant, abs)
import qualified EFA.Flow.Topology.Index as Idx
import qualified EFA.Graph.Topology.Node as Node
import qualified EFA.Graph.Topology as Topo
import qualified EFA.Graph as Graph
import qualified EFA.Report.Format as Format
import EFA.Report.FormatValue (formatTopologyPosition)
import EFA.Report.Report (ToTable(toTable), Table(..), tvcat)
import EFA.Report.Typ (TDisp, getDisplayTypName)
import EFA.Report.Base (DispStorage1)
import Text.Printf (PrintfArg)
import qualified Test.QuickCheck as QC
import System.Random (Random)
import qualified Data.Map as Map ; import Data.Map (Map)
import qualified Data.Set as Set ; import Data.Set (Set)
import qualified Data.List as List
import qualified Data.Foldable as Fold
import qualified Data.List.HT as ListHT
import qualified Data.List.Key as Key
import qualified Data.List.Match as Match
import qualified Data.NonEmpty as NonEmpty; import Data.NonEmpty ((!:))
import Control.Monad (liftM2)
import Data.Ratio (Ratio, (%))
import Data.Foldable (foldMap)
import Data.List (transpose)
import Data.Tuple.HT (mapFst)
import Data.Ord.HT (inRange)
import qualified System.Random as Random
import qualified Prelude as P; import Prelude hiding (abs, map)
newtype SigId = SigId String deriving (Eq, Ord, Show, Read)
{-
-- Don't use this, if you want read to work!!!
instance Show SigId where
show (SigId x) = show x
-}
type instance D.Value (Record s1 s2 t1 t2 id v d1 d2) = d2
data Record s1 s2 t1 t2 id v d1 d2 =
Record { recordTime :: TC s1 t1 (Data (v :> Nil) d1),
recordSignalMap :: Map id (TC s2 t2 (Data (v :> Nil) d2)) }
deriving (Show, Read, Eq)
type SignalRecord v d = Record Signal Signal (Typ A T Tt) (Typ UT UT UT) SigId v d d
type PowerRecord n v d = Record Signal Signal (Typ A T Tt) (Typ A P Tt) (Idx.Position n) v d d
type FlowRecord n v d = Record Signal FSignal (Typ A T Tt) (Typ A F Tt) (Idx.Position n) v d d
-- type CumFlowRecord n v d = Record Scalar Scalar (Typ A T Tt) (Typ A F Tt) (Idx.Position n) v d d
type DTimeFlowRecord n v d = Record FSignal FSignal (Typ D T Tt) (Typ A F Tt) (Idx.Position n) v d d
type DTimePowerRecord n v d = Record FSignal FSignal (Typ D T Tt) (Typ A P Tt) (Idx.Position n) v d d
type DistRecord n v d = Record FDistrib FDistrib (Typ UT UT UT) (Typ A F Tt) (Idx.Position n) v ([S.Class d], [S.SignalIdx]) d
-- data DistRecord n v d = DistRecord (UTDistr v ([S.Class d], [S.SignalIdx])) (Map (Idx.Position n) (FDistr v d))
class (Ord id) => Index id where
formatIndex :: id -> String
instance Index SigId where
formatIndex (SigId str) = str
instance Node.C node => Index (Idx.Position node) where
formatIndex =
Format.unUnicode .
formatTopologyPosition (Format.literal "pos")
formatIndexSet :: (Index id) => Set id -> String
formatIndexSet =
Fold.foldMap (\i -> formatIndex i ++ "\n")
newtype Name = Name String
newtype DeltaName = DeltaName String
deltaName :: Name -> Name -> DeltaName
deltaName (Name x) (Name y) = (DeltaName $ y ++ "_vs_" ++ x)
map ::
(TC s1 t1 (Data (v :> Nil) d2) -> TC s2 t2 (Data (v :> Nil) d2)) ->
Record s s1 t t1 id v d1 d2 -> Record s s2 t t2 id v d1 d2
map f (Record t ma) = Record t (Map.map f ma)
mapKeys ::
(Index id2) =>
(id1 -> id2) ->
Record s1 s2 t1 t2 id1 v d1 d2 -> Record s1 s2 t1 t2 id2 v d1 d2
mapKeys f (Record t ma) = Record t (Map.mapKeys f ma)
mapWithKey ::
(id ->
TC s0 t0 (Data (v :> Nil) d2) ->
TC s1 t1 (Data (v :> Nil) d2)) ->
Record s s0 t t0 id v d1 d2 ->
Record s s1 t t1 id v d1 d2
mapWithKey f (Record t ma) = Record t (Map.mapWithKey f ma)
-- | Time Access Function -- not for Distributions
getTime :: Record s1 s2 t1 t2 id v d d -> TC s1 t1 (Data (v :> Nil) d)
getTime (Record time _) = time
-- | Signal Access Function -- not for Distributions
getSig ::
(Show (v d2), Index id) =>
Record s1 s2 t1 t2 id v d1 d2 -> id -> TC s2 t2 (Data (v :> Nil) d2)
getSig (Record _ sigMap) key =
Map.findWithDefault
(error $
"Record.getSig: unknown key " ++ formatIndex key ++ "\n" ++
"available keys " ++ formatIndexSet (Map.keysSet sigMap))
key sigMap
-- | Get Start and End time
{- Wollen wir wirklich (Typ A T Tt) vorschreiben?
getTimeWindow :: (Ord a,
V.Storage v a,
V.Singleton v) =>
Record s1 s2 (Typ A T Tt) t2 id v d1 d2 ->
(Scal (Typ A T Tt) a, Scal (Typ A T Tt) a)
-}
-- | not for Distributions
getTimeWindow ::
(Ord d, V.Storage v d, V.Singleton v) =>
Record s1 s2 t1 t2 id v d d ->
(TC Scalar t1 (Data Nil d), TC Scalar t1 (Data Nil d))
getTimeWindow = S.unzip . S.minmax . getTime
diffTime ::
{-
(V.Zipper v, V.Walker v, V.Singleton v, V.Storage v a, Sum a,
DSucc abs delta) =>
Record Signal s2 (Typ abs t1 p1) t2 id v a ->
Record FSignal s2 (Typ delta t1 p1) t2 id v a
-}
(V.Zipper v, V.Walker v, V.Singleton v, V.Storage v d, Sum d) =>
FlowRecord node v d ->
DTimeFlowRecord node v d
diffTime (Record time signals) = Record (S.delta time) signals
dTimePowerRecord ::
(V.Zipper v, V.Walker v, V.Singleton v, V.Storage v d,
Constant d) =>
PowerRecord n v d ->
DTimePowerRecord n v d
dTimePowerRecord (Record time signals) =
map (S.deltaMap (\x y -> (x~+y) ~/ Arith.fromInteger 2)) $
Record (S.delta time) signals
-- | Use carefully -- removes signal jitter around zero
removeZeroNoise ::
(V.Walker v, V.Storage v d, Ord d, Constant d) =>
d -> PowerRecord node v d -> PowerRecord node v d
removeZeroNoise threshold (Record time pMap) =
Record time $ Map.map (S.map (hardShrinkage threshold)) pMap
hardShrinkage :: (Ord d, Constant d) => d -> d -> d
hardShrinkage threshold x =
if abs x < threshold then Arith.zero else x
-- | Generate a new Record with selected signals
extract ::
(Index id) =>
[id] -> Record s1 s2 t1 t2 id v d1 d2 -> Record s1 s2 t1 t2 id v d1 d2
extract xs rec = extractLogSignals rec $ List.map (flip (,) id) xs
{-
extract ::
(Show (v a), Index id) =>
extract xs rec@(Record time _) =
Record time $ mapFromSet (getSig rec) $ Set.fromList xs
-}
-- | Split SignalRecord in even chunks
split ::
(Index id) =>
Int -> Record s1 s2 t1 t2 id v d1 d2 -> [Record s1 s2 t1 t2 id v d1 d2]
split n (Record time pMap) =
List.map (Record time . Map.fromList) $
ListHT.sliceVertical n $ Map.toList pMap
sortSigList ::
(Ord d, Constant d, V.Walker v, V.Storage v d) =>
[(SigId, TC Signal (Typ UT UT UT) (Data (v :> Nil) d))] ->
[(SigId, TC Signal (Typ UT UT UT) (Data (v :> Nil) d))]
sortSigList = Key.sort (S.sum . snd)
-----------------------------------------------------------------------------------
-- Functions to support Signal Selection
-- | List of Operations for pre-processing signals
-- | create a Record of selected, and sign corrected signals
extractLogSignals ::
(Index id) =>
Record s1 s2 t1 t2 id v d1 d2 ->
[(id, TC s2 t2 (Data (v :> Nil) d2) -> TC s2 t2 (Data (v :> Nil) d2))] ->
Record s1 s2 t1 t2 id v d1 d2
extractLogSignals (Record time sMap) idList =
let idMap = Map.fromList idList
notFound = Set.difference (Map.keysSet idMap) (Map.keysSet sMap)
in if Set.null notFound
then Record time $ Map.intersectionWith ($) idMap sMap
else error $
"extractLogSignals: signals not found in record: " ++
formatIndexSet notFound ++ "\n" ++
"Available Keys in Map : \n" ++
(formatIndexSet $ Map.keysSet sMap)
genPowerRecord ::
( Show (v d), V.Zipper v, V.Walker v,
V.Storage v d, Product d, Ord node) =>
TSignal v d ->
[(Graph.DirEdge node, UTSignal v d, UTSignal v d)] ->
PowerRecord node v d
genPowerRecord time =
Record time .
foldMap
(\(e, sigOut, sigIn) ->
Map.fromList
[(Topo.outPosFromDirEdge e, S.setType sigOut),
(Topo.inPosFromDirEdge e, S.setType sigIn)])
addSignals ::
(Index id, V.Len (v d1), V.Len (v d2)) =>
[(id, TC s2 t2 (Data (v :> Nil) d2))] ->
Record s1 s2 t1 t2 id v d1 d2 -> Record s1 s2 t1 t2 id v d1 d2
addSignals list (Record time m) = (Record time (foldl f m list))
where f ma (ident,sig) =
if S.len time == S.len sig
then Map.insert ident sig ma
else error $ "Error in addSignals - signal length differs: "
++ formatIndex ident
-- | adding signals of two records with same time vector by using Data.Map.union
union ::
(Eq (v d1), Index id) =>
Record s1 s2 t1 t2 id v d1 d2 ->
Record s1 s2 t1 t2 id v d1 d2 ->
Record s1 s2 t1 t2 id v d1 d2
union (Record timeA mA) (Record timeB mB) =
if timeA == timeB
then Record timeA
(Map.unionWith
(error "EFA.Signal.Record.union: duplicate signal ids") mA mB)
else error "EFA.Signal.Record.union: time vectors differ"
{-
-- Wegen newTimeBase ist der Typ nicht so algemein wie bei "union" oben. Schade.
unionWithNewTime ::
( Eq (v d), Show d, Show (v d),
Index id,
Product d,
Ord d,
V.Filter v,
V.Storage v d,
V.Walker v,
V.Singleton v,
V.Lookup v,
V.Find v,
V.Sort v) =>
[Record S.Signal S.Signal (Typ A T Tt) t2 id v d d] ->
Record S.Signal S.Signal (Typ A T Tt) t2 id v d d
unionWithNewTime rs = Record newTime $
Map.unionsWith (error "unionWithNewTime: duplicate signal ids") $
List.map ((\(Record _ m) -> m) . flip (newTimeBase "unionWithNewTime") newTime) rs
where (starts, ends) = unzip $ List.map getTimeWindow rs
newTime = S.sort $ List.foldr1 S.append $ List.map (filt . getTime) rs
filt = S.filter $ inRange $ (,)
(S.fromScalar (maximum starts))
(S.fromScalar (minimum ends))
-}
nonEmptyUnzip :: NonEmpty.T [] (a, b) -> (NonEmpty.T [] a, NonEmpty.T [] b)
nonEmptyUnzip (NonEmpty.Cons (x, y) rest) =
let (xs, ys) = unzip rest in (x !: xs, y !: ys)
unionWithNewTime ::
( Eq (v d), Show d, Show (v d),
Ord id, Show id, Product d, Ord d,
V.Filter v, V.FromList v, V.Storage v d, V.Walker v,
V.Singleton v, V.Lookup v, V.Find v, V.Sort v, Constant d,
V.Zipper v,V.Storage v Bool,V.Len (v d)) =>
NonEmpty.T [] (Record S.Signal S.Signal (Typ A T Tt) t2 id v d d) ->
Record S.Signal S.Signal (Typ A T Tt) t2 id v d d
unionWithNewTime rs = Record newTime $
Map.unionsWith (error "unionWithNewTime: duplicate signal ids") $
NonEmpty.toList $ fmap g rs
where g x = recordSignalMap $ newTimeBase "unionWithNewTime" x newTime
(starts, ends) = nonEmptyUnzip $ fmap getTimeWindow rs
newTime = NonEmpty.foldBalanced (S.mergeBy (<=)) $ fmap (filt . getTime) rs
filt =
S.filter $
inRange
(S.fromScalar (NonEmpty.maximum starts),
S.fromScalar (NonEmpty.minimum ends))
-- | Modify the SigId
modifySigId ::
(String -> String) ->
Record s1 s2 t1 t2 SigId v d1 d2 ->
Record s1 s2 t1 t2 SigId v d1 d2
modifySigId f = mapKeys (\(SigId str) -> SigId (f str))
-- | Modify specified signals with function
modifySignals ::
(Index id) =>
ToModify id ->
(TC s2 t2 (Data (v :> Nil) d2) ->
TC s2 t2 (Data (v :> Nil) d2)) ->
Record s1 s2 t1 t2 id v d1 d2->
Record s1 s2 t1 t2 id v d1 d2
modifySignals idList f (Record time ma) =
Record time $
List.foldl' (flip $ Map.adjust f) ma $
case idList of
ModifyAll -> Map.keys ma
ToModify x -> x
-- | Get maximum signal range for all signals specified
maxRange ::
( Ord d2, V.Storage v d2, Show (v d2), V.Singleton v, Index id) =>
RangeFrom id ->
Record s1 s2 t1 t2 id v d1 d2 ->
(TC Scalar t2 (Data Nil d2), TC Scalar t2 (Data Nil d2))
maxRange list rec@(Record _ m) =
(S.toScalar $ minimum lmin, S.toScalar $ maximum lmax)
where (lmin, lmax) =
unzip $
List.map (S.fromScalar . S.minmax . getSig rec) $
case list of
RangeFromAll -> Map.keys m
RangeFrom w -> w
-- | Get maximum signal range for all signals specified
data RangeFrom id = RangeFrom [id] | RangeFromAll
data ToModify id = ToModify [id] | ModifyAll
normSignals2Range :: (Index id,
Ord d2,
Show (v d2),
V.Storage v d2,
V.Singleton v,
V.Walker v,
Product d2) =>
(RangeFrom id, ToModify id) ->
Record s1 s2 t1 t2 id v d1 d2 ->
Record s1 s2 t1 t2 id v d1 d2
normSignals2Range (listM,listN) record = modifySignals listN f record
where (TC (Data minx),TC (Data maxx)) = maxRange listM record
f = S.map (\y -> y ~* (maxx ~- minx) ~+ minx) . S.norm
normSignals2Max75 :: (Index id,
Ord d2,
Show (v d2),
V.Storage v d2,
V.Singleton v,
V.Walker v,
Constant d2) =>
(RangeFrom id, ToModify id) ->
Record s1 s2 t1 t2 id v d1 d2 ->
Record s1 s2 t1 t2 id v d1 d2
normSignals2Max75 (listM,listN) record = modifySignals listN f record
where ( _ ,TC (Data maxx)) = maxRange listM record
f = S.map (\y -> y ~* Arith.fromRational 0.75 ~* maxx) . S.norm
-- | Norm all signals to one
norm :: (Product d2,
Ord d2,
V.Walker v,
V.Storage v d2,
V.Singleton v) =>
Record s1 s2 t1 t2 id v d1 d2 -> Record s1 s2 t1 t2 id v d1 d2
norm rec = map S.norm rec
-- | Add interpolated data points in an existing record
newTimeBase ::
(Product d, Ord d, V.Find v, Show d, Show (v d),
V.Lookup v, V.Walker v, V.Singleton v, V.Storage v d,
Constant d, V.Zipper v, V.Storage v Bool, V.Len (v d)) =>
String ->
Record Signal Signal (Typ A T Tt) t2 id v d d ->
TSignal v d ->
Record Signal Signal (Typ A T Tt) t2 id v d d
newTimeBase caller (Record time m) newTime = Record newTime (Map.map f m)
where f sig = S.interp1LinSig caller time sig newTime
-- | Create a new Record by slicing time and all signals on given Indices
slice ::
(V.Slice v, V.Storage v d) =>
Record s1 s2 t1 t2 id v d d ->
Range ->
Record s1 s2 t1 t2 id v d d
slice (Record t m) (Range sidx1@(S.SignalIdx idx1) (S.SignalIdx idx2)) =
Record (f t) (Map.map f m)
where f ::
(V.Slice v, V.Storage v d) =>
TC s t (Data (v :> Nil) d) -> TC s t (Data (v :> Nil) d)
f = S.slice sidx1 (idx2-idx1+1)
{- | Filter Sequence Flow
Used to filter Modelica signals.
State changes in solver create several DataPoints with exact the same time.
The resulting sections which have zero time duration are removed.
-}
longerThanZero ::
(Sum d, Ord d, V.Storage v d, V.Singleton v) =>
PowerRecord node v d -> Bool
longerThanZero = uncurry (/=) . getTimeWindow
-- | Check for minimum duration
longerThan ::
(Sum d, Ord d, V.Storage v d, V.Singleton v) =>
d -> Record s1 s2 (Typ A T Tt) t2 id v d d -> Bool
longerThan threshold r =
case getTimeWindow r of
(TC (Data x), TC (Data y)) -> abs (x ~- y) > threshold
-- | Check for minimum duration
longerEqual ::
(Constant d, Ord d, V.Storage v d, V.Singleton v) =>
d -> Record s1 s2 (Typ A T Tt) t2 id v d d -> Bool
longerEqual threshold r =
case getTimeWindow r of
(TC (Data x), TC (Data y)) -> abs (x ~- y) >= threshold
-- | Check for negligible energy flow
energyBelow ::
(Constant d, Ord d, V.Walker v, V.Storage v d) =>
d -> FlowRecord node v d -> Bool
energyBelow threshold (Record _ fMap) =
Fold.all (\s -> abs (S.fromScalar (S.sum s)) < threshold) fMap
major ::
(Constant d, Ord d,
V.Storage v d, V.Singleton v, V.Walker v) =>
TC Scalar (Typ A F Tt) (Data Nil d) ->
TC Scalar (Typ A T Tt) (Data Nil d) ->
FlowRecord id v d -> Bool
major (S.TC (D.Data energyThreshold)) (S.TC (D.Data timeThreshold)) rec =
not (energyBelow energyThreshold rec)
&&
longerEqual timeThreshold rec
-----------------------------------------------------------------------------------
-- Various Class and Instance Definition for the different Sequence Datatypes
instance
(Sample d1,
Sample d2,
V.FromList v,
V.Storage v d1,
V.Storage v d2,
QC.Arbitrary id,
Index id) =>
QC.Arbitrary (Record s1 s2 t1 t2 id v d1 d2) where
arbitrary = do
xs <- QC.listOf arbitrarySample
n <- QC.choose (1,5)
pos <- QC.vectorOf n QC.arbitrary
let vectorSamples =
ListHT.switchR [] (\equalSized _ -> equalSized) $
ListHT.sliceVertical n xs
return $
Record (S.fromList $ Match.take vectorSamples $ iterate (1+) 0) $
Map.fromList $ zip pos $ List.map S.fromList $ transpose vectorSamples
{-
we need this class,
because QC.choose requires a Random instance
but there is no Random Ratio instance
-}
class Num d => Sample d where arbitrarySample :: QC.Gen d
instance Sample Double where arbitrarySample = QC.choose (-1,1)
instance (Random d, Integral d) => Sample (Ratio d) where
arbitrarySample = do
x <- QC.choose (-100,100)
y <- QC.choose (-100,100)
return $
case compare (P.abs x) (P.abs y) of
LT -> x%y
GT -> y%x
EQ -> 1 -- prevent 0/0
instance
(V.Walker v,
V.Singleton v,
V.FromList v,
V.Storage v d1,
V.Storage v d2,
DispStorage1 v,
Ord d1,
Constant d1,
PrintfArg d1,
Index id,
Ord d2,
Constant d2,
PrintfArg d2,
S.DispApp s1,
S.DispApp s2,
TDisp t1,
TDisp t2) =>
ToTable (Record s1 s2 t1 t2 id v d1 d2) where
toTable os (ti, Record time sigs) =
[Table {
tableTitle =
(getDisplayTypName $ S.getDisplayType $ snd $ head sigList) ++
"Record - " ++ ti,
tableData = tableData t,
tableFormat = tableFormat t,
tableSubTitle = ""}]
where sigList = Map.toList sigs
t = tvcat $ S.toTable os ("Time",time) !:
concatMap (toTable os . mapFst formatIndex) sigList
------------------------------------
-- RSignal als Transponierte Form
--type Sig = (TSigL, PSamp2LL)
type Sig v a = (TSignal [] a, PSample2 v [] a)
--type Samp1 = (TSamp, PSamp1L)
type Samp1 a = (TSample a, PSample1 [] a)
--type Samp = (TSamp, PSamp)
type Samp a = (TSample a, PSample a)
--viewL :: Sig -> Maybe (Samp1, Sig)
viewL
:: (V.Storage v1 (D.Apply v2 d), V.Storage v3 (D.Apply v4 d1),
V.Singleton v1, V.Singleton v3, S.TailType s, S.TailType s1) =>
(TC s typ (Data (v1 :> v2) d), TC s1 typ1 (Data (v3 :> v4) d1))
-> Maybe
((TC (S.Head s) typ (Data v2 d), TC (S.Head s1) typ1 (Data v4 d1)),
(TC s typ (Data (v1 :> v2) d), TC s1 typ1 (Data (v3 :> v4) d1)))
viewL (t, ps) =
liftM2 zipPairs (S.viewL t) (S.viewL ps)
--viewR :: Sig -> Maybe (Sig, Samp1)
viewR
:: (V.Storage v1 (D.Apply v2 d), V.Storage v3 (D.Apply v4 d1),
V.Singleton v1, V.Singleton v3, S.TailType s, S.TailType s1) =>
(TC s typ (Data (v1 :> v2) d), TC s1 typ1 (Data (v3 :> v4) d1))
-> Maybe
((TC s typ (Data (v1 :> v2) d), TC s1 typ1 (Data (v3 :> v4) d1)),
(TC (S.Head s) typ (Data v2 d), TC (S.Head s1) typ1 (Data v4 d1)))
viewR (t,ps) =
liftM2 zipPairs (S.viewR t) (S.viewR ps)
zipPairs :: (a,b) -> (c,d) -> ((a,c), (b,d))
zipPairs (a,b) (c,d) = ((a,c), (b,d))
len :: V.Len (v [a]) => Sig v a -> Int
len (t,ps) = min (S.len t) (S.len ps)
singleton
:: (V.Storage v (D.Apply c d), V.Storage v1 (D.Apply c1 d1),
S.Singleton s v c, S.Singleton s1 v1 c1) =>
(TC (S.SingletonSource s) t (Data c d),
TC (S.SingletonSource s1) t1 (Data c1 d1))
-> (TC s t (Data (v :> c) d), TC s1 t1 (Data (v1 :> c1) d1))
singleton (t,ps) = (S.singleton t, S.singleton ps)
-- * Conversion between Signal and Power Record
-- | Convert a power record to a signal record
powerToSignal :: (Show id) => PowerRecord id v d -> SignalRecord v d
powerToSignal (Record time m) =
Record time $
Map.mapKeys (\x -> SigId $ show x) $
Map.map S.untype m
-- | Plot Records with readible keys
powerToSignalWithFunct ::
(Ord node, Show node, Show (v d)) =>
(Idx.Position node -> SigId) -> PowerRecord node v d -> SignalRecord v d
powerToSignalWithFunct funct rec = map S.untype $ mapKeys funct rec
-- | Combine a power and a signal record together in a signal record (plotting)
combinePowerAndSignal :: (Eq (v d), Show id) => PowerRecord id v d -> SignalRecord v d -> SignalRecord v d
combinePowerAndSignal pr sr = union (powerToSignal pr) sr
-- | Combine a power and a signal record together in a signal record (plotting)
combinePowerAndSignalWithFunction :: (Eq (v d),
Ord node,
Show (v d),
Show node) =>
(Idx.Position node -> SigId) -> PowerRecord node v d -> SignalRecord v d -> SignalRecord v d
combinePowerAndSignalWithFunction funct pr sr = union (powerToSignalWithFunct funct pr) sr
-- | Add Record name to SigId -- can be used for plotting multiple records in one window
addRecName2SigId :: String -> SignalRecord v d -> SignalRecord v d
addRecName2SigId name (Record time sigs) = Record time (Map.mapKeys (\ (SigId x) -> SigId (name ++ "_" ++ x) ) sigs)
-- | Integrate power signal step wise to get a flow record
partIntegrate :: (V.Zipper v,
V.Walker v,
V.Storage v d,
V.Singleton v,
Constant d) => PowerRecord node v d -> FlowRecord node v d
partIntegrate rec@(Record time _) = map (S.partIntegrate time) rec
{-
-- | Classify a flow record to get a distribution record
distribution :: (V.FromList v,
V.Filter v,
V.Unique v (S.Class d),
V.Storage v S.SignalIdx,
V.Storage v Int,
V.Storage v (S.Class d),
RealFrac d,
V.Walker v,
V.Storage v d,
V.Storage v ([S.Class d], [S.SignalIdx]),
V.Lookup v,
Constant d,
V.Find v,
Node.C n,
Show (v d)) => FlowRecord n v d -> [Idx.Position n] -> d -> d -> DistRecord n v d
distribution rec@(Record _ pMap) xs interval offset = Record classification energyDistribution
where classification =
S.combineDistributions $
List.map
((S.genDistribution1D $ S.classifyEven interval offset) .
S.changeSignalType . S.untype . getSig rec)
xs
energyDistribution =
Map.map (S.calcDistributionValues classification) pMap
-}
-- | Careful quick hack
sumFlowRecord :: (V.FromList v,
V.Zipper v,
V.Walker v,
V.Storage v d,
V.Singleton v,
Constant d) => FlowRecord node v d -> FlowRecord node v d
sumFlowRecord (Record time pmap) =
Record
(S.fromList $ [head $ S.toList time, last $ S.toList time])
(Map.map (S.fromList . (\x -> [x]) . S.fromScalar . S.sum) pmap)
{-
sumFlowRecord :: (V.FromList v,
V.Zipper v,
V.Walker v,
V.Storage v d,
V.Singleton v,
Product d) => DTimeFlowRecord node v d -> CumFlowRecord node v d
sumFlowRecord (Record dtime map) = Record (S.sum dtime) (Map.map (S.sum) map)
-}
makeStepped :: (V.Storage v d1, V.FromList v, V.Storage v d2) =>
Record s1 s2 t1 t2 id v d1 d2 -> Record s1 s2 t1 t2 id v d1 d2
makeStepped (Record time pmap) = Record (S.duplicateR time) $ Map.map (S.duplicateL) pmap
scatterRnd ::
(V.Storage v d1, V.FromList v, Constant d1, Ord id,
Random d2,
V.Storage v d2,
Product d2,
Random.RandomGen rnd) =>
rnd -> Int -> d2 -> Record s1 s2 t1 t2 id v d1 d2 -> Record s1 s2 t1 t2 id v d1 d2
scatterRnd randomGenerator number scale (Record time pMap) =
Record (S.densifyTime (P.toInteger number) time)
(Map.fromList $ snd $
foldl (\ (rndList, xs) (k,x) -> (drop number rndList, xs ++ [(k,S.scatter rndList number scale x)]))
(randomList,[]) $ Map.toList pMap )
where
randomList = Random.randoms randomGenerator
{-
scatterSin ::
(V.Storage v d1, V.FromList v, Constant d1, Ord id,
Random d2,
V.Storage v d2,
Product d2) =>
Int -> d2 -> d2 -> Record s1 s2 t1 t2 id v d1 d2 -> Record s1 s2 t1 t2 id v d1 d2
scatterSin number scale freq (Record time pMap) =
Record (S.densifyTime (P.toInteger number) time)
(Map.map (\x -> S.scatter sinList number scale x) pMap)
where
sinList = map sin $ S.toList (S.scale time freq)
time = S.densifyTime (P.toInteger number) time
-}
|
energyflowanalysis/efa-2.1
|
src/EFA/Signal/Record.hs
|
bsd-3-clause
| 26,147 | 0 | 18 | 7,576 | 8,956 | 4,684 | 4,272 | 490 | 2 |
{-# LANGUAGE OverloadedStrings #-}
module Main
( main
) where
import Test.Hspec
import Test.QuickCheck
import qualified Data.ByteString as BS
import qualified Data.Text as T
import Codec.Rot13
main :: IO ()
main = hspec $ do
describe "Codec.Rot13" $ do
it "correctly ciphers the alphabet (rot13 String)" $ do
rot13 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" :: String)
`shouldBe` "NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm"
it "correctly ciphers the alphabet (rot13 ByteString)" $ do
rot13 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
`shouldBe` ("NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm" :: BS.ByteString)
it "correctly ciphers the alphabet (rot13 Text)" $ do
rot13 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
`shouldBe` ("NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm" :: T.Text)
it "is reversible (String)" $
property $ \s -> s == (rot13 . rot13 :: String -> String) s
it "is reversible (ByteString)" $
property $ \s -> let s' = BS.pack s
in s' == (rot13 . rot13 :: BS.ByteString -> BS.ByteString) s'
it "is reversible (Text)" $
property $ \s -> let s' = T.pack s
in s' == (rot13 . rot13 :: T.Text -> T.Text) s'
|
kvanberendonck/codec-rot13
|
test/Spec.hs
|
bsd-3-clause
| 1,371 | 0 | 19 | 344 | 318 | 164 | 154 | 28 | 1 |
{-# LANGUAGE Rank2Types, ImpredicativeTypes #-}
module Main where
import Test.QuickCheck
import qualified Data.FMList as F
import qualified Data.List as L
import qualified Data.Foldable as DF
t1 t ff lf = quickCheck ((\s -> not(t s) || ((F.toList . ff . F.fromList) s == lf s)) :: [Int] -> Bool)
t2 t ff lf = quickCheck ((\s -> not(t s) || ((F.toList . ff . F.fromList . map F.fromList) s == lf s)) :: [[Int]] -> Bool)
t3 t ff lf = quickCheck ((\s -> not(t s) || (( ff . F.fromList) s == lf s)) :: [Int] -> Bool)
t4 ff lf = quickCheck ((\a s -> (F.toList . ff a . F.fromList) s == lf a s) :: Int -> [Int] -> Bool)
t5 ff lf = quickCheck ((\s t -> F.toList (ff (F.fromList s) (F.fromList t)) == lf s t) :: [Int] -> [Int] -> Bool)
al = const True
instance Show (a -> b) where
show _ = "Some function"
upto x = F.unfold unfoldRange (0, x) where
unfoldRange (l, r)
| l >= r = F.empty
| l == r - 1 = F.singleton (Right l)
| otherwise = let m = (l + r) `div` 2 in (Left (l, m) `F.pair` Left (m, r))
main = do
t1 al id id
t4 F.cons (:)
t4 (flip F.snoc) (flip (++) . (:[]))
t5 F.append (++)
t2 al F.flatten L.concat
t3 al F.null L.null
t3 al F.length L.length
t3 (not . L.null) F.head L.head
t1 (not . L.null) F.tail L.tail
t3 (not . L.null) F.last L.last
t1 (not . L.null) F.init L.init
t1 al F.reverse L.reverse
t1 al (F.filter (> 2)) (L.filter (> 2))
t4 F.take L.take
t4 F.drop L.drop
t1 al (F.takeWhile (> 2)) (L.takeWhile (> 2))
t1 al (F.dropWhile (> 2)) (L.dropWhile (> 2))
t5 F.zip L.zip
t1 al (fmap (*2)) (map (*2))
quickCheck ((\f z -> (F.toList . F.take 10 $ F.unfoldr f z) == L.take 10 (L.unfoldr f z)) :: (Int -> Maybe (Int, Int)) -> Int -> Bool)
|
sjoerdvisscher/fmlist
|
tests.hs
|
bsd-3-clause
| 1,753 | 0 | 17 | 439 | 1,073 | 551 | 522 | 40 | 1 |
-- Copyright (c) 2016-present, Facebook, Inc.
-- All rights reserved.
--
-- This source code is licensed under the BSD-style license found in the
-- LICENSE file in the root directory of this source tree.
{-# LANGUAGE OverloadedStrings #-}
module Duckling.Time.GA.Corpus
( corpus
) where
import Data.String
import Prelude
import Duckling.Locale
import Duckling.Resolve
import Duckling.Time.Corpus
import Duckling.TimeGrain.Types hiding (add)
import Duckling.Testing.Types hiding (examples)
corpus :: Corpus
corpus = (testContext {locale = makeLocale GA Nothing}, testOptions, allExamples)
allExamples :: [Example]
allExamples = concat
[ examples (datetime (2013, 2, 12, 4, 30, 0) Second)
[ "anois"
]
, examples (datetime (2013, 2, 12, 0, 0, 0) Day)
[ "inniu"
]
, examples (datetime (2013, 2, 11, 0, 0, 0) Day)
[ "inné"
]
, examples (datetime (2013, 2, 10, 0, 0, 0) Day)
[ "arú inné"
]
, examples (datetime (2013, 2, 13, 0, 0, 0) Day)
[ "amárach"
]
, examples (datetime (2013, 2, 14, 0, 0, 0) Day)
[ "arú amárach"
]
, examples (datetime (2013, 2, 18, 0, 0, 0) Day)
[ "dé luain"
, "an luan"
, "an luan seo"
]
, examples (datetime (2013, 2, 18, 0, 0, 0) Day)
[ "an luan seo chugainn"
, "an luan seo atá ag teacht"
, "dé luain seo chugainn"
]
, examples (datetime (2013, 2, 18, 0, 0, 0) Day)
[ "18/2/2013"
]
]
|
facebookincubator/duckling
|
Duckling/Time/GA/Corpus.hs
|
bsd-3-clause
| 1,632 | 0 | 10 | 542 | 460 | 280 | 180 | 36 | 1 |
{-# LINE 1 "GHC.Event.Unique.hs" #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE BangPatterns, GeneralizedNewtypeDeriving, NoImplicitPrelude #-}
module GHC.Event.Unique
(
UniqueSource
, Unique(..)
, newSource
, newUnique
) where
import Data.Int (Int64)
import GHC.Base
import GHC.Conc.Sync (TVar, atomically, newTVarIO, readTVar, writeTVar)
import GHC.Num (Num(..))
import GHC.Show (Show(..))
-- We used to use IORefs here, but Simon switched us to STM when we
-- found that our use of atomicModifyIORef was subject to a severe RTS
-- performance problem when used in a tight loop from multiple
-- threads: http://ghc.haskell.org/trac/ghc/ticket/3838
--
-- There seems to be no performance cost to using a TVar instead.
newtype UniqueSource = US (TVar Int64)
newtype Unique = Unique { asInt64 :: Int64 }
deriving (Eq, Ord, Num)
instance Show Unique where
show = show . asInt64
newSource :: IO UniqueSource
newSource = US `fmap` newTVarIO 0
newUnique :: UniqueSource -> IO Unique
newUnique (US ref) = atomically $ do
u <- readTVar ref
let !u' = u+1
writeTVar ref u'
return $ Unique u'
{-# INLINE newUnique #-}
|
phischu/fragnix
|
builtins/base/GHC.Event.Unique.hs
|
bsd-3-clause
| 1,158 | 0 | 11 | 222 | 255 | 147 | 108 | 27 | 1 |
import Dna ( compl )
-- | Given a strand takes its reverse complement,
-- where 'A' <-> 'T', 'C' <-> 'G' are complements
--
-- >>> AAAACCCGGT
-- ACCGGGTTTT
revc :: String -> String
revc = show . map Dna.compl . read . reverse
main = interact revc
|
mitochon/hoosalind
|
src/problems/revc.hs
|
mit
| 250 | 0 | 9 | 52 | 53 | 30 | 23 | 4 | 1 |
import Test.Hspec (Spec, it, shouldBe)
import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
import SecretHandshake (handshake)
main :: IO ()
main = hspecWith defaultConfig {configFastFail = True} specs
specs :: Spec
specs = do
it "wink for 1" $
handshake (1 :: Int) `shouldBe` ["wink"]
it "double blink for 10" $
handshake (2 :: Int) `shouldBe` ["double blink"]
it "close your eyes for 100" $
handshake (4 :: Int) `shouldBe` ["close your eyes"]
it "jump for 1000" $
handshake (8 :: Int) `shouldBe` ["jump"]
it "combine two actions" $
handshake (3 :: Int) `shouldBe` ["wink", "double blink"]
it "reverse two actions" $
handshake (19 :: Int) `shouldBe` ["double blink", "wink"]
it "reversing one action gives the same action" $
handshake (24 :: Int) `shouldBe` ["jump"]
it "reversing no actions still gives no actions" $
handshake (16 :: Int) `shouldBe` []
it "all possible actions" $
handshake (15 :: Int) `shouldBe` ["wink", "double blink", "close your eyes", "jump"]
it "reverse all possible actions" $
handshake (31 :: Int) `shouldBe` ["jump", "close your eyes", "double blink", "wink"]
it "do nothing for zero" $
handshake (0 :: Int) `shouldBe` []
|
enolive/exercism
|
haskell/secret-handshake/test/Tests.hs
|
mit
| 1,297 | 0 | 10 | 315 | 410 | 226 | 184 | 29 | 1 |
{- | Module : $Header$
- Description : Implementation of logic instance Mon
- Copyright : (c) Daniel Hausmann & Georgel Calin & Lutz Schroeder, DFKI Lab Bremen,
- Rob Myers & Dirk Pattinson, Department of Computing, ICL
- License : GPLv2 or higher, see LICENSE.txt
- Maintainer : [email protected]
- Stability : provisional
- Portability : portable
-
- Provides the implementation of the matching functions monotonic modal logic.
-}
module GMP.Logics.Mon where
import List
import Ratio
import Maybe
import Debug.Trace
import Text.ParserCombinators.Parsec
import GMP.Logics.Generic
import GMP.Parser
--------------------------------------------------------------------------------
-- instance of feature for Monotonic logic
--------------------------------------------------------------------------------
data Mon a = Mon [Formula a] deriving (Eq,Show)
-- For any combination of a positive and a negative literal, there is a premise
-- containing only one sequent. This sequent contains only one formula over the
-- stripped positive literal and the negated stripped negative literal.
-- e.g. seq = [ (M Mon p), !(M Mon q), (M Mon !p), !(M Mon !r)]
-- match seq = [ [[ p, !q]], [[p, r]], [[ !p, !q]], [[ !p, r]] ]
instance (SigFeature b c d, Eq (b (c d)), Eq (c d)) => NonEmptyFeature Mon b c d where
nefMatch flags seq = let stripnlits = [ Neg (head phi) | (Neg (Mod (Mon phi))) <- seq]
striplits = [ (head phi) | (Mod (Mon phi)) <- seq]
in if (flags!!1)
then
[ [[(Sequent [(Neg (And (Neg neg) (Neg pos)))])]] | neg <- stripnlits, pos <- striplits]
else
[ [[(Sequent [(Neg (And (Neg neg) (Neg pos)))])]] | neg <- stripnlits, pos <- striplits]
nefPretty d = genfPretty d "[Mon]"
nefFeatureFromSignature sig = Mon
nefFeatureFromFormula phi = Mon
nefStripFeature (Mon phis) = phis
--------------------------------------------------------------------------------
-- instance of sigFeature for Monotonic logic
--------------------------------------------------------------------------------
instance (SigFeature b c d, Eq (c d), Eq (b (c d))) => NonEmptySigFeature Mon b c d where
neGoOn sig flag = genericPGoOn sig flag
|
nevrenato/Hets_Fork
|
GMP/versioning/gmp-coloss-0.0.3/GMP/Logics/Mon.hs
|
gpl-2.0
| 2,347 | 0 | 20 | 547 | 477 | 258 | 219 | -1 | -1 |
----------------------------------------------------
-- --
-- HyLoRes.Statistics: --
-- Functions that collect and print out --
-- statistics --
-- --
----------------------------------------------------
{-
Copyright (C) HyLoRes 2002-2007 - See AUTHORS file
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA.
-}
module HyLoRes.Statistics(
-- the original idea was not to export MonadStatistcs methods,
-- but this is required to implement the Worker type....
MonadStatistics(..), StatisticsT, runStatisticsT,
StatsValues,
recordGivenClause, recordQueuedClauses,
recordFiredRule, recordSubsumedPremise,
recordLateSubsumedClause,
showAllMetrics, logInspectionMetrics,
mkStatsValues,
Metric, UniqueMetric,
rawClausesGenerated, nonFwSubsumedClausesGenerated,
premisesSubsumedByConsequents, ruleApplicationCount,
averageGivenClauseSize, lateSubsumedClauses
) where
import Prelude hiding ( log )
import Control.Monad ( guard, when, liftM, liftM2 )
import Control.Monad.Trans ( MonadTrans(lift), MonadIO(liftIO) )
import Control.Monad.Reader ( ReaderT, runReaderT, ask )
import Control.Applicative ( (<*>), (<$>) )
import Data.List ( intersperse, nub, (\\) )
import Data.Maybe ( mapMaybe )
import Data.Unique ( Unique, newUnique )
import Data.Array.IO ( IOUArray, Ix, MArray,
newArray, readArray, writeArray, getAssocs )
import Data.IORef ( IORef, newIORef, readIORef, writeIORef )
import HyLoRes.Clause ( Clause(..) )
import HyLoRes.Clause.BasicClause ( BasicClause )
import HyLoRes.Clause.FullClause ( FullClause )
import HyLoRes.Core.Rule.Metadata ( RuleId )
import HyLoRes.Logger ( MonadLogger, log, LoggerEvent (..) )
-------------------------------------------
-- Statistics are collections of Metrics
-- which can be printed out (at regular intervals)
-------------------------------------------
data StatsValues = Stat{metrics :: [Metric],
inspectionMetrics :: [Metric],
count :: IORef Int,
step :: Maybe Int}
class Monad m => MonadStatistics m where
getStatsValues :: m StatsValues
performIO :: IO a -> m a
newtype StatisticsT m a = StatsT{unStatsT :: ReaderT StatsValues m a}
deriving (Functor, Monad, MonadTrans, MonadIO)
instance MonadIO m => MonadStatistics (StatisticsT m) where
getStatsValues = StatsT ask
performIO = liftIO
instance (MonadStatistics m, MonadTrans t, Monad (t m))
=> MonadStatistics (t m) where
getStatsValues = lift getStatsValues
performIO = lift . performIO
runStatisticsT :: MonadIO m => StatisticsT m a -> StatsValues -> m a
runStatisticsT m = (unStatsT m `runReaderT`)
needsToPrintOut :: StatsValues -> IO Bool
needsToPrintOut (Stat _ [] _ _) = return False
needsToPrintOut (Stat _ _ _ Nothing) = return False
needsToPrintOut (Stat _ _ itRef (Just toi)) = do iter <- readIORef itRef
return $ iter > 0 &&
iter `mod` toi == 0
noStats :: StatsValues -> Bool
noStats (Stat [] [] _ _) = True
noStats _ = False
mkStatsValues :: [UniqueMetric] -> Maybe (Int, [UniqueMetric]) -> IO StatsValues
mkStatsValues ms iims =
do countRef <- newIORef 0
--
-- we remove "duplicated" metrics (i.e. no ioref occurs twice);
-- otherwise, aliasing would give us wrong results
let ims' = nub $ maybe [] snd iims
let ms' = nub ms \\ ims'
--
let toi = fmap fst iims
--
return Stat{metrics = map unUnique ms',
inspectionMetrics = map unUnique ims',
count = countRef,
step = guard (maybe False (> 0) toi) >> toi}
updateMetrics :: MonadStatistics m => (Metric -> IO ()) -> m ()
updateMetrics f = do stat <- getStatsValues
performIO $
mapM_ f (metrics stat ++ inspectionMetrics stat)
updateStep :: MonadStatistics m => m ()
updateStep = performIO . updateStep' =<< getStatsValues
where updateStep' (Stat _ [] _ _) = return ()
updateStep' (Stat _ _ _ Nothing) = return ()
updateStep' (Stat _ _ r _) = modifyIORef' r (1 +)
recordGivenClause :: MonadStatistics m => FullClause f -> m ()
recordGivenClause cl = do updateMetrics (recordGivenClauseM cl)
updateStep
recordFiredRule :: MonadStatistics m => RuleId -> [BasicClause] -> m ()
recordFiredRule rule cls = updateMetrics (recordFiredRuleM rule cls)
recordSubsumedPremise :: MonadStatistics m => m ()
recordSubsumedPremise = updateMetrics recordSubsumedPremiseM
recordLateSubsumedClause :: MonadStatistics m => Int -> m ()
recordLateSubsumedClause n = updateMetrics (recordLateSubsumedClauseM n)
recordQueuedClauses :: MonadStatistics m => [FullClause f] -> m ()
recordQueuedClauses cls = updateMetrics (recordQueuedClausesM cls)
showAllMetrics :: StatsValues -> IO String
showAllMetrics stats = if noStats stats
then return []
else do sms <- showMetricList $ inspectionMetrics stats
++ metrics stats
return $ "(final statistics)\n" ++ sms
logInspectionMetrics :: (MonadStatistics m, MonadLogger m) => m ()
logInspectionMetrics =
do s <- getStatsValues
shouldPrint <- performIO $ needsToPrintOut s
when shouldPrint $ do
iter <- performIO $ readIORef (count s)
log L_Metric $ concat ["(partial statistics: iteration",
show iter, ")"]
log L_Metric =<< (performIO $ showMetricList (inspectionMetrics s))
showMetricList :: [Metric] -> IO String
showMetricList [] = return []
showMetricList ms = do sms <- mapM showMetric ms
return . unlines . intersperse separator $ "begin" :
sms ++
["end"]
where separator = "---------------------"
--------------------------------------------
-- Metrics
--------------------------------------------
data Metric = CG (IORef Int)
-- Raw clauses generated
-- (sum of the clauses generated by each rule)
--
| CG' (IORef Int)
-- Non fw-subsumed clauses generated
--
| SP (IORef Int)
-- Number of premises that were subsumed by their consequents
--
| LS (IORef Int)
-- Number of Clauses subsumed already processed
--
| RC (IOUArray RuleId Int)
-- Rule application count
--
| GS (IORef Int) (IORef Int)
-- Avg size of the given clause
-- deriving(Eq) -- this uses ioref equality (pointer equality)
-- but IOUArray lacks an Eq instance (grrrr).
-- until fixed, we use a Unique
data UniqueMetric = UM{unique :: Unique, unUnique :: Metric}
instance Eq UniqueMetric where
a == b = unique a == unique b
showMetric :: Metric -> IO String
showMetric (CG x) =
do n <- readIORef x
return $ concat ["Clauses generated (raw): ", show n]
showMetric (CG' x) =
do n <- readIORef x
return $ concat ["Clauses generated (non forward-subsumed): ", show n]
showMetric (SP x) =
do n <- readIORef x
return $ concat ["Premises subsumed by their consequents: ", show n]
showMetric (LS x) =
do n <- readIORef x
return $ concat ["Late Subsumed Clauses: ", show n]
showMetric (GS s c) =
do (a,b) <- (,) <$> (readIORef s) <*> (readIORef c)
return $ concat ["Avg. given clause size: ", show (ratio a b)]
showMetric (RC x) =
do as <- getAssocs x
let rs = "Rule applications:": mapMaybe showRule as
return . concat . intersperse "\n" $ rs
where showRule (i,c) = do guard (c > 0)
return $ concat [" ",show i, " rule: ", show c]
modifyIORef' :: IORef a -> (a -> a) -> IO ()
modifyIORef' r f = do new <- liftM f (readIORef r)
writeIORef r $! new
modifyArray :: (MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m ()
modifyArray a i f = do new <- liftM f (readArray a i)
writeArray a i $! new
recordGivenClauseM :: FullClause f -> Metric -> IO ()
recordGivenClauseM cl (GS s c) = do modifyIORef' s (size cl +)
modifyIORef' c (1 +)
recordGivenClauseM _ _ = return ()
recordQueuedClausesM :: [FullClause f] -> Metric -> IO ()
recordQueuedClausesM cls (CG' x) = modifyIORef' x (length cls +)
recordQueuedClausesM _ _ = return ()
recordFiredRuleM :: RuleId -> [BasicClause] -> Metric -> IO ()
recordFiredRuleM _ cls (CG x) = modifyIORef' x (length cls +)
recordFiredRuleM rule _ (RC a) = modifyArray a rule (1 +)
recordFiredRuleM _ _ _ = return ()
recordSubsumedPremiseM :: Metric -> IO ()
recordSubsumedPremiseM (SP x) = modifyIORef' x (1+)
recordSubsumedPremiseM _ = return ()
recordLateSubsumedClauseM :: Int -> Metric -> IO ()
recordLateSubsumedClauseM n (LS x) = modifyIORef' x (n+)
recordLateSubsumedClauseM _ _ = return ()
ratio :: Int -> Int -> Float
ratio x y = (fromIntegral x) / (fromIntegral y)
------------------------------------ Metric builders -------------
mkUnique :: IO Metric -> IO UniqueMetric
mkUnique = liftM2 UM newUnique
rawClausesGenerated :: IO UniqueMetric
rawClausesGenerated = mkUnique . liftM CG $ newIORef 0
nonFwSubsumedClausesGenerated :: IO UniqueMetric
nonFwSubsumedClausesGenerated = mkUnique . liftM CG' $ newIORef 0
premisesSubsumedByConsequents :: IO UniqueMetric
premisesSubsumedByConsequents = mkUnique . liftM SP $ newIORef 0
lateSubsumedClauses :: IO UniqueMetric
lateSubsumedClauses = mkUnique . liftM LS $ newIORef 0
ruleApplicationCount :: IO UniqueMetric
ruleApplicationCount = mkUnique . liftM RC $ newArray (minBound, maxBound) 0
averageGivenClauseSize :: IO UniqueMetric
averageGivenClauseSize = mkUnique $ GS <$> (newIORef 0) <*> (newIORef 0)
|
nevrenato/HyLoRes_Source
|
src/HyLoRes/Statistics.hs
|
gpl-2.0
| 11,265 | 0 | 15 | 3,335 | 2,890 | 1,494 | 1,396 | -1 | -1 |
{-# LANGUAGE OverloadedStrings #-}
{- |
Module: TestMaker.Problems
Description: Parses the tex that holds the problem sets
Copyright: (c) Chris Godbout
License: GPLv3
Maintainer: [email protected]
Stability: experimental
Portability: portable
-}
module TestMaker.Problems where
import qualified Data.ByteString as B
import qualified Data.Text as T
import Data.Text.Encoding
import System.Random.Shuffle
import TestMaker.Types
import Text.Megaparsec
import Text.Megaparsec.Text
-- | This simply strips trailing whitespace. Yeah, there are parser combinators that do this, but I felt like doing it myself.
lexeme :: Parser a -> Parser a
lexeme p = do
x <- p
_ <- many $ oneOf (" \t\n" :: String)
return x
-- | In the latex style file, there are different options for correct or incorrect choices. This parser finds them.
choicedelim :: Parser String
choicedelim = lexeme $ try (string "\\correct") <|> string "\\choice"
-- | This parses individual choices. Doing it this way allows multi-line choices.
parseChoices' :: Parser Choice
parseChoices' = do
item <- choicedelim
opt <-
lexeme $ manyTill anyChar (try $ (() <$ lookAhead choicedelim) <|> eof)
if item == "\\choice"
then return $ Incorrect (T.strip $ T.pack opt)
else return $ Correct (T.strip $ T.pack opt)
-- TODO: Handle errors better.
-- | The actual function that takes a block of text and converts it into a list of choices. There's no error handling (yet), other than to return an empty list on failure. This is definitely not ideal.
parseChoices :: T.Text -> [Choice]
parseChoices cs =
case parse (many parseChoices') "" cs of
Right x -> x
Left _ -> []
-- | This parser takes care of the tags command.
tags :: Parser QItem
tags = do
_ <- try $ string "\\tags{"
tlist <- lexeme $ many (noneOf ("}" :: String))
_ <- lexeme $ char '}'
return $ QTags $ map T.toLower $ T.splitOn "," $ T.pack tlist
-- | This parser deals with "sagesilent"
setup :: Parser QItem
setup = do
_ <- try $ string "\\begin{sagesilent}"
bdy <- manyTill anyChar (try $ string "\\end{sagesilent}")
return $ QSetup $ T.pack bdy
-- | The parser for the main body of the question.
body :: Parser QItem
body = do
_ <- string "\\begin{body}"
bdy <- manyTill anyChar (try $ string "\\end{body}")
return $ QBody $ T.pack bdy
-- | This parser parses the choices environment.
choiceEnv :: Parser QItem
choiceEnv = do
_ <- lexeme $ string "\\begin{choices}{"
ncols <- lexeme $ some digitChar
_ <- lexeme $ char '}'
cs <- manyTill anyChar (try $ string "\\end{choices}")
return $ QChoices (read ncols :: Int, parseChoices $ T.pack cs)
-- | This takes care of integers - positive and negative. some digits doesn't work because I want to allow for negative id's. Negative id's are mainly dummy id's.
integer :: Parser Int
integer = rd <$> (plus <|> minus <|> number)
where
rd = read :: String -> Int
plus = char '+' *> number
minus = (:) <$> char '-' <*> number
number = some digitChar
-- | Parse a question that has a UID with it.
questionWithUID :: Parser Int
questionWithUID = do
_ <- string "\\begin{question}["
i <- integer
_ <- char ']'
return i
-- | Parse a question that does not.
questionNoUID :: Parser Int
questionNoUID = string "\\begin{question}" >> return (-1)
-- | Parse any QItems.
qitem :: Parser QItem
qitem = lexeme (try tags <|> try setup <|> try body <|> try choiceEnv)
-- | This takes everything in a question environment and turns into a Question.
question :: Parser Question
question = do
i <- lexeme (try questionWithUID <|> questionNoUID)
items <- many qitem
_ <-
lexeme $
manyTill
anyChar
(try $ (() <$ lookAhead (string "\\begin{question}")) <|> eof)
return $ createQuestion i items
-- | Parses a whole list of problems.
problemset :: Parser [Question]
problemset = do
_ <- manyTill anyChar (try $ lookAhead $ string "\\begin{question}")
many question
-- | This is just a convienence function to parse a problem set in a file.
-- TODO: Have it return just IO [Question]. There's no real need to return the error since I never handle it anyway.
parseProblemSet :: FilePath -- ^ Path to the file to parse.
-> IO [Question]
parseProblemSet fn = do
pset <- B.readFile fn
case runParser problemset fn (decodeUtf8 pset) of
Left _ -> return []
Right qs -> return qs
-- | Randomize choices in a question
shuffleChoices :: Question -> IO Question
shuffleChoices NullQuestion = return NullQuestion
shuffleChoices q = do
cs <- shuffleM (qChoices q)
return (modQuestion q (QChoices (qCols q, cs)))
-- | Helper function to randomize all the choices in a list of questions.
shuffleQList' :: [Question] -> [Question] -> IO [Question]
shuffleQList' qs [] = return qs
shuffleQList' qs (x:xs) = do
shuffled <- shuffleChoices =<< shuffleChoices x
shuffleQList' (qs ++ [shuffled]) xs
-- | Randomizes all of the choices in a list of questions.
shuffleQList :: [Question] -> IO [Question]
shuffleQList = shuffleQList' []
|
mathologist/hTestMaker
|
testmaker/src/TestMaker/Problems.hs
|
gpl-3.0
| 5,226 | 0 | 17 | 1,202 | 1,291 | 640 | 651 | 101 | 2 |
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}
-- Derived from AWS service descriptions, licensed under Apache 2.0.
-- |
-- Module : Network.AWS.RDS.PromoteReadReplica
-- Copyright : (c) 2013-2015 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Promotes a Read Replica DB instance to a standalone DB instance.
--
-- We recommend that you enable automated backups on your Read Replica
-- before promoting the Read Replica. This ensures that no backup is taken
-- during the promotion process. Once the instance is promoted to a primary
-- instance, backups are taken based on your backup settings.
--
-- /See:/ <http://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_PromoteReadReplica.html AWS API Reference> for PromoteReadReplica.
module Network.AWS.RDS.PromoteReadReplica
(
-- * Creating a Request
promoteReadReplica
, PromoteReadReplica
-- * Request Lenses
, prrPreferredBackupWindow
, prrBackupRetentionPeriod
, prrDBInstanceIdentifier
-- * Destructuring the Response
, promoteReadReplicaResponse
, PromoteReadReplicaResponse
-- * Response Lenses
, prrrsDBInstance
, prrrsResponseStatus
) where
import Network.AWS.Prelude
import Network.AWS.RDS.Types
import Network.AWS.RDS.Types.Product
import Network.AWS.Request
import Network.AWS.Response
-- |
--
-- /See:/ 'promoteReadReplica' smart constructor.
data PromoteReadReplica = PromoteReadReplica'
{ _prrPreferredBackupWindow :: !(Maybe Text)
, _prrBackupRetentionPeriod :: !(Maybe Int)
, _prrDBInstanceIdentifier :: !Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
-- | Creates a value of 'PromoteReadReplica' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'prrPreferredBackupWindow'
--
-- * 'prrBackupRetentionPeriod'
--
-- * 'prrDBInstanceIdentifier'
promoteReadReplica
:: Text -- ^ 'prrDBInstanceIdentifier'
-> PromoteReadReplica
promoteReadReplica pDBInstanceIdentifier_ =
PromoteReadReplica'
{ _prrPreferredBackupWindow = Nothing
, _prrBackupRetentionPeriod = Nothing
, _prrDBInstanceIdentifier = pDBInstanceIdentifier_
}
-- | The daily time range during which automated backups are created if
-- automated backups are enabled, using the 'BackupRetentionPeriod'
-- parameter.
--
-- Default: A 30-minute window selected at random from an 8-hour block of
-- time per region. To see the time blocks available, see
-- <http://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/AdjustingTheMaintenanceWindow.html Adjusting the Preferred Maintenance Window>
-- in the /Amazon RDS User Guide./
--
-- Constraints:
--
-- - Must be in the format 'hh24:mi-hh24:mi'.
-- - Times should be in Universal Coordinated Time (UTC).
-- - Must not conflict with the preferred maintenance window.
-- - Must be at least 30 minutes.
prrPreferredBackupWindow :: Lens' PromoteReadReplica (Maybe Text)
prrPreferredBackupWindow = lens _prrPreferredBackupWindow (\ s a -> s{_prrPreferredBackupWindow = a});
-- | The number of days to retain automated backups. Setting this parameter
-- to a positive number enables backups. Setting this parameter to 0
-- disables automated backups.
--
-- Default: 1
--
-- Constraints:
--
-- - Must be a value from 0 to 8
prrBackupRetentionPeriod :: Lens' PromoteReadReplica (Maybe Int)
prrBackupRetentionPeriod = lens _prrBackupRetentionPeriod (\ s a -> s{_prrBackupRetentionPeriod = a});
-- | The DB instance identifier. This value is stored as a lowercase string.
--
-- Constraints:
--
-- - Must be the identifier for an existing Read Replica DB instance
-- - Must contain from 1 to 63 alphanumeric characters or hyphens
-- - First character must be a letter
-- - Cannot end with a hyphen or contain two consecutive hyphens
--
-- Example: mydbinstance
prrDBInstanceIdentifier :: Lens' PromoteReadReplica Text
prrDBInstanceIdentifier = lens _prrDBInstanceIdentifier (\ s a -> s{_prrDBInstanceIdentifier = a});
instance AWSRequest PromoteReadReplica where
type Rs PromoteReadReplica =
PromoteReadReplicaResponse
request = postQuery rDS
response
= receiveXMLWrapper "PromoteReadReplicaResult"
(\ s h x ->
PromoteReadReplicaResponse' <$>
(x .@? "DBInstance") <*> (pure (fromEnum s)))
instance ToHeaders PromoteReadReplica where
toHeaders = const mempty
instance ToPath PromoteReadReplica where
toPath = const "/"
instance ToQuery PromoteReadReplica where
toQuery PromoteReadReplica'{..}
= mconcat
["Action" =: ("PromoteReadReplica" :: ByteString),
"Version" =: ("2014-10-31" :: ByteString),
"PreferredBackupWindow" =: _prrPreferredBackupWindow,
"BackupRetentionPeriod" =: _prrBackupRetentionPeriod,
"DBInstanceIdentifier" =: _prrDBInstanceIdentifier]
-- | /See:/ 'promoteReadReplicaResponse' smart constructor.
data PromoteReadReplicaResponse = PromoteReadReplicaResponse'
{ _prrrsDBInstance :: !(Maybe DBInstance)
, _prrrsResponseStatus :: !Int
} deriving (Eq,Read,Show,Data,Typeable,Generic)
-- | Creates a value of 'PromoteReadReplicaResponse' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'prrrsDBInstance'
--
-- * 'prrrsResponseStatus'
promoteReadReplicaResponse
:: Int -- ^ 'prrrsResponseStatus'
-> PromoteReadReplicaResponse
promoteReadReplicaResponse pResponseStatus_ =
PromoteReadReplicaResponse'
{ _prrrsDBInstance = Nothing
, _prrrsResponseStatus = pResponseStatus_
}
-- | Undocumented member.
prrrsDBInstance :: Lens' PromoteReadReplicaResponse (Maybe DBInstance)
prrrsDBInstance = lens _prrrsDBInstance (\ s a -> s{_prrrsDBInstance = a});
-- | The response status code.
prrrsResponseStatus :: Lens' PromoteReadReplicaResponse Int
prrrsResponseStatus = lens _prrrsResponseStatus (\ s a -> s{_prrrsResponseStatus = a});
|
fmapfmapfmap/amazonka
|
amazonka-rds/gen/Network/AWS/RDS/PromoteReadReplica.hs
|
mpl-2.0
| 6,540 | 0 | 13 | 1,229 | 741 | 456 | 285 | 89 | 1 |
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
-- | A collection of example programs that might be interesting to look at
-- during execution.
module Stg.ExamplePrograms (
-- * Simple introductory programs
implies,
addTwoNumbers,
calculateLength,
mapNot,
mapNotForced,
-- * Sum of list
-- ** via 'Data.Foldable.foldl''
sum_foldl',
-- ** via 'Data.Foldable.foldl'' implemented with 'foldr'
sum_foldl'ViaFoldr,
-- ** via 'foldl'
sum_foldl,
-- ** via 'foldr'
sum_foldr,
-- * Fibonacci
-- ** Naive implementation (exponential time)
fibonacciNaive,
-- ** Improved implementation (linear time)
fibonacciImproved,
-- ** Infinite list with zipWith (+)
fibonacciZipWith,
-- * List concatenation
-- | It is well-known that Haskell's (++) operator is linear if
-- associated to the right, but quadratic when associated to the left.
-- These two examples showcase the issue.
-- ** Right-associated
listConcatRightAssociated,
-- ** Left-associated
listConcatLeftAssociated,
-- * Sorting
naiveSort,
librarySort,
-- * Sharing
-- ** Repeat
repeatNaive,
repeatSharing,
) where
import Stg.Language
import Stg.Marshal
import Stg.Parser.QuasiQuoter
import qualified Stg.Prelude as Stg
-- | A program that calculates @x and not y@. This is probably the simplest
-- example program worth showing. It demonstrates how functions are evaluated,
-- has an update for the @main@ closure, and shows how nested functions result
-- in @let@ allocations.
implies :: Bool -> Bool -> Program
implies p q = mconcat
[ Stg.or2
, Stg.not
, toStg "p" p
, toStg "q" q
, [program|
main = \ => let notP = \ -> not p
in or2 notP q
|]]
-- | A program that adds two numbers.
addTwoNumbers :: Integer -> Integer -> Program
addTwoNumbers x y = mconcat
[ Stg.add
, toStg "x" x
, toStg "y" y
, [program|
main = \ => add x y
|]]
-- | A program that measures the length of a list.
calculateLength :: ToStg a => [a] -> Program
calculateLength xs = mconcat
[ Stg.length
, toStg "xs" xs
, [program|
main = \ => length xs
|]]
-- | Negate a list of booleans, but non-strictly. This program does almost
-- nothing, because nothing forces the list.
mapNot :: [Bool] -> Program
mapNot xs = mconcat
[ Stg.not
, Stg.map
, toStg "xs" xs
, [program|
main = \ => map not xs
|]]
-- | Negate a list of booleans strictly.
mapNotForced :: [Bool] -> Program
mapNotForced xs = mconcat
[ Stg.not
, Stg.map
, toStg "xs" xs
, [program|
main = \ => let mapped = \ => map not xs
in force mapped;
force = \bs -> case bs of
Nil -> Nil;
Cons y ys -> case y of
someBool -> case force ys of
someList -> Cons someBool someList;
badList -> error_force badList
|]]
-- | Program to sum up a list, but with the @sum@ function left undefined.
sumTemplate :: [Integer] -> Program
sumTemplate list = mconcat
[ Stg.add
, toStg "zero" (0 :: Integer)
, toStg "list" list
, [program| main = \ => sum list |]]
-- | Sum up a list of 'Integer's using
--
-- @
-- sum = 'Data.Foldable.foldl'' ('+') 0
-- @
--
-- This is a good way to sum up a list in Haskell, as it runs in constant space.
sum_foldl' :: [Integer] -> Program
sum_foldl' list = mconcat
[ sumTemplate list
, Stg.foldl'
, [program| sum = \ -> foldl' add zero |]]
-- | Sum up a list of 'Integer's using
--
-- @
-- sum = 'Data.Foldable.foldl'' ('+') 0
-- @
--
-- where 'Data.Foldable.foldl'' is implemented via 'foldr' as
--
-- @
-- foldl' f z ys = 'foldr' (\x xs acc -> xs '$!' f acc x) id ys z
-- @
--
-- which is a standard "'Data.Foldable.foldl'' in terms of 'foldr'" definition.
-- This definition is denotationally equivalent to the standard
-- 'Data.Foldable.foldl'', but has a bit more computational overhead.
sum_foldl'ViaFoldr :: [Integer] -> Program
sum_foldl'ViaFoldr list = mconcat
[ sumTemplate list
, Stg.id
, Stg.foldr
, [program|
sum = \ -> foldl' add zero;
foldl' = \f z xs ->
let go = \(f) x xs acc -> case f acc x of
forced -> xs forced
in foldr go id xs z
|]]
-- | Sum up a list of 'Integer's using
--
-- @
-- sum = 'foldl' ('+') 0
-- @
--
-- This is the canonical space leak in Haskell: note how the accumulator is
-- lazy, resulting in a large thunk buildup of suspended additions, that is only
-- collapsed to a final value after 'foldl' has terminated. The thunks are
-- stored on the heap, so it grows linearly with the length of the list. When
-- that thunk is forced, it will push lots of additions on the stack; in
-- summary, this produces a heap overflow, and if the heap is not exhausted, it
-- will try to overflow the stack.
sum_foldl :: [Integer] -> Program
sum_foldl list = mconcat
[ sumTemplate list
, Stg.foldl
, [program| sum = \ -> foldl add zero |]]
-- | Sum up a list of 'Integer's using
--
-- @
-- sum = 'foldr' ('+') 0
-- @
--
-- Like the 'foldl' version demonstrated in 'sum_foldl', this is a space-leaking
-- implementation of the sum of a list. In this case however, the leak spills to
-- the stack and the heap alike: the stack contains the continuations for the
-- additions, while the heap contains thunks for the recursive call to @foldr@.
sum_foldr :: [Integer] -> Program
sum_foldr list = mconcat
[ sumTemplate list
, Stg.foldr
, [program| sum = \ -> foldr add zero |]]
-- | Compute the list of Fibonacci numbers eagerly in the contents, but lazy in
-- the spine.
--
-- This means that the program will successively generate all the Fibonacci
-- numbers, allocating new cells of the infinite list and calculating their new
-- values, and garbage collecting previous values.
--
-- You can picture this as what happens to `fibo` in the Haskell program
--
-- @
-- main = let fibo = 'zipWith' ('+') fibo ('tail' fibo)
-- in 'Data.Foldable.traverse_' 'print' fibo
-- @
fibonacciZipWith :: Program
fibonacciZipWith = mconcat
[ Stg.add
, toStg "zero" (0 :: Integer)
, Stg.foldl'
, Stg.zipWith
, [program|
flipConst = \x y -> y;
main = \ =>
letrec
fibo = \ =>
letrec
fib0 = \(fib1) -> Cons zero fib1;
fib1 = \(fib2) =>
let one = \ -> Int# 1#
in Cons one fib2;
fib2 = \(fib0 fib1) => zipWith add fib0 fib1
in fib0
in foldl' flipConst zero fibo
|]]
-- | Calculate the n-th Fibonacci number using the computationally (horribly)
-- inefficient formula
--
-- @
-- fib n | n <= 1 = n
-- fib n = fib (n-1) + fib (n-2)
-- @
--
-- This implementation is stack-only, so enjoy watching it explode. At the time
-- of writing this, the machine takes:
--
-- * fib 0 => 27 steps
-- * fib 1 => 27 steps
-- * fib 2 => 122 steps
-- * fib 3 => 218 steps
-- * fib 4 => 410 steps
-- * fib 5 => 698 steps
-- * fib 6 => 1178 steps
-- * fib 7 => 1946 steps
-- * fib 8 => 3194 steps
-- * fib 9 => 5210 steps
-- * fib 10 => 8474 steps
fibonacciNaive :: Integer -> Program
fibonacciNaive n = mconcat
[ Stg.add
, Stg.leq_Int
, Stg.sub
, toStg "one" (1 :: Integer)
, toStg "n" n
, [program|
main = \ =>
letrec
fib = \(fib) n -> case leq_Int n one of
True -> n;
_False -> case sub n one of
nMinusOne -> case fib nMinusOne of
fibNMinusOne -> case sub nMinusOne one of
nMinusTwo -> case fib nMinusTwo of
fibNMinusTwo -> case add fibNMinusOne fibNMinusTwo of
result -> result
in fib n
|]]
-- | Calculate the n-th Fibonacci number using the more efficient formula
--
-- @
-- fib = fib' 0 1
-- where
-- fib' x _ | n <= 0 = x
-- fib' x !y n = fib' y (x+y) (n-1)
-- @
--
-- This implementation is a lot faster than the naive exponential
-- implementation. For example, calculating the 10th Fibonacci number (55) takes
-- only 490 steps, compared to the many thousands of the exponential version.
fibonacciImproved :: Integer -> Program
fibonacciImproved n = mconcat
[ Stg.add
, Stg.leq_Int
, Stg.sub
, toStg "zero" (0 :: Integer)
, toStg "one" (1 :: Integer)
, toStg "n" n
, [program|
main = \ =>
letrec
fib = \(fib') -> fib' zero one;
fib' = \(fib') x y n -> case leq_Int n zero of
True -> x;
_False -> case add x y of
xy -> case sub n one of
nMinusOne -> fib' y xy nMinusOne
in fib n
|]]
-- | List concatenation example with the 'concat' definition left out.
listConcatTemplate :: ToStg a => [[a]] -> Program
listConcatTemplate xss = mconcat
[ toStg "xss" xss
, Stg.concat2
, [program|
forceList = \xs -> case xs of
Nil -> Done;
Cons _ xs' -> forceList xs';
_ -> BadListError;
concatenated = \ => concat xss;
main = \ => case forceList concatenated of
_ -> concatenated
|]]
-- | Force a right-associated concatenation
--
-- @
-- [0] '++' ([1] '++' ([2] '++' ([3])))
-- @
--
-- and store it in the @main@ closure.
--
-- This computation is __linear__ in the number of elements of the sublists.
listConcatRightAssociated :: ToStg a => [[a]] -> Program
listConcatRightAssociated xss = mconcat
[ listConcatTemplate xss
, Stg.foldr
, [program| concat = \ -> foldr concat2 nil |]]
-- | Force a left-associated concatenation
--
-- @
-- (([0] '++' [1]) '++' [2]) '++' [3]
-- @
--
-- and store it in the @main@ closure.
--
-- This computation is __quadratic__ in the number of elements of the sublists.
listConcatLeftAssociated :: ToStg a => [[a]] -> Program
listConcatLeftAssociated xss = mconcat
[ listConcatTemplate xss
, Stg.foldl'
, [program| concat = \ -> foldl' concat2 nil |]]
-- | Sort a list with the canonical Quicksort-inspired algorithm often found
-- in introductory texts about Haskell.
--
-- Note that this is not Quicksort itself, as one key feature of it is sorting
-- in-place. In particular, this algorithm is not all that quick, as it takes
-- almost a thousand steps to reach the final state when sorting @[5,4,3,2,1]@.
naiveSort :: [Integer] -> Program
naiveSort xs =
toStg "xs" xs
<> Stg.forceSpine
<> Stg.naiveSort
<> [program|
sorted = \ => naiveSort xs;
main = \ => forceSpine sorted |]
-- | Sort a list with a translation of Haskell's 'Data.List.sort', which is
-- an implementation of mergesort with ordered sublist detection.
librarySort :: [Integer] -> Program
librarySort xs =
toStg "xs" xs
<> Stg.forceSpine
<> Stg.sort
<> [program|
sorted = \ => sort xs;
main = \ => forceSpine sorted |]
-- | This is a naive implementation of the 'repeat' function,
--
-- @
-- 'repeat' x = x : 'repeat' x
-- @
--
-- and it is used to compute the infinite repetition of a number. Run this
-- program for a couple hundred steps and observe the heap and the garbage
-- collector. Count the GC invocations, and compare it to the behaviour of
-- 'repeatSharing'! Also note how long it takes to generate two successive
-- list elements.
--
-- The reason for this behaviour is that the call to @'repeat' x@ is not shared,
-- but done again for each cons cell, requiring one heap allocation every time.
-- Cleaning up after this keeps the GC quite busy.
repeatNaive :: Program
repeatNaive = repeatSharing <> [program|
repeat = \x ->
let repeatX = \(x) -> repeat x
in Cons x repeatX
|]
-- | This uses a much better definition of 'repeat',
--
-- @
-- 'repeat' x = let repeatX = x : repeatX
-- in repeatX
-- @
--
-- This program does only a total of three heap allocations before continuously
-- running without interruption: one for the @repeated@ value, one for the
-- self-referencing cons cell, and one because of how 'Stg.forceSpine' works.
--
-- Note how much smaller the cycles between the traversal of two neighbouring
-- list cells are!
repeatSharing :: Program
repeatSharing = mconcat
[ Stg.forceSpine
, Stg.repeat
, [program|
main = \ =>
let repeated = \ -> repeat 1#
in case forceSpine repeated of v -> v
|]]
|
quchen/stg
|
src/Stg/ExamplePrograms.hs
|
bsd-3-clause
| 12,734 | 0 | 8 | 3,615 | 1,236 | 798 | 438 | 140 | 1 |
{-# LANGUAGE OverloadedStrings, TemplateHaskell, FunctionalDependencies #-}
module SecondTransfer.Http1.Types (
HttpRequest (..)
, headers_Rq
, body_Rq
, HttpResponse (..)
, headers_Rp
, body_Rp
, Http1CycleController (..)
, ProxyToHttpServer (..)
, ResponseBodyHandling (..)
) where
import Control.Lens
import qualified Data.ByteString as B
import Data.Conduit
import SimpleHttpHeadersHq
----- Types--- I may move some of the types here later to CoherentWorker --------
-- ... or to some other common-use file.
-- | Request. This is an old-fashioned HTTP request, with less data than that
-- defined at CoherentWorker: just headers and perhaps a request streaming body.
-- As in other places in this library, we expect method and path to be
-- given as pseudo-headers
data HttpRequest m = HttpRequest {
_headers_Rq :: HqHeaders
, _body_Rq :: Source m B.ByteString
}
makeLenses ''HttpRequest
-- | Response. Status should be given as a pseudo-header
data HttpResponse m = HttpResponse {
_headers_Rp :: HqHeaders
, _body_Rp :: Source m B.ByteString
}
makeLenses ''HttpResponse
-- | What to do with the source of ByteStrings to handle the body
data ResponseBodyHandling =
-- | This response have no body, any leftover bytes are for the next
-- response (pipelining?)
None_RBH
-- | No transfer-encoding
| PlainBytes_RBH
-- | There is a chunked transfer encoding. Use unwrapChunks over the
-- original source
| Chunked_RBH
-- Used for early release of resources
class Monad m => Http1CycleController m contrl where
releaseResponseResources :: contrl -> m ()
-- | Something that can talk to a HTTP 1.1 server by using a connection and sending
-- the request to it
class (Http1CycleController m contrl, Monad m) => ProxyToHttpServer m conn contrl | conn -> contrl m where
-- Sends the request to server, gets the response
proxyToConnection ::
conn
-> HttpRequest m
-> m (HttpResponse m, contrl)
|
shimmercat/second-transfer
|
hs-src/SecondTransfer/Http1/Types.hs
|
bsd-3-clause
| 2,464 | 0 | 11 | 871 | 279 | 168 | 111 | -1 | -1 |
{-# LANGUAGE Haskell98 #-}
{-# LINE 1 "Data/Text.hs" #-}
{-# LANGUAGE BangPatterns, CPP, MagicHash, Rank2Types, UnboxedTuples #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE TypeFamilies #-}
-- |
-- Module : Data.Text
-- Copyright : (c) 2009, 2010, 2011, 2012 Bryan O'Sullivan,
-- (c) 2009 Duncan Coutts,
-- (c) 2008, 2009 Tom Harper
--
-- License : BSD-style
-- Maintainer : [email protected]
-- Stability : experimental
-- Portability : GHC
--
-- A time and space-efficient implementation of Unicode text.
-- Suitable for performance critical use, both in terms of large data
-- quantities and high speed.
--
-- /Note/: Read below the synopsis for important notes on the use of
-- this module.
--
-- This module is intended to be imported @qualified@, to avoid name
-- clashes with "Prelude" functions, e.g.
--
-- > import qualified Data.Text as T
--
-- To use an extended and very rich family of functions for working
-- with Unicode text (including normalization, regular expressions,
-- non-standard encodings, text breaking, and locales), see
-- <http://hackage.haskell.org/package/text-icu the text-icu package >.
module Data.Text
(
-- * Strict vs lazy types
-- $strict
-- * Acceptable data
-- $replacement
-- * Fusion
-- $fusion
-- * Types
Text
-- * Creation and elimination
, pack
, unpack
, singleton
, empty
-- * Basic interface
, cons
, snoc
, append
, uncons
, head
, last
, tail
, init
, null
, length
, compareLength
-- * Transformations
, map
, intercalate
, intersperse
, transpose
, reverse
, replace
-- ** Case conversion
-- $case
, toCaseFold
, toLower
, toUpper
, toTitle
-- ** Justification
, justifyLeft
, justifyRight
, center
-- * Folds
, foldl
, foldl'
, foldl1
, foldl1'
, foldr
, foldr1
-- ** Special folds
, concat
, concatMap
, any
, all
, maximum
, minimum
-- * Construction
-- ** Scans
, scanl
, scanl1
, scanr
, scanr1
-- ** Accumulating maps
, mapAccumL
, mapAccumR
-- ** Generation and unfolding
, replicate
, unfoldr
, unfoldrN
-- * Substrings
-- ** Breaking strings
, take
, takeEnd
, drop
, dropEnd
, takeWhile
, takeWhileEnd
, dropWhile
, dropWhileEnd
, dropAround
, strip
, stripStart
, stripEnd
, splitAt
, breakOn
, breakOnEnd
, break
, span
, group
, groupBy
, inits
, tails
-- ** Breaking into many substrings
-- $split
, splitOn
, split
, chunksOf
-- ** Breaking into lines and words
, lines
--, lines'
, words
, unlines
, unwords
-- * Predicates
, isPrefixOf
, isSuffixOf
, isInfixOf
-- ** View patterns
, stripPrefix
, stripSuffix
, commonPrefixes
-- * Searching
, filter
, breakOnAll
, find
, partition
-- , findSubstring
-- * Indexing
-- $index
, index
, findIndex
, count
-- * Zipping
, zip
, zipWith
-- -* Ordered text
-- , sort
-- * Low level operations
, copy
, unpackCString#
) where
import Prelude (Char, Bool(..), Int, Maybe(..), String,
Eq(..), Ord(..), Ordering(..), (++),
Read(..),
(&&), (||), (+), (-), (.), ($), ($!), (>>),
not, return, otherwise, quot)
import Control.DeepSeq (NFData(rnf))
import Data.Char (isSpace)
import Data.Data (Data(gfoldl, toConstr, gunfold, dataTypeOf), constrIndex,
Constr, mkConstr, DataType, mkDataType, Fixity(Prefix))
import Control.Monad (foldM)
import Control.Monad.ST (ST)
import qualified Data.Text.Array as A
import qualified Data.List as L
import Data.Binary (Binary(get, put))
import Data.Monoid (Monoid(..))
import Data.Semigroup (Semigroup(..))
import Data.String (IsString(..))
import qualified Data.Text.Internal.Fusion as S
import qualified Data.Text.Internal.Fusion.Common as S
import Data.Text.Encoding (decodeUtf8', encodeUtf8)
import Data.Text.Internal.Fusion (stream, reverseStream, unstream)
import Data.Text.Internal.Private (span_)
import Data.Text.Internal (Text(..), empty, firstf, mul, safe, text)
import Data.Text.Show (singleton, unpack, unpackCString#)
import qualified Prelude as P
import Data.Text.Unsafe (Iter(..), iter, iter_, lengthWord16, reverseIter,
reverseIter_, unsafeHead, unsafeTail)
import Data.Text.Internal.Unsafe.Char (unsafeChr)
import qualified Data.Text.Internal.Functions as F
import qualified Data.Text.Internal.Encoding.Utf16 as U16
import Data.Text.Internal.Search (indices)
import GHC.Base (eqInt, neInt, gtInt, geInt, ltInt, leInt)
import qualified GHC.Exts as Exts
import Text.Printf (PrintfArg, formatArg, formatString)
-- $strict
--
-- This package provides both strict and lazy 'Text' types. The
-- strict type is provided by the "Data.Text" module, while the lazy
-- type is provided by the "Data.Text.Lazy" module. Internally, the
-- lazy @Text@ type consists of a list of strict chunks.
--
-- The strict 'Text' type requires that an entire string fit into
-- memory at once. The lazy 'Data.Text.Lazy.Text' type is capable of
-- streaming strings that are larger than memory using a small memory
-- footprint. In many cases, the overhead of chunked streaming makes
-- the lazy 'Data.Text.Lazy.Text' type slower than its strict
-- counterpart, but this is not always the case. Sometimes, the time
-- complexity of a function in one module may be different from the
-- other, due to their differing internal structures.
--
-- Each module provides an almost identical API, with the main
-- difference being that the strict module uses 'Int' values for
-- lengths and counts, while the lazy module uses 'Data.Int.Int64'
-- lengths.
-- $replacement
--
-- A 'Text' value is a sequence of Unicode scalar values, as defined
-- in
-- <http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf#page=35 §3.9, definition D76 of the Unicode 5.2 standard >.
-- As such, a 'Text' cannot contain values in the range U+D800 to
-- U+DFFF inclusive. Haskell implementations admit all Unicode code
-- points
-- (<http://www.unicode.org/versions/Unicode5.2.0/ch03.pdf#page=13 §3.4, definition D10 >)
-- as 'Char' values, including code points from this invalid range.
-- This means that there are some 'Char' values that are not valid
-- Unicode scalar values, and the functions in this module must handle
-- those cases.
--
-- Within this module, many functions construct a 'Text' from one or
-- more 'Char' values. Those functions will substitute 'Char' values
-- that are not valid Unicode scalar values with the replacement
-- character \"�\" (U+FFFD). Functions that perform this
-- inspection and replacement are documented with the phrase
-- \"Performs replacement on invalid scalar values\".
--
-- (One reason for this policy of replacement is that internally, a
-- 'Text' value is represented as packed UTF-16 data. Values in the
-- range U+D800 through U+DFFF are used by UTF-16 to denote surrogate
-- code points, and so cannot be represented. The functions replace
-- invalid scalar values, instead of dropping them, as a security
-- measure. For details, see
-- <http://unicode.org/reports/tr36/#Deletion_of_Noncharacters Unicode Technical Report 36, §3.5 >.)
-- $fusion
--
-- Most of the functions in this module are subject to /fusion/,
-- meaning that a pipeline of such functions will usually allocate at
-- most one 'Text' value.
--
-- As an example, consider the following pipeline:
--
-- > import Data.Text as T
-- > import Data.Text.Encoding as E
-- > import Data.ByteString (ByteString)
-- >
-- > countChars :: ByteString -> Int
-- > countChars = T.length . T.toUpper . E.decodeUtf8
--
-- From the type signatures involved, this looks like it should
-- allocate one 'Data.ByteString.ByteString' value, and two 'Text'
-- values. However, when a module is compiled with optimisation
-- enabled under GHC, the two intermediate 'Text' values will be
-- optimised away, and the function will be compiled down to a single
-- loop over the source 'Data.ByteString.ByteString'.
--
-- Functions that can be fused by the compiler are documented with the
-- phrase \"Subject to fusion\".
instance Eq Text where
Text arrA offA lenA == Text arrB offB lenB
| lenA == lenB = A.equal arrA offA arrB offB lenA
| otherwise = False
{-# INLINE (==) #-}
instance Ord Text where
compare = compareText
instance Read Text where
readsPrec p str = [(pack x,y) | (x,y) <- readsPrec p str]
-- Semigroup orphan instances for older GHCs are provided by
-- 'semigroups` package
instance Semigroup Text where
(<>) = append
instance Monoid Text where
mempty = empty
mappend = (<>) -- future-proof definition
mconcat = concat
instance IsString Text where
fromString = pack
instance Exts.IsList Text where
type Item Text = Char
fromList = pack
toList = unpack
instance NFData Text where rnf !_ = ()
instance Binary Text where
put t = put (encodeUtf8 t)
get = do
bs <- get
case decodeUtf8' bs of
P.Left exn -> P.fail (P.show exn)
P.Right a -> P.return a
-- | This instance preserves data abstraction at the cost of inefficiency.
-- We omit reflection services for the sake of data abstraction.
--
-- This instance was created by copying the updated behavior of
-- @"Data.Set".@'Data.Set.Set' and @"Data.Map".@'Data.Map.Map'. If you
-- feel a mistake has been made, please feel free to submit
-- improvements.
--
-- The original discussion is archived here:
-- <http://groups.google.com/group/haskell-cafe/browse_thread/thread/b5bbb1b28a7e525d/0639d46852575b93 could we get a Data instance for Data.Text.Text? >
--
-- The followup discussion that changed the behavior of 'Data.Set.Set'
-- and 'Data.Map.Map' is archived here:
-- <http://markmail.org/message/trovdc6zkphyi3cr#query:+page:1+mid:a46der3iacwjcf6n+state:results Proposal: Allow gunfold for Data.Map, ... >
instance Data Text where
gfoldl f z txt = z pack `f` (unpack txt)
toConstr _ = packConstr
gunfold k z c = case constrIndex c of
1 -> k (z pack)
_ -> P.error "gunfold"
dataTypeOf _ = textDataType
-- | Only defined for @base-4.7.0.0@ and later
instance PrintfArg Text where
formatArg txt = formatString $ unpack txt
packConstr :: Constr
packConstr = mkConstr textDataType "pack" [] Prefix
textDataType :: DataType
textDataType = mkDataType "Data.Text.Text" [packConstr]
-- | /O(n)/ Compare two 'Text' values lexicographically.
compareText :: Text -> Text -> Ordering
compareText ta@(Text _arrA _offA lenA) tb@(Text _arrB _offB lenB)
| lenA == 0 && lenB == 0 = EQ
| otherwise = go 0 0
where
go !i !j
| i >= lenA || j >= lenB = compare lenA lenB
| a < b = LT
| a > b = GT
| otherwise = go (i+di) (j+dj)
where Iter a di = iter ta i
Iter b dj = iter tb j
-- -----------------------------------------------------------------------------
-- * Conversion to/from 'Text'
-- | /O(n)/ Convert a 'String' into a 'Text'. Subject to
-- fusion. Performs replacement on invalid scalar values.
pack :: String -> Text
pack = unstream . S.map safe . S.streamList
{-# INLINE [1] pack #-}
-- -----------------------------------------------------------------------------
-- * Basic functions
-- | /O(n)/ Adds a character to the front of a 'Text'. This function
-- is more costly than its 'List' counterpart because it requires
-- copying a new array. Subject to fusion. Performs replacement on
-- invalid scalar values.
cons :: Char -> Text -> Text
cons c t = unstream (S.cons (safe c) (stream t))
{-# INLINE cons #-}
infixr 5 `cons`
-- | /O(n)/ Adds a character to the end of a 'Text'. This copies the
-- entire array in the process, unless fused. Subject to fusion.
-- Performs replacement on invalid scalar values.
snoc :: Text -> Char -> Text
snoc t c = unstream (S.snoc (stream t) (safe c))
{-# INLINE snoc #-}
-- | /O(n)/ Appends one 'Text' to the other by copying both of them
-- into a new 'Text'. Subject to fusion.
append :: Text -> Text -> Text
append a@(Text arr1 off1 len1) b@(Text arr2 off2 len2)
| len1 == 0 = b
| len2 == 0 = a
| len > 0 = Text (A.run x) 0 len
| otherwise = overflowError "append"
where
len = len1+len2
x :: ST s (A.MArray s)
x = do
arr <- A.new len
A.copyI arr 0 arr1 off1 len1
A.copyI arr len1 arr2 off2 len
return arr
{-# NOINLINE append #-}
{-# RULES
"TEXT append -> fused" [~1] forall t1 t2.
append t1 t2 = unstream (S.append (stream t1) (stream t2))
"TEXT append -> unfused" [1] forall t1 t2.
unstream (S.append (stream t1) (stream t2)) = append t1 t2
#-}
-- | /O(1)/ Returns the first character of a 'Text', which must be
-- non-empty. Subject to fusion.
head :: Text -> Char
head t = S.head (stream t)
{-# INLINE head #-}
-- | /O(1)/ Returns the first character and rest of a 'Text', or
-- 'Nothing' if empty. Subject to fusion.
uncons :: Text -> Maybe (Char, Text)
uncons t@(Text arr off len)
| len <= 0 = Nothing
| otherwise = Just $ let !(Iter c d) = iter t 0
in (c, text arr (off+d) (len-d))
{-# INLINE [1] uncons #-}
-- | Lifted from Control.Arrow and specialized.
second :: (b -> c) -> (a,b) -> (a,c)
second f (a, b) = (a, f b)
-- | /O(1)/ Returns the last character of a 'Text', which must be
-- non-empty. Subject to fusion.
last :: Text -> Char
last (Text arr off len)
| len <= 0 = emptyError "last"
| n < 0xDC00 || n > 0xDFFF = unsafeChr n
| otherwise = U16.chr2 n0 n
where n = A.unsafeIndex arr (off+len-1)
n0 = A.unsafeIndex arr (off+len-2)
{-# INLINE [1] last #-}
{-# RULES
"TEXT last -> fused" [~1] forall t.
last t = S.last (stream t)
"TEXT last -> unfused" [1] forall t.
S.last (stream t) = last t
#-}
-- | /O(1)/ Returns all characters after the head of a 'Text', which
-- must be non-empty. Subject to fusion.
tail :: Text -> Text
tail t@(Text arr off len)
| len <= 0 = emptyError "tail"
| otherwise = text arr (off+d) (len-d)
where d = iter_ t 0
{-# INLINE [1] tail #-}
{-# RULES
"TEXT tail -> fused" [~1] forall t.
tail t = unstream (S.tail (stream t))
"TEXT tail -> unfused" [1] forall t.
unstream (S.tail (stream t)) = tail t
#-}
-- | /O(1)/ Returns all but the last character of a 'Text', which must
-- be non-empty. Subject to fusion.
init :: Text -> Text
init (Text arr off len) | len <= 0 = emptyError "init"
| n >= 0xDC00 && n <= 0xDFFF = text arr off (len-2)
| otherwise = text arr off (len-1)
where
n = A.unsafeIndex arr (off+len-1)
{-# INLINE [1] init #-}
{-# RULES
"TEXT init -> fused" [~1] forall t.
init t = unstream (S.init (stream t))
"TEXT init -> unfused" [1] forall t.
unstream (S.init (stream t)) = init t
#-}
-- | /O(1)/ Tests whether a 'Text' is empty or not. Subject to
-- fusion.
null :: Text -> Bool
null (Text _arr _off len) =
len <= 0
{-# INLINE [1] null #-}
{-# RULES
"TEXT null -> fused" [~1] forall t.
null t = S.null (stream t)
"TEXT null -> unfused" [1] forall t.
S.null (stream t) = null t
#-}
-- | /O(1)/ Tests whether a 'Text' contains exactly one character.
-- Subject to fusion.
isSingleton :: Text -> Bool
isSingleton = S.isSingleton . stream
{-# INLINE isSingleton #-}
-- | /O(n)/ Returns the number of characters in a 'Text'.
-- Subject to fusion.
length :: Text -> Int
length t = S.length (stream t)
{-# INLINE [0] length #-}
-- length needs to be phased after the compareN/length rules otherwise
-- it may inline before the rules have an opportunity to fire.
-- | /O(n)/ Compare the count of characters in a 'Text' to a number.
-- Subject to fusion.
--
-- This function gives the same answer as comparing against the result
-- of 'length', but can short circuit if the count of characters is
-- greater than the number, and hence be more efficient.
compareLength :: Text -> Int -> Ordering
compareLength t n = S.compareLengthI (stream t) n
{-# INLINE [1] compareLength #-}
{-# RULES
"TEXT compareN/length -> compareLength" [~1] forall t n.
compare (length t) n = compareLength t n
#-}
{-# RULES
"TEXT ==N/length -> compareLength/==EQ" [~1] forall t n.
eqInt (length t) n = compareLength t n == EQ
#-}
{-# RULES
"TEXT /=N/length -> compareLength//=EQ" [~1] forall t n.
neInt (length t) n = compareLength t n /= EQ
#-}
{-# RULES
"TEXT <N/length -> compareLength/==LT" [~1] forall t n.
ltInt (length t) n = compareLength t n == LT
#-}
{-# RULES
"TEXT <=N/length -> compareLength//=GT" [~1] forall t n.
leInt (length t) n = compareLength t n /= GT
#-}
{-# RULES
"TEXT >N/length -> compareLength/==GT" [~1] forall t n.
gtInt (length t) n = compareLength t n == GT
#-}
{-# RULES
"TEXT >=N/length -> compareLength//=LT" [~1] forall t n.
geInt (length t) n = compareLength t n /= LT
#-}
-- -----------------------------------------------------------------------------
-- * Transformations
-- | /O(n)/ 'map' @f@ @t@ is the 'Text' obtained by applying @f@ to
-- each element of @t@. Subject to fusion. Performs replacement on
-- invalid scalar values.
map :: (Char -> Char) -> Text -> Text
map f t = unstream (S.map (safe . f) (stream t))
{-# INLINE [1] map #-}
-- | /O(n)/ The 'intercalate' function takes a 'Text' and a list of
-- 'Text's and concatenates the list after interspersing the first
-- argument between each element of the list.
intercalate :: Text -> [Text] -> Text
intercalate t = concat . (F.intersperse t)
{-# INLINE intercalate #-}
-- | /O(n)/ The 'intersperse' function takes a character and places it
-- between the characters of a 'Text'. Subject to fusion. Performs
-- replacement on invalid scalar values.
intersperse :: Char -> Text -> Text
intersperse c t = unstream (S.intersperse (safe c) (stream t))
{-# INLINE intersperse #-}
-- | /O(n)/ Reverse the characters of a string. Subject to fusion.
reverse :: Text -> Text
reverse t = S.reverse (stream t)
{-# INLINE reverse #-}
-- | /O(m+n)/ Replace every non-overlapping occurrence of @needle@ in
-- @haystack@ with @replacement@.
--
-- This function behaves as though it was defined as follows:
--
-- @
-- replace needle replacement haystack =
-- 'intercalate' replacement ('splitOn' needle haystack)
-- @
--
-- As this suggests, each occurrence is replaced exactly once. So if
-- @needle@ occurs in @replacement@, that occurrence will /not/ itself
-- be replaced recursively:
--
-- > replace "oo" "foo" "oo" == "foo"
--
-- In cases where several instances of @needle@ overlap, only the
-- first one will be replaced:
--
-- > replace "ofo" "bar" "ofofo" == "barfo"
--
-- In (unlikely) bad cases, this function's time complexity degrades
-- towards /O(n*m)/.
replace :: Text
-- ^ @needle@ to search for. If this string is empty, an
-- error will occur.
-> Text
-- ^ @replacement@ to replace @needle@ with.
-> Text
-- ^ @haystack@ in which to search.
-> Text
replace needle@(Text _ _ neeLen)
(Text repArr repOff repLen)
haystack@(Text hayArr hayOff hayLen)
| neeLen == 0 = emptyError "replace"
| L.null ixs = haystack
| len > 0 = Text (A.run x) 0 len
| otherwise = empty
where
ixs = indices needle haystack
len = hayLen - (neeLen - repLen) `mul` L.length ixs
x :: ST s (A.MArray s)
x = do
marr <- A.new len
let loop (i:is) o d = do
let d0 = d + i - o
d1 = d0 + repLen
A.copyI marr d hayArr (hayOff+o) d0
A.copyI marr d0 repArr repOff d1
loop is (i + neeLen) d1
loop [] o d = A.copyI marr d hayArr (hayOff+o) len
loop ixs 0 0
return marr
-- ----------------------------------------------------------------------------
-- ** Case conversions (folds)
-- $case
--
-- When case converting 'Text' values, do not use combinators like
-- @map toUpper@ to case convert each character of a string
-- individually, as this gives incorrect results according to the
-- rules of some writing systems. The whole-string case conversion
-- functions from this module, such as @toUpper@, obey the correct
-- case conversion rules. As a result, these functions may map one
-- input character to two or three output characters. For examples,
-- see the documentation of each function.
--
-- /Note/: In some languages, case conversion is a locale- and
-- context-dependent operation. The case conversion functions in this
-- module are /not/ locale sensitive. Programs that require locale
-- sensitivity should use appropriate versions of the
-- <http://hackage.haskell.org/package/text-icu-0.6.3.7/docs/Data-Text-ICU.html#g:4 case mapping functions from the text-icu package >.
-- | /O(n)/ Convert a string to folded case. Subject to fusion.
--
-- This function is mainly useful for performing caseless (also known
-- as case insensitive) string comparisons.
--
-- A string @x@ is a caseless match for a string @y@ if and only if:
--
-- @toCaseFold x == toCaseFold y@
--
-- The result string may be longer than the input string, and may
-- differ from applying 'toLower' to the input string. For instance,
-- the Armenian small ligature \"ﬓ\" (men now, U+FB13) is case
-- folded to the sequence \"մ\" (men, U+0574) followed by
-- \"ն\" (now, U+0576), while the Greek \"µ\" (micro sign,
-- U+00B5) is case folded to \"μ\" (small letter mu, U+03BC)
-- instead of itself.
toCaseFold :: Text -> Text
toCaseFold t = unstream (S.toCaseFold (stream t))
{-# INLINE toCaseFold #-}
-- | /O(n)/ Convert a string to lower case, using simple case
-- conversion. Subject to fusion.
--
-- The result string may be longer than the input string. For
-- instance, \"İ\" (Latin capital letter I with dot above,
-- U+0130) maps to the sequence \"i\" (Latin small letter i, U+0069)
-- followed by \" ̇\" (combining dot above, U+0307).
toLower :: Text -> Text
toLower t = unstream (S.toLower (stream t))
{-# INLINE toLower #-}
-- | /O(n)/ Convert a string to upper case, using simple case
-- conversion. Subject to fusion.
--
-- The result string may be longer than the input string. For
-- instance, the German \"ß\" (eszett, U+00DF) maps to the
-- two-letter sequence \"SS\".
toUpper :: Text -> Text
toUpper t = unstream (S.toUpper (stream t))
{-# INLINE toUpper #-}
-- | /O(n)/ Convert a string to title case, using simple case
-- conversion. Subject to fusion.
--
-- The first letter of the input is converted to title case, as is
-- every subsequent letter that immediately follows a non-letter.
-- Every letter that immediately follows another letter is converted
-- to lower case.
--
-- The result string may be longer than the input string. For example,
-- the Latin small ligature fl (U+FB02) is converted to the
-- sequence Latin capital letter F (U+0046) followed by Latin small
-- letter l (U+006C).
--
-- /Note/: this function does not take language or culture specific
-- rules into account. For instance, in English, different style
-- guides disagree on whether the book name \"The Hill of the Red
-- Fox\" is correctly title cased—but this function will
-- capitalize /every/ word.
toTitle :: Text -> Text
toTitle t = unstream (S.toTitle (stream t))
{-# INLINE toTitle #-}
-- | /O(n)/ Left-justify a string to the given length, using the
-- specified fill character on the right. Subject to fusion.
-- Performs replacement on invalid scalar values.
--
-- Examples:
--
-- > justifyLeft 7 'x' "foo" == "fooxxxx"
-- > justifyLeft 3 'x' "foobar" == "foobar"
justifyLeft :: Int -> Char -> Text -> Text
justifyLeft k c t
| len >= k = t
| otherwise = t `append` replicateChar (k-len) c
where len = length t
{-# INLINE [1] justifyLeft #-}
{-# RULES
"TEXT justifyLeft -> fused" [~1] forall k c t.
justifyLeft k c t = unstream (S.justifyLeftI k c (stream t))
"TEXT justifyLeft -> unfused" [1] forall k c t.
unstream (S.justifyLeftI k c (stream t)) = justifyLeft k c t
#-}
-- | /O(n)/ Right-justify a string to the given length, using the
-- specified fill character on the left. Performs replacement on
-- invalid scalar values.
--
-- Examples:
--
-- > justifyRight 7 'x' "bar" == "xxxxbar"
-- > justifyRight 3 'x' "foobar" == "foobar"
justifyRight :: Int -> Char -> Text -> Text
justifyRight k c t
| len >= k = t
| otherwise = replicateChar (k-len) c `append` t
where len = length t
{-# INLINE justifyRight #-}
-- | /O(n)/ Center a string to the given length, using the specified
-- fill character on either side. Performs replacement on invalid
-- scalar values.
--
-- Examples:
--
-- > center 8 'x' "HS" = "xxxHSxxx"
center :: Int -> Char -> Text -> Text
center k c t
| len >= k = t
| otherwise = replicateChar l c `append` t `append` replicateChar r c
where len = length t
d = k - len
r = d `quot` 2
l = d - r
{-# INLINE center #-}
-- | /O(n)/ The 'transpose' function transposes the rows and columns
-- of its 'Text' argument. Note that this function uses 'pack',
-- 'unpack', and the list version of transpose, and is thus not very
-- efficient.
transpose :: [Text] -> [Text]
transpose ts = P.map pack (L.transpose (P.map unpack ts))
-- -----------------------------------------------------------------------------
-- * Reducing 'Text's (folds)
-- | /O(n)/ 'foldl', applied to a binary operator, a starting value
-- (typically the left-identity of the operator), and a 'Text',
-- reduces the 'Text' using the binary operator, from left to right.
-- Subject to fusion.
foldl :: (a -> Char -> a) -> a -> Text -> a
foldl f z t = S.foldl f z (stream t)
{-# INLINE foldl #-}
-- | /O(n)/ A strict version of 'foldl'. Subject to fusion.
foldl' :: (a -> Char -> a) -> a -> Text -> a
foldl' f z t = S.foldl' f z (stream t)
{-# INLINE foldl' #-}
-- | /O(n)/ A variant of 'foldl' that has no starting value argument,
-- and thus must be applied to a non-empty 'Text'. Subject to fusion.
foldl1 :: (Char -> Char -> Char) -> Text -> Char
foldl1 f t = S.foldl1 f (stream t)
{-# INLINE foldl1 #-}
-- | /O(n)/ A strict version of 'foldl1'. Subject to fusion.
foldl1' :: (Char -> Char -> Char) -> Text -> Char
foldl1' f t = S.foldl1' f (stream t)
{-# INLINE foldl1' #-}
-- | /O(n)/ 'foldr', applied to a binary operator, a starting value
-- (typically the right-identity of the operator), and a 'Text',
-- reduces the 'Text' using the binary operator, from right to left.
-- Subject to fusion.
foldr :: (Char -> a -> a) -> a -> Text -> a
foldr f z t = S.foldr f z (stream t)
{-# INLINE foldr #-}
-- | /O(n)/ A variant of 'foldr' that has no starting value argument,
-- and thus must be applied to a non-empty 'Text'. Subject to
-- fusion.
foldr1 :: (Char -> Char -> Char) -> Text -> Char
foldr1 f t = S.foldr1 f (stream t)
{-# INLINE foldr1 #-}
-- -----------------------------------------------------------------------------
-- ** Special folds
-- | /O(n)/ Concatenate a list of 'Text's.
concat :: [Text] -> Text
concat ts = case ts' of
[] -> empty
[t] -> t
_ -> Text (A.run go) 0 len
where
ts' = L.filter (not . null) ts
len = sumP "concat" $ L.map lengthWord16 ts'
go :: ST s (A.MArray s)
go = do
arr <- A.new len
let step i (Text a o l) =
let !j = i + l in A.copyI arr i a o j >> return j
foldM step 0 ts' >> return arr
-- | /O(n)/ Map a function over a 'Text' that results in a 'Text', and
-- concatenate the results.
concatMap :: (Char -> Text) -> Text -> Text
concatMap f = concat . foldr ((:) . f) []
{-# INLINE concatMap #-}
-- | /O(n)/ 'any' @p@ @t@ determines whether any character in the
-- 'Text' @t@ satisfies the predicate @p@. Subject to fusion.
any :: (Char -> Bool) -> Text -> Bool
any p t = S.any p (stream t)
{-# INLINE any #-}
-- | /O(n)/ 'all' @p@ @t@ determines whether all characters in the
-- 'Text' @t@ satisfy the predicate @p@. Subject to fusion.
all :: (Char -> Bool) -> Text -> Bool
all p t = S.all p (stream t)
{-# INLINE all #-}
-- | /O(n)/ 'maximum' returns the maximum value from a 'Text', which
-- must be non-empty. Subject to fusion.
maximum :: Text -> Char
maximum t = S.maximum (stream t)
{-# INLINE maximum #-}
-- | /O(n)/ 'minimum' returns the minimum value from a 'Text', which
-- must be non-empty. Subject to fusion.
minimum :: Text -> Char
minimum t = S.minimum (stream t)
{-# INLINE minimum #-}
-- -----------------------------------------------------------------------------
-- * Building 'Text's
-- | /O(n)/ 'scanl' is similar to 'foldl', but returns a list of
-- successive reduced values from the left. Subject to fusion.
-- Performs replacement on invalid scalar values.
--
-- > scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--
-- Note that
--
-- > last (scanl f z xs) == foldl f z xs.
scanl :: (Char -> Char -> Char) -> Char -> Text -> Text
scanl f z t = unstream (S.scanl g z (stream t))
where g a b = safe (f a b)
{-# INLINE scanl #-}
-- | /O(n)/ 'scanl1' is a variant of 'scanl' that has no starting
-- value argument. Subject to fusion. Performs replacement on
-- invalid scalar values.
--
-- > scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
scanl1 :: (Char -> Char -> Char) -> Text -> Text
scanl1 f t | null t = empty
| otherwise = scanl f (unsafeHead t) (unsafeTail t)
{-# INLINE scanl1 #-}
-- | /O(n)/ 'scanr' is the right-to-left dual of 'scanl'. Performs
-- replacement on invalid scalar values.
--
-- > scanr f v == reverse . scanl (flip f) v . reverse
scanr :: (Char -> Char -> Char) -> Char -> Text -> Text
scanr f z = S.reverse . S.reverseScanr g z . reverseStream
where g a b = safe (f a b)
{-# INLINE scanr #-}
-- | /O(n)/ 'scanr1' is a variant of 'scanr' that has no starting
-- value argument. Subject to fusion. Performs replacement on
-- invalid scalar values.
scanr1 :: (Char -> Char -> Char) -> Text -> Text
scanr1 f t | null t = empty
| otherwise = scanr f (last t) (init t)
{-# INLINE scanr1 #-}
-- | /O(n)/ Like a combination of 'map' and 'foldl''. Applies a
-- function to each element of a 'Text', passing an accumulating
-- parameter from left to right, and returns a final 'Text'. Performs
-- replacement on invalid scalar values.
mapAccumL :: (a -> Char -> (a,Char)) -> a -> Text -> (a, Text)
mapAccumL f z0 = S.mapAccumL g z0 . stream
where g a b = second safe (f a b)
{-# INLINE mapAccumL #-}
-- | The 'mapAccumR' function behaves like a combination of 'map' and
-- a strict 'foldr'; it applies a function to each element of a
-- 'Text', passing an accumulating parameter from right to left, and
-- returning a final value of this accumulator together with the new
-- 'Text'.
-- Performs replacement on invalid scalar values.
mapAccumR :: (a -> Char -> (a,Char)) -> a -> Text -> (a, Text)
mapAccumR f z0 = second reverse . S.mapAccumL g z0 . reverseStream
where g a b = second safe (f a b)
{-# INLINE mapAccumR #-}
-- -----------------------------------------------------------------------------
-- ** Generating and unfolding 'Text's
-- | /O(n*m)/ 'replicate' @n@ @t@ is a 'Text' consisting of the input
-- @t@ repeated @n@ times.
replicate :: Int -> Text -> Text
replicate n t@(Text a o l)
| n <= 0 || l <= 0 = empty
| n == 1 = t
| isSingleton t = replicateChar n (unsafeHead t)
| otherwise = Text (A.run x) 0 len
where
len = l `mul` n
x :: ST s (A.MArray s)
x = do
arr <- A.new len
let loop !d !i | i >= n = return arr
| otherwise = let m = d + l
in A.copyI arr d a o m >> loop m (i+1)
loop 0 0
{-# INLINE [1] replicate #-}
{-# RULES
"TEXT replicate/singleton -> replicateChar" [~1] forall n c.
replicate n (singleton c) = replicateChar n c
#-}
-- | /O(n)/ 'replicateChar' @n@ @c@ is a 'Text' of length @n@ with @c@ the
-- value of every element. Subject to fusion.
replicateChar :: Int -> Char -> Text
replicateChar n c = unstream (S.replicateCharI n (safe c))
{-# INLINE replicateChar #-}
-- | /O(n)/, where @n@ is the length of the result. The 'unfoldr'
-- function is analogous to the List 'L.unfoldr'. 'unfoldr' builds a
-- 'Text' from a seed value. The function takes the element and
-- returns 'Nothing' if it is done producing the 'Text', otherwise
-- 'Just' @(a,b)@. In this case, @a@ is the next 'Char' in the
-- string, and @b@ is the seed value for further production. Subject
-- to fusion. Performs replacement on invalid scalar values.
unfoldr :: (a -> Maybe (Char,a)) -> a -> Text
unfoldr f s = unstream (S.unfoldr (firstf safe . f) s)
{-# INLINE unfoldr #-}
-- | /O(n)/ Like 'unfoldr', 'unfoldrN' builds a 'Text' from a seed
-- value. However, the length of the result should be limited by the
-- first argument to 'unfoldrN'. This function is more efficient than
-- 'unfoldr' when the maximum length of the result is known and
-- correct, otherwise its performance is similar to 'unfoldr'. Subject
-- to fusion. Performs replacement on invalid scalar values.
unfoldrN :: Int -> (a -> Maybe (Char,a)) -> a -> Text
unfoldrN n f s = unstream (S.unfoldrN n (firstf safe . f) s)
{-# INLINE unfoldrN #-}
-- -----------------------------------------------------------------------------
-- * Substrings
-- | /O(n)/ 'take' @n@, applied to a 'Text', returns the prefix of the
-- 'Text' of length @n@, or the 'Text' itself if @n@ is greater than
-- the length of the Text. Subject to fusion.
take :: Int -> Text -> Text
take n t@(Text arr off len)
| n <= 0 = empty
| n >= len = t
| otherwise = text arr off (iterN n t)
{-# INLINE [1] take #-}
iterN :: Int -> Text -> Int
iterN n t@(Text _arr _off len) = loop 0 0
where loop !i !cnt
| i >= len || cnt >= n = i
| otherwise = loop (i+d) (cnt+1)
where d = iter_ t i
{-# RULES
"TEXT take -> fused" [~1] forall n t.
take n t = unstream (S.take n (stream t))
"TEXT take -> unfused" [1] forall n t.
unstream (S.take n (stream t)) = take n t
#-}
-- | /O(n)/ 'takeEnd' @n@ @t@ returns the suffix remaining after
-- taking @n@ characters from the end of @t@.
--
-- Examples:
--
-- > takeEnd 3 "foobar" == "bar"
takeEnd :: Int -> Text -> Text
takeEnd n t@(Text arr off len)
| n <= 0 = empty
| n >= len = t
| otherwise = text arr (off+i) (len-i)
where i = iterNEnd n t
iterNEnd :: Int -> Text -> Int
iterNEnd n t@(Text _arr _off len) = loop (len-1) n
where loop i !m
| m <= 0 = i+1
| i <= 0 = 0
| otherwise = loop (i+d) (m-1)
where d = reverseIter_ t i
-- | /O(n)/ 'drop' @n@, applied to a 'Text', returns the suffix of the
-- 'Text' after the first @n@ characters, or the empty 'Text' if @n@
-- is greater than the length of the 'Text'. Subject to fusion.
drop :: Int -> Text -> Text
drop n t@(Text arr off len)
| n <= 0 = t
| n >= len = empty
| otherwise = text arr (off+i) (len-i)
where i = iterN n t
{-# INLINE [1] drop #-}
{-# RULES
"TEXT drop -> fused" [~1] forall n t.
drop n t = unstream (S.drop n (stream t))
"TEXT drop -> unfused" [1] forall n t.
unstream (S.drop n (stream t)) = drop n t
#-}
-- | /O(n)/ 'dropEnd' @n@ @t@ returns the prefix remaining after
-- dropping @n@ characters from the end of @t@.
--
-- Examples:
--
-- > dropEnd 3 "foobar" == "foo"
dropEnd :: Int -> Text -> Text
dropEnd n t@(Text arr off len)
| n <= 0 = t
| n >= len = empty
| otherwise = text arr off (iterNEnd n t)
-- | /O(n)/ 'takeWhile', applied to a predicate @p@ and a 'Text',
-- returns the longest prefix (possibly empty) of elements that
-- satisfy @p@. Subject to fusion.
takeWhile :: (Char -> Bool) -> Text -> Text
takeWhile p t@(Text arr off len) = loop 0
where loop !i | i >= len = t
| p c = loop (i+d)
| otherwise = text arr off i
where Iter c d = iter t i
{-# INLINE [1] takeWhile #-}
{-# RULES
"TEXT takeWhile -> fused" [~1] forall p t.
takeWhile p t = unstream (S.takeWhile p (stream t))
"TEXT takeWhile -> unfused" [1] forall p t.
unstream (S.takeWhile p (stream t)) = takeWhile p t
#-}
-- | /O(n)/ 'takeWhileEnd', applied to a predicate @p@ and a 'Text',
-- returns the longest suffix (possibly empty) of elements that
-- satisfy @p@. Subject to fusion.
-- Examples:
--
-- > takeWhileEnd (=='o') "foo" == "oo"
takeWhileEnd :: (Char -> Bool) -> Text -> Text
takeWhileEnd p t@(Text arr off len) = loop (len-1) len
where loop !i !l | l <= 0 = t
| p c = loop (i+d) (l+d)
| otherwise = text arr (off+l) (len-l)
where (c,d) = reverseIter t i
{-# INLINE [1] takeWhileEnd #-}
{-# RULES
"TEXT takeWhileEnd -> fused" [~1] forall p t.
takeWhileEnd p t = S.reverse (S.takeWhile p (S.reverseStream t))
"TEXT takeWhileEnd -> unfused" [1] forall p t.
S.reverse (S.takeWhile p (S.reverseStream t)) = takeWhileEnd p t
#-}
-- | /O(n)/ 'dropWhile' @p@ @t@ returns the suffix remaining after
-- 'takeWhile' @p@ @t@. Subject to fusion.
dropWhile :: (Char -> Bool) -> Text -> Text
dropWhile p t@(Text arr off len) = loop 0 0
where loop !i !l | l >= len = empty
| p c = loop (i+d) (l+d)
| otherwise = Text arr (off+i) (len-l)
where Iter c d = iter t i
{-# INLINE [1] dropWhile #-}
{-# RULES
"TEXT dropWhile -> fused" [~1] forall p t.
dropWhile p t = unstream (S.dropWhile p (stream t))
"TEXT dropWhile -> unfused" [1] forall p t.
unstream (S.dropWhile p (stream t)) = dropWhile p t
#-}
-- | /O(n)/ 'dropWhileEnd' @p@ @t@ returns the prefix remaining after
-- dropping characters that satisfy the predicate @p@ from the end of
-- @t@. Subject to fusion.
--
-- Examples:
--
-- > dropWhileEnd (=='.') "foo..." == "foo"
dropWhileEnd :: (Char -> Bool) -> Text -> Text
dropWhileEnd p t@(Text arr off len) = loop (len-1) len
where loop !i !l | l <= 0 = empty
| p c = loop (i+d) (l+d)
| otherwise = Text arr off l
where (c,d) = reverseIter t i
{-# INLINE [1] dropWhileEnd #-}
{-# RULES
"TEXT dropWhileEnd -> fused" [~1] forall p t.
dropWhileEnd p t = S.reverse (S.dropWhile p (S.reverseStream t))
"TEXT dropWhileEnd -> unfused" [1] forall p t.
S.reverse (S.dropWhile p (S.reverseStream t)) = dropWhileEnd p t
#-}
-- | /O(n)/ 'dropAround' @p@ @t@ returns the substring remaining after
-- dropping characters that satisfy the predicate @p@ from both the
-- beginning and end of @t@. Subject to fusion.
dropAround :: (Char -> Bool) -> Text -> Text
dropAround p = dropWhile p . dropWhileEnd p
{-# INLINE [1] dropAround #-}
-- | /O(n)/ Remove leading white space from a string. Equivalent to:
--
-- > dropWhile isSpace
stripStart :: Text -> Text
stripStart = dropWhile isSpace
{-# INLINE [1] stripStart #-}
-- | /O(n)/ Remove trailing white space from a string. Equivalent to:
--
-- > dropWhileEnd isSpace
stripEnd :: Text -> Text
stripEnd = dropWhileEnd isSpace
{-# INLINE [1] stripEnd #-}
-- | /O(n)/ Remove leading and trailing white space from a string.
-- Equivalent to:
--
-- > dropAround isSpace
strip :: Text -> Text
strip = dropAround isSpace
{-# INLINE [1] strip #-}
-- | /O(n)/ 'splitAt' @n t@ returns a pair whose first element is a
-- prefix of @t@ of length @n@, and whose second is the remainder of
-- the string. It is equivalent to @('take' n t, 'drop' n t)@.
splitAt :: Int -> Text -> (Text, Text)
splitAt n t@(Text arr off len)
| n <= 0 = (empty, t)
| n >= len = (t, empty)
| otherwise = let k = iterN n t
in (text arr off k, text arr (off+k) (len-k))
-- | /O(n)/ 'span', applied to a predicate @p@ and text @t@, returns
-- a pair whose first element is the longest prefix (possibly empty)
-- of @t@ of elements that satisfy @p@, and whose second is the
-- remainder of the list.
span :: (Char -> Bool) -> Text -> (Text, Text)
span p t = case span_ p t of
(# hd,tl #) -> (hd,tl)
{-# INLINE span #-}
-- | /O(n)/ 'break' is like 'span', but the prefix returned is
-- over elements that fail the predicate @p@.
break :: (Char -> Bool) -> Text -> (Text, Text)
break p = span (not . p)
{-# INLINE break #-}
-- | /O(n)/ Group characters in a string according to a predicate.
groupBy :: (Char -> Char -> Bool) -> Text -> [Text]
groupBy p = loop
where
loop t@(Text arr off len)
| null t = []
| otherwise = text arr off n : loop (text arr (off+n) (len-n))
where Iter c d = iter t 0
n = d + findAIndexOrEnd (not . p c) (Text arr (off+d) (len-d))
-- | Returns the /array/ index (in units of 'Word16') at which a
-- character may be found. This is /not/ the same as the logical
-- index returned by e.g. 'findIndex'.
findAIndexOrEnd :: (Char -> Bool) -> Text -> Int
findAIndexOrEnd q t@(Text _arr _off len) = go 0
where go !i | i >= len || q c = i
| otherwise = go (i+d)
where Iter c d = iter t i
-- | /O(n)/ Group characters in a string by equality.
group :: Text -> [Text]
group = groupBy (==)
-- | /O(n)/ Return all initial segments of the given 'Text', shortest
-- first.
inits :: Text -> [Text]
inits t@(Text arr off len) = loop 0
where loop i | i >= len = [t]
| otherwise = Text arr off i : loop (i + iter_ t i)
-- | /O(n)/ Return all final segments of the given 'Text', longest
-- first.
tails :: Text -> [Text]
tails t | null t = [empty]
| otherwise = t : tails (unsafeTail t)
-- $split
--
-- Splitting functions in this library do not perform character-wise
-- copies to create substrings; they just construct new 'Text's that
-- are slices of the original.
-- | /O(m+n)/ Break a 'Text' into pieces separated by the first 'Text'
-- argument (which cannot be empty), consuming the delimiter. An empty
-- delimiter is invalid, and will cause an error to be raised.
--
-- Examples:
--
-- > splitOn "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"]
-- > splitOn "aaa" "aaaXaaaXaaaXaaa" == ["","X","X","X",""]
-- > splitOn "x" "x" == ["",""]
--
-- and
--
-- > intercalate s . splitOn s == id
-- > splitOn (singleton c) == split (==c)
--
-- (Note: the string @s@ to split on above cannot be empty.)
--
-- In (unlikely) bad cases, this function's time complexity degrades
-- towards /O(n*m)/.
splitOn :: Text
-- ^ String to split on. If this string is empty, an error
-- will occur.
-> Text
-- ^ Input text.
-> [Text]
splitOn pat@(Text _ _ l) src@(Text arr off len)
| l <= 0 = emptyError "splitOn"
| isSingleton pat = split (== unsafeHead pat) src
| otherwise = go 0 (indices pat src)
where
go !s (x:xs) = text arr (s+off) (x-s) : go (x+l) xs
go s _ = [text arr (s+off) (len-s)]
{-# INLINE [1] splitOn #-}
{-# RULES
"TEXT splitOn/singleton -> split/==" [~1] forall c t.
splitOn (singleton c) t = split (==c) t
#-}
-- | /O(n)/ Splits a 'Text' into components delimited by separators,
-- where the predicate returns True for a separator element. The
-- resulting components do not contain the separators. Two adjacent
-- separators result in an empty component in the output. eg.
--
-- > split (=='a') "aabbaca" == ["","","bb","c",""]
-- > split (=='a') "" == [""]
split :: (Char -> Bool) -> Text -> [Text]
split _ t@(Text _off _arr 0) = [t]
split p t = loop t
where loop s | null s' = [l]
| otherwise = l : loop (unsafeTail s')
where (# l, s' #) = span_ (not . p) s
{-# INLINE split #-}
-- | /O(n)/ Splits a 'Text' into components of length @k@. The last
-- element may be shorter than the other chunks, depending on the
-- length of the input. Examples:
--
-- > chunksOf 3 "foobarbaz" == ["foo","bar","baz"]
-- > chunksOf 4 "haskell.org" == ["hask","ell.","org"]
chunksOf :: Int -> Text -> [Text]
chunksOf k = go
where
go t = case splitAt k t of
(a,b) | null a -> []
| otherwise -> a : go b
{-# INLINE chunksOf #-}
-- ----------------------------------------------------------------------------
-- * Searching
-------------------------------------------------------------------------------
-- ** Searching with a predicate
-- | /O(n)/ The 'find' function takes a predicate and a 'Text', and
-- returns the first element matching the predicate, or 'Nothing' if
-- there is no such element.
find :: (Char -> Bool) -> Text -> Maybe Char
find p t = S.findBy p (stream t)
{-# INLINE find #-}
-- | /O(n)/ The 'partition' function takes a predicate and a 'Text',
-- and returns the pair of 'Text's with elements which do and do not
-- satisfy the predicate, respectively; i.e.
--
-- > partition p t == (filter p t, filter (not . p) t)
partition :: (Char -> Bool) -> Text -> (Text, Text)
partition p t = (filter p t, filter (not . p) t)
{-# INLINE partition #-}
-- | /O(n)/ 'filter', applied to a predicate and a 'Text',
-- returns a 'Text' containing those characters that satisfy the
-- predicate.
filter :: (Char -> Bool) -> Text -> Text
filter p t = unstream (S.filter p (stream t))
{-# INLINE filter #-}
-- | /O(n+m)/ Find the first instance of @needle@ (which must be
-- non-'null') in @haystack@. The first element of the returned tuple
-- is the prefix of @haystack@ before @needle@ is matched. The second
-- is the remainder of @haystack@, starting with the match.
--
-- Examples:
--
-- > breakOn "::" "a::b::c" ==> ("a", "::b::c")
-- > breakOn "/" "foobar" ==> ("foobar", "")
--
-- Laws:
--
-- > append prefix match == haystack
-- > where (prefix, match) = breakOn needle haystack
--
-- If you need to break a string by a substring repeatedly (e.g. you
-- want to break on every instance of a substring), use 'breakOnAll'
-- instead, as it has lower startup overhead.
--
-- In (unlikely) bad cases, this function's time complexity degrades
-- towards /O(n*m)/.
breakOn :: Text -> Text -> (Text, Text)
breakOn pat src@(Text arr off len)
| null pat = emptyError "breakOn"
| otherwise = case indices pat src of
[] -> (src, empty)
(x:_) -> (text arr off x, text arr (off+x) (len-x))
{-# INLINE breakOn #-}
-- | /O(n+m)/ Similar to 'breakOn', but searches from the end of the
-- string.
--
-- The first element of the returned tuple is the prefix of @haystack@
-- up to and including the last match of @needle@. The second is the
-- remainder of @haystack@, following the match.
--
-- > breakOnEnd "::" "a::b::c" ==> ("a::b::", "c")
breakOnEnd :: Text -> Text -> (Text, Text)
breakOnEnd pat src = (reverse b, reverse a)
where (a,b) = breakOn (reverse pat) (reverse src)
{-# INLINE breakOnEnd #-}
-- | /O(n+m)/ Find all non-overlapping instances of @needle@ in
-- @haystack@. Each element of the returned list consists of a pair:
--
-- * The entire string prior to the /k/th match (i.e. the prefix)
--
-- * The /k/th match, followed by the remainder of the string
--
-- Examples:
--
-- > breakOnAll "::" ""
-- > ==> []
-- > breakOnAll "/" "a/b/c/"
-- > ==> [("a", "/b/c/"), ("a/b", "/c/"), ("a/b/c", "/")]
--
-- In (unlikely) bad cases, this function's time complexity degrades
-- towards /O(n*m)/.
--
-- The @needle@ parameter may not be empty.
breakOnAll :: Text -- ^ @needle@ to search for
-> Text -- ^ @haystack@ in which to search
-> [(Text, Text)]
breakOnAll pat src@(Text arr off slen)
| null pat = emptyError "breakOnAll"
| otherwise = L.map step (indices pat src)
where
step x = (chunk 0 x, chunk x (slen-x))
chunk !n !l = text arr (n+off) l
{-# INLINE breakOnAll #-}
-------------------------------------------------------------------------------
-- ** Indexing 'Text's
-- $index
--
-- If you think of a 'Text' value as an array of 'Char' values (which
-- it is not), you run the risk of writing inefficient code.
--
-- An idiom that is common in some languages is to find the numeric
-- offset of a character or substring, then use that number to split
-- or trim the searched string. With a 'Text' value, this approach
-- would require two /O(n)/ operations: one to perform the search, and
-- one to operate from wherever the search ended.
--
-- For example, suppose you have a string that you want to split on
-- the substring @\"::\"@, such as @\"foo::bar::quux\"@. Instead of
-- searching for the index of @\"::\"@ and taking the substrings
-- before and after that index, you would instead use @breakOnAll \"::\"@.
-- | /O(n)/ 'Text' index (subscript) operator, starting from 0.
index :: Text -> Int -> Char
index t n = S.index (stream t) n
{-# INLINE index #-}
-- | /O(n)/ The 'findIndex' function takes a predicate and a 'Text'
-- and returns the index of the first element in the 'Text' satisfying
-- the predicate. Subject to fusion.
findIndex :: (Char -> Bool) -> Text -> Maybe Int
findIndex p t = S.findIndex p (stream t)
{-# INLINE findIndex #-}
-- | /O(n+m)/ The 'count' function returns the number of times the
-- query string appears in the given 'Text'. An empty query string is
-- invalid, and will cause an error to be raised.
--
-- In (unlikely) bad cases, this function's time complexity degrades
-- towards /O(n*m)/.
count :: Text -> Text -> Int
count pat src
| null pat = emptyError "count"
| isSingleton pat = countChar (unsafeHead pat) src
| otherwise = L.length (indices pat src)
{-# INLINE [1] count #-}
{-# RULES
"TEXT count/singleton -> countChar" [~1] forall c t.
count (singleton c) t = countChar c t
#-}
-- | /O(n)/ The 'countChar' function returns the number of times the
-- query element appears in the given 'Text'. Subject to fusion.
countChar :: Char -> Text -> Int
countChar c t = S.countChar c (stream t)
{-# INLINE countChar #-}
-------------------------------------------------------------------------------
-- * Zipping
-- | /O(n)/ 'zip' takes two 'Text's and returns a list of
-- corresponding pairs of bytes. If one input 'Text' is short,
-- excess elements of the longer 'Text' are discarded. This is
-- equivalent to a pair of 'unpack' operations.
zip :: Text -> Text -> [(Char,Char)]
zip a b = S.unstreamList $ S.zipWith (,) (stream a) (stream b)
{-# INLINE zip #-}
-- | /O(n)/ 'zipWith' generalises 'zip' by zipping with the function
-- given as the first argument, instead of a tupling function.
-- Performs replacement on invalid scalar values.
zipWith :: (Char -> Char -> Char) -> Text -> Text -> Text
zipWith f t1 t2 = unstream (S.zipWith g (stream t1) (stream t2))
where g a b = safe (f a b)
{-# INLINE zipWith #-}
-- | /O(n)/ Breaks a 'Text' up into a list of words, delimited by 'Char's
-- representing white space.
words :: Text -> [Text]
words t@(Text arr off len) = loop 0 0
where
loop !start !n
| n >= len = if start == n
then []
else [Text arr (start+off) (n-start)]
| isSpace c =
if start == n
then loop (start+1) (start+1)
else Text arr (start+off) (n-start) : loop (n+d) (n+d)
| otherwise = loop start (n+d)
where Iter c d = iter t n
{-# INLINE words #-}
-- | /O(n)/ Breaks a 'Text' up into a list of 'Text's at
-- newline 'Char's. The resulting strings do not contain newlines.
lines :: Text -> [Text]
lines ps | null ps = []
| otherwise = h : if null t
then []
else lines (unsafeTail t)
where (# h,t #) = span_ (/= '\n') ps
{-# INLINE lines #-}
{-
-- | /O(n)/ Portably breaks a 'Text' up into a list of 'Text's at line
-- boundaries.
--
-- A line boundary is considered to be either a line feed, a carriage
-- return immediately followed by a line feed, or a carriage return.
-- This accounts for both Unix and Windows line ending conventions,
-- and for the old convention used on Mac OS 9 and earlier.
lines' :: Text -> [Text]
lines' ps | null ps = []
| otherwise = h : case uncons t of
Nothing -> []
Just (c,t')
| c == '\n' -> lines t'
| c == '\r' -> case uncons t' of
Just ('\n',t'') -> lines t''
_ -> lines t'
where (h,t) = span notEOL ps
notEOL c = c /= '\n' && c /= '\r'
{-# INLINE lines' #-}
-}
-- | /O(n)/ Joins lines, after appending a terminating newline to
-- each.
unlines :: [Text] -> Text
unlines = concat . L.map (`snoc` '\n')
{-# INLINE unlines #-}
-- | /O(n)/ Joins words using single space characters.
unwords :: [Text] -> Text
unwords = intercalate (singleton ' ')
{-# INLINE unwords #-}
-- | /O(n)/ The 'isPrefixOf' function takes two 'Text's and returns
-- 'True' iff the first is a prefix of the second. Subject to fusion.
isPrefixOf :: Text -> Text -> Bool
isPrefixOf a@(Text _ _ alen) b@(Text _ _ blen) =
alen <= blen && S.isPrefixOf (stream a) (stream b)
{-# INLINE [1] isPrefixOf #-}
{-# RULES
"TEXT isPrefixOf -> fused" [~1] forall s t.
isPrefixOf s t = S.isPrefixOf (stream s) (stream t)
#-}
-- | /O(n)/ The 'isSuffixOf' function takes two 'Text's and returns
-- 'True' iff the first is a suffix of the second.
isSuffixOf :: Text -> Text -> Bool
isSuffixOf a@(Text _aarr _aoff alen) b@(Text barr boff blen) =
d >= 0 && a == b'
where d = blen - alen
b' | d == 0 = b
| otherwise = Text barr (boff+d) alen
{-# INLINE isSuffixOf #-}
-- | /O(n+m)/ The 'isInfixOf' function takes two 'Text's and returns
-- 'True' iff the first is contained, wholly and intact, anywhere
-- within the second.
--
-- In (unlikely) bad cases, this function's time complexity degrades
-- towards /O(n*m)/.
isInfixOf :: Text -> Text -> Bool
isInfixOf needle haystack
| null needle = True
| isSingleton needle = S.elem (unsafeHead needle) . S.stream $ haystack
| otherwise = not . L.null . indices needle $ haystack
{-# INLINE [1] isInfixOf #-}
{-# RULES
"TEXT isInfixOf/singleton -> S.elem/S.stream" [~1] forall n h.
isInfixOf (singleton n) h = S.elem n (S.stream h)
#-}
-------------------------------------------------------------------------------
-- * View patterns
-- | /O(n)/ Return the suffix of the second string if its prefix
-- matches the entire first string.
--
-- Examples:
--
-- > stripPrefix "foo" "foobar" == Just "bar"
-- > stripPrefix "" "baz" == Just "baz"
-- > stripPrefix "foo" "quux" == Nothing
--
-- This is particularly useful with the @ViewPatterns@ extension to
-- GHC, as follows:
--
-- > {-# LANGUAGE ViewPatterns #-}
-- > import Data.Text as T
-- >
-- > fnordLength :: Text -> Int
-- > fnordLength (stripPrefix "fnord" -> Just suf) = T.length suf
-- > fnordLength _ = -1
stripPrefix :: Text -> Text -> Maybe Text
stripPrefix p@(Text _arr _off plen) t@(Text arr off len)
| p `isPrefixOf` t = Just $! text arr (off+plen) (len-plen)
| otherwise = Nothing
-- | /O(n)/ Find the longest non-empty common prefix of two strings
-- and return it, along with the suffixes of each string at which they
-- no longer match.
--
-- If the strings do not have a common prefix or either one is empty,
-- this function returns 'Nothing'.
--
-- Examples:
--
-- > commonPrefixes "foobar" "fooquux" == Just ("foo","bar","quux")
-- > commonPrefixes "veeble" "fetzer" == Nothing
-- > commonPrefixes "" "baz" == Nothing
commonPrefixes :: Text -> Text -> Maybe (Text,Text,Text)
commonPrefixes t0@(Text arr0 off0 len0) t1@(Text arr1 off1 len1) = go 0 0
where
go !i !j | i < len0 && j < len1 && a == b = go (i+d0) (j+d1)
| i > 0 = Just (Text arr0 off0 i,
text arr0 (off0+i) (len0-i),
text arr1 (off1+j) (len1-j))
| otherwise = Nothing
where Iter a d0 = iter t0 i
Iter b d1 = iter t1 j
-- | /O(n)/ Return the prefix of the second string if its suffix
-- matches the entire first string.
--
-- Examples:
--
-- > stripSuffix "bar" "foobar" == Just "foo"
-- > stripSuffix "" "baz" == Just "baz"
-- > stripSuffix "foo" "quux" == Nothing
--
-- This is particularly useful with the @ViewPatterns@ extension to
-- GHC, as follows:
--
-- > {-# LANGUAGE ViewPatterns #-}
-- > import Data.Text as T
-- >
-- > quuxLength :: Text -> Int
-- > quuxLength (stripSuffix "quux" -> Just pre) = T.length pre
-- > quuxLength _ = -1
stripSuffix :: Text -> Text -> Maybe Text
stripSuffix p@(Text _arr _off plen) t@(Text arr off len)
| p `isSuffixOf` t = Just $! text arr off (len-plen)
| otherwise = Nothing
-- | Add a list of non-negative numbers. Errors out on overflow.
sumP :: String -> [Int] -> Int
sumP fun = go 0
where go !a (x:xs)
| ax >= 0 = go ax xs
| otherwise = overflowError fun
where ax = a + x
go a _ = a
emptyError :: String -> a
emptyError fun = P.error $ "Data.Text." ++ fun ++ ": empty input"
overflowError :: String -> a
overflowError fun = P.error $ "Data.Text." ++ fun ++ ": size overflow"
-- | /O(n)/ Make a distinct copy of the given string, sharing no
-- storage with the original string.
--
-- As an example, suppose you read a large string, of which you need
-- only a small portion. If you do not use 'copy', the entire original
-- array will be kept alive in memory by the smaller string. Making a
-- copy \"breaks the link\" to the original array, allowing it to be
-- garbage collected if there are no other live references to it.
copy :: Text -> Text
copy (Text arr off len) = Text (A.run go) 0 len
where
go :: ST s (A.MArray s)
go = do
marr <- A.new len
A.copyI marr 0 arr off len
return marr
|
phischu/fragnix
|
tests/packages/scotty/Data.Text.hs
|
bsd-3-clause
| 58,643 | 0 | 18 | 14,070 | 10,453 | 5,763 | 4,690 | 783 | 3 |
{-
hlint configuration for hledger
manual: http://community.haskell.org/~ndm/darcs/hlint/hlint.htm
examples:
ignore "Eta reduce" = "" - suppress all eta reduction suggestions.
ignore "Eta reduce" = Data.List Prelude - suppress eta reduction hints in the Prelude and Data.List modules.
ignore = Data.List.map - don't give any hints in the function Data.List.map.
error = Data.List.map - any hint in the function is an error.
error "Use concatMap" = "" - the hint to use concatMap is an error.
warn "Use concatMap" = "" - the hint to use concatMap is a warning.
-}
import HLint.Default
ignore "Use camelCase" = ""
|
kmels/hledger
|
hledger/hlint.hs
|
gpl-3.0
| 705 | 0 | 5 | 189 | 15 | 8 | 7 | 2 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- Module : Network.AWS.ElastiCache.CreateCacheParameterGroup
-- Copyright : (c) 2013-2014 Brendan Hay <[email protected]>
-- License : This Source Code Form is subject to the terms of
-- the Mozilla Public License, v. 2.0.
-- A copy of the MPL can be found in the LICENSE file or
-- you can obtain it at http://mozilla.org/MPL/2.0/.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : experimental
-- Portability : non-portable (GHC extensions)
--
-- Derived from AWS service descriptions, licensed under Apache 2.0.
-- | The /CreateCacheParameterGroup/ action creates a new cache parameter group. A
-- cache parameter group is a collection of parameters that you apply to all of
-- the nodes in a cache cluster.
--
-- <http://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheParameterGroup.html>
module Network.AWS.ElastiCache.CreateCacheParameterGroup
(
-- * Request
CreateCacheParameterGroup
-- ** Request constructor
, createCacheParameterGroup
-- ** Request lenses
, ccpgCacheParameterGroupFamily
, ccpgCacheParameterGroupName
, ccpgDescription
-- * Response
, CreateCacheParameterGroupResponse
-- ** Response constructor
, createCacheParameterGroupResponse
-- ** Response lenses
, ccpgrCacheParameterGroup
) where
import Network.AWS.Prelude
import Network.AWS.Request.Query
import Network.AWS.ElastiCache.Types
import qualified GHC.Exts
data CreateCacheParameterGroup = CreateCacheParameterGroup
{ _ccpgCacheParameterGroupFamily :: Text
, _ccpgCacheParameterGroupName :: Text
, _ccpgDescription :: Text
} deriving (Eq, Ord, Read, Show)
-- | 'CreateCacheParameterGroup' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'ccpgCacheParameterGroupFamily' @::@ 'Text'
--
-- * 'ccpgCacheParameterGroupName' @::@ 'Text'
--
-- * 'ccpgDescription' @::@ 'Text'
--
createCacheParameterGroup :: Text -- ^ 'ccpgCacheParameterGroupName'
-> Text -- ^ 'ccpgCacheParameterGroupFamily'
-> Text -- ^ 'ccpgDescription'
-> CreateCacheParameterGroup
createCacheParameterGroup p1 p2 p3 = CreateCacheParameterGroup
{ _ccpgCacheParameterGroupName = p1
, _ccpgCacheParameterGroupFamily = p2
, _ccpgDescription = p3
}
-- | The name of the cache parameter group family the cache parameter group can be
-- used with.
--
-- Valid values are: 'memcached1.4' | 'redis2.6' | 'redis2.8'
ccpgCacheParameterGroupFamily :: Lens' CreateCacheParameterGroup Text
ccpgCacheParameterGroupFamily =
lens _ccpgCacheParameterGroupFamily
(\s a -> s { _ccpgCacheParameterGroupFamily = a })
-- | A user-specified name for the cache parameter group.
ccpgCacheParameterGroupName :: Lens' CreateCacheParameterGroup Text
ccpgCacheParameterGroupName =
lens _ccpgCacheParameterGroupName
(\s a -> s { _ccpgCacheParameterGroupName = a })
-- | A user-specified description for the cache parameter group.
ccpgDescription :: Lens' CreateCacheParameterGroup Text
ccpgDescription = lens _ccpgDescription (\s a -> s { _ccpgDescription = a })
newtype CreateCacheParameterGroupResponse = CreateCacheParameterGroupResponse
{ _ccpgrCacheParameterGroup :: Maybe CacheParameterGroup
} deriving (Eq, Read, Show)
-- | 'CreateCacheParameterGroupResponse' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'ccpgrCacheParameterGroup' @::@ 'Maybe' 'CacheParameterGroup'
--
createCacheParameterGroupResponse :: CreateCacheParameterGroupResponse
createCacheParameterGroupResponse = CreateCacheParameterGroupResponse
{ _ccpgrCacheParameterGroup = Nothing
}
ccpgrCacheParameterGroup :: Lens' CreateCacheParameterGroupResponse (Maybe CacheParameterGroup)
ccpgrCacheParameterGroup =
lens _ccpgrCacheParameterGroup
(\s a -> s { _ccpgrCacheParameterGroup = a })
instance ToPath CreateCacheParameterGroup where
toPath = const "/"
instance ToQuery CreateCacheParameterGroup where
toQuery CreateCacheParameterGroup{..} = mconcat
[ "CacheParameterGroupFamily" =? _ccpgCacheParameterGroupFamily
, "CacheParameterGroupName" =? _ccpgCacheParameterGroupName
, "Description" =? _ccpgDescription
]
instance ToHeaders CreateCacheParameterGroup
instance AWSRequest CreateCacheParameterGroup where
type Sv CreateCacheParameterGroup = ElastiCache
type Rs CreateCacheParameterGroup = CreateCacheParameterGroupResponse
request = post "CreateCacheParameterGroup"
response = xmlResponse
instance FromXML CreateCacheParameterGroupResponse where
parseXML = withElement "CreateCacheParameterGroupResult" $ \x -> CreateCacheParameterGroupResponse
<$> x .@? "CacheParameterGroup"
|
kim/amazonka
|
amazonka-elasticache/gen/Network/AWS/ElastiCache/CreateCacheParameterGroup.hs
|
mpl-2.0
| 5,364 | 0 | 9 | 1,063 | 560 | 342 | 218 | 73 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- Module : Network.AWS.SNS.Subscribe
-- Copyright : (c) 2013-2014 Brendan Hay <[email protected]>
-- License : This Source Code Form is subject to the terms of
-- the Mozilla Public License, v. 2.0.
-- A copy of the MPL can be found in the LICENSE file or
-- you can obtain it at http://mozilla.org/MPL/2.0/.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : experimental
-- Portability : non-portable (GHC extensions)
--
-- Derived from AWS service descriptions, licensed under Apache 2.0.
-- | Prepares to subscribe an endpoint by sending the endpoint a confirmation
-- message. To actually create a subscription, the endpoint owner must call the 'ConfirmSubscription' action with the token from the confirmation message. Confirmation tokens are
-- valid for three days.
--
-- <http://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html>
module Network.AWS.SNS.Subscribe
(
-- * Request
Subscribe
-- ** Request constructor
, subscribe
-- ** Request lenses
, sEndpoint
, sProtocol
, sTopicArn
-- * Response
, SubscribeResponse
-- ** Response constructor
, subscribeResponse
-- ** Response lenses
, srSubscriptionArn
) where
import Network.AWS.Prelude
import Network.AWS.Request.Query
import Network.AWS.SNS.Types
import qualified GHC.Exts
data Subscribe = Subscribe
{ _sEndpoint :: Maybe Text
, _sProtocol :: Text
, _sTopicArn :: Text
} deriving (Eq, Ord, Read, Show)
-- | 'Subscribe' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'sEndpoint' @::@ 'Maybe' 'Text'
--
-- * 'sProtocol' @::@ 'Text'
--
-- * 'sTopicArn' @::@ 'Text'
--
subscribe :: Text -- ^ 'sTopicArn'
-> Text -- ^ 'sProtocol'
-> Subscribe
subscribe p1 p2 = Subscribe
{ _sTopicArn = p1
, _sProtocol = p2
, _sEndpoint = Nothing
}
-- | The endpoint that you want to receive notifications. Endpoints vary by
-- protocol:
--
-- For the 'http' protocol, the endpoint is an URL beginning with "http://" For
-- the 'https' protocol, the endpoint is a URL beginning with "https://" For the 'email' protocol, the endpoint is an email address For the 'email-json' protocol, the
-- endpoint is an email address For the 'sms' protocol, the endpoint is a phone
-- number of an SMS-enabled device For the 'sqs' protocol, the endpoint is the ARN
-- of an Amazon SQS queue For the 'application' protocol, the endpoint is the
-- EndpointArn of a mobile app and device.
sEndpoint :: Lens' Subscribe (Maybe Text)
sEndpoint = lens _sEndpoint (\s a -> s { _sEndpoint = a })
-- | The protocol you want to use. Supported protocols include:
--
-- 'http' -- delivery of JSON-encoded message via HTTP POST 'https' -- delivery
-- of JSON-encoded message via HTTPS POST 'email' -- delivery of message via SMTP
-- 'email-json' -- delivery of JSON-encoded message via SMTP 'sms' -- delivery of
-- message via SMS 'sqs' -- delivery of JSON-encoded message to an Amazon SQS
-- queue 'application' -- delivery of JSON-encoded message to an EndpointArn for
-- a mobile app and device.
sProtocol :: Lens' Subscribe Text
sProtocol = lens _sProtocol (\s a -> s { _sProtocol = a })
-- | The ARN of the topic you want to subscribe to.
sTopicArn :: Lens' Subscribe Text
sTopicArn = lens _sTopicArn (\s a -> s { _sTopicArn = a })
newtype SubscribeResponse = SubscribeResponse
{ _srSubscriptionArn :: Maybe Text
} deriving (Eq, Ord, Read, Show, Monoid)
-- | 'SubscribeResponse' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'srSubscriptionArn' @::@ 'Maybe' 'Text'
--
subscribeResponse :: SubscribeResponse
subscribeResponse = SubscribeResponse
{ _srSubscriptionArn = Nothing
}
-- | The ARN of the subscription, if the service was able to create a subscription
-- immediately (without requiring endpoint owner confirmation).
srSubscriptionArn :: Lens' SubscribeResponse (Maybe Text)
srSubscriptionArn =
lens _srSubscriptionArn (\s a -> s { _srSubscriptionArn = a })
instance ToPath Subscribe where
toPath = const "/"
instance ToQuery Subscribe where
toQuery Subscribe{..} = mconcat
[ "Endpoint" =? _sEndpoint
, "Protocol" =? _sProtocol
, "TopicArn" =? _sTopicArn
]
instance ToHeaders Subscribe
instance AWSRequest Subscribe where
type Sv Subscribe = SNS
type Rs Subscribe = SubscribeResponse
request = post "Subscribe"
response = xmlResponse
instance FromXML SubscribeResponse where
parseXML = withElement "SubscribeResult" $ \x -> SubscribeResponse
<$> x .@? "SubscriptionArn"
|
romanb/amazonka
|
amazonka-sns/gen/Network/AWS/SNS/Subscribe.hs
|
mpl-2.0
| 5,137 | 0 | 9 | 1,117 | 584 | 360 | 224 | 67 | 1 |
module StoryMode.AutoUpdate where
import Control.Monad.Trans.Error
import Utils
import Base
import StoryMode.Client
import StoryMode.Purchasing
-- | auto updating of the storymode
update :: Configuration -> Application -> (Prose -> IO ()) -> ErrorT String IO ()
update config app logCommand = catchSomeExceptionsErrorT show $ do
loginData <- readLoginData
answer <- (convertErrorT (\ err -> "SERVER-ERROR:\n" ++ err) $
askForStoryModeZip (story_mode_server_portnumber config) loginData)
case answer of
(Unauthorized err) ->
throwError ("UNAUTHORIZED REQUEST:\n" ++ err)
(AuthorizedDownload zipUrl version) ->
installStoryMode app logCommand loginData version zipUrl
|
geocurnoff/nikki
|
src/StoryMode/AutoUpdate.hs
|
lgpl-3.0
| 742 | 0 | 14 | 158 | 188 | 97 | 91 | 16 | 2 |
{-|
Module : Idris.Info
Description : Get information about Idris.
Copyright : 2016 The Idris Community
License : BSD3
Maintainer : The Idris Community.
-}
module Idris.Info
( getIdrisDataDir
, getIdrisCRTSDir
, getIdrisJSRTSDir
, getIdrisLibDir
, getIdrisDocDir
, getIdrisFlagsLib
, getIdrisFlagsInc
, getIdrisFlagsEnv
, getIdrisCC
, getIdrisVersion
, getIdrisVersionNoGit
, getIdrisUserDataDir
, getIdrisInitScript
, getIdrisHistoryFile
, getIdrisInstalledPackages
, getIdrisLoggingCategories
, getIdrisDataFileByName
) where
import Idris.AbsSyntax (loggingCatsStr)
import Idris.Imports (installedPackages)
import qualified IRTS.System as S
import Paths_idris
import Version_idris (gitHash)
import Data.Version
import System.Directory
import System.FilePath
getIdrisDataDir :: IO String
getIdrisDataDir = S.getIdrisDataDir
getIdrisCRTSDir :: IO String
getIdrisCRTSDir = S.getIdrisCRTSDir
getIdrisJSRTSDir :: IO String
getIdrisJSRTSDir = S.getIdrisJSRTSDir
getIdrisDocDir :: IO String
getIdrisDocDir = S.getIdrisDocDir
getIdrisLibDir :: IO String
getIdrisLibDir = S.getIdrisLibDir
getIdrisFlagsLib :: IO [String]
getIdrisFlagsLib = S.getLibFlags
getIdrisFlagsInc :: IO [String]
getIdrisFlagsInc = S.getIncFlags
getIdrisFlagsEnv :: IO [String]
getIdrisFlagsEnv = S.getEnvFlags
getIdrisCC :: IO String
getIdrisCC = S.getCC
getIdrisVersion = showVersion S.version ++ suffix
where
suffix = if gitHash =="" then "" else "-" ++ gitHash
getIdrisVersionNoGit = S.version
-- | Get the platform-specific, user-specific Idris dir
getIdrisUserDataDir :: IO FilePath
getIdrisUserDataDir = getAppUserDataDirectory "idris"
-- | Locate the platform-specific location for the init script
getIdrisInitScript :: IO FilePath
getIdrisInitScript = do
idrisDir <- getIdrisUserDataDir
return $ idrisDir </> "repl" </> "init"
getIdrisHistoryFile :: IO FilePath
getIdrisHistoryFile = do
udir <- getIdrisUserDataDir
return (udir </> "repl" </> "history")
getIdrisInstalledPackages :: IO [String]
getIdrisInstalledPackages = installedPackages
getIdrisLoggingCategories :: IO [String]
getIdrisLoggingCategories = return $ words loggingCatsStr
getIdrisDataFileByName :: String -> IO FilePath
getIdrisDataFileByName = S.getIdrisDataFileByName
|
bravit/Idris-dev
|
src/Idris/Info.hs
|
bsd-3-clause
| 2,296 | 0 | 10 | 337 | 450 | 252 | 198 | 63 | 2 |
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE helpset PUBLIC "-//Sun Microsystems Inc.//DTD JavaHelp HelpSet Version 2.0//EN" "http://java.sun.com/products/javahelp/helpset_2_0.dtd">
<helpset version="2.0" xml:lang="zh-CN">
<title>Windows WebDrivers</title>
<maps>
<homeID>top</homeID>
<mapref location="map.jhm"/>
</maps>
<view>
<name>TOC</name>
<label>Contents</label>
<type>org.zaproxy.zap.extension.help.ZapTocView</type>
<data>toc.xml</data>
</view>
<view>
<name>Index</name>
<label>Index</label>
<type>javax.help.IndexView</type>
<data>index.xml</data>
</view>
<view>
<name>Search</name>
<label>Search</label>
<type>javax.help.SearchView</type>
<data engine="com.sun.java.help.search.DefaultSearchEngine">
JavaHelpSearch
</data>
</view>
<view>
<name>Favorites</name>
<label>Favorites</label>
<type>javax.help.FavoritesView</type>
</view>
</helpset>
|
kingthorin/zap-extensions
|
addOns/webdrivers/webdriverwindows/src/main/javahelp/org/zaproxy/zap/extension/webdriverwindows/resources/help_zh_CN/helpset_zh_CN.hs
|
apache-2.0
| 963 | 82 | 52 | 156 | 390 | 206 | 184 | -1 | -1 |
{-# LANGUAGE CPP #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternSynonyms #-}
module Lazyfoo.Lesson04 (main) where
import Prelude hiding (any, mapM_)
import Control.Monad hiding (mapM_)
import Data.Foldable
import Data.Maybe
import Data.Monoid
import Foreign.C.Types
import Linear
import qualified SDL
import Paths_sdl2 (getDataFileName)
#if !MIN_VERSION_base(4,8,0)
import Control.Applicative
#endif
screenWidth, screenHeight :: CInt
(screenWidth, screenHeight) = (640, 480)
loadBMP :: FilePath -> IO (SDL.Surface)
loadBMP path = getDataFileName path >>= SDL.loadBMP
main :: IO ()
main = do
SDL.initialize [SDL.InitVideo]
window <- SDL.createWindow "SDL Tutorial" SDL.defaultWindow { SDL.windowInitialSize = V2 screenWidth screenHeight }
SDL.showWindow window
screenSurface <- SDL.getWindowSurface window
surfaceDefault <- loadBMP "examples/lazyfoo/press.bmp"
surfaceUp <- loadBMP "examples/lazyfoo/up.bmp"
surfaceDown <- loadBMP "examples/lazyfoo/down.bmp"
surfaceLeft <- loadBMP "examples/lazyfoo/left.bmp"
surfaceRight <- loadBMP "examples/lazyfoo/right.bmp"
let
loop oldSurface = do
let collectEvents = do
e <- SDL.pollEvent
case e of
Nothing -> return []
Just e' -> (e' :) <$> collectEvents
events <- map SDL.eventPayload <$> collectEvents
let quit = any (== SDL.QuitEvent) events
currentSurface =
fromMaybe oldSurface $ getLast $
foldMap (\case SDL.KeyboardEvent e
| SDL.keyboardEventKeyMotion e == SDL.Pressed ->
case SDL.keysymKeycode (SDL.keyboardEventKeysym e) of
SDL.KeycodeUp -> Last (Just surfaceUp)
SDL.KeycodeDown -> Last (Just surfaceDown)
SDL.KeycodeRight -> Last (Just surfaceRight)
SDL.KeycodeLeft -> Last (Just surfaceLeft)
_ -> mempty
_ -> mempty)
events
SDL.surfaceBlit currentSurface Nothing screenSurface Nothing
SDL.updateWindowSurface window
unless quit (loop currentSurface)
loop surfaceDefault
mapM_ SDL.freeSurface [ surfaceDefault, surfaceUp, surfaceDown, surfaceRight, surfaceLeft ]
SDL.destroyWindow window
SDL.quit
|
dalaing/sdl2
|
examples/lazyfoo/Lesson04.hs
|
bsd-3-clause
| 2,473 | 0 | 27 | 694 | 602 | 299 | 303 | 59 | 7 |
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TemplateHaskell #-}
module Ros.Test_srvs.AddTwoIntsRequest where
import qualified Prelude as P
import Prelude ((.), (+), (*))
import qualified Data.Typeable as T
import Control.Applicative
import Ros.Internal.RosBinary
import Ros.Internal.Msg.MsgInfo
import qualified GHC.Generics as G
import qualified Data.Default.Generics as D
import Ros.Internal.Msg.SrvInfo
import qualified Data.Int as Int
import Foreign.Storable (Storable(..))
import qualified Ros.Internal.Util.StorableMonad as SM
import Lens.Family.TH (makeLenses)
import Lens.Family (view, set)
data AddTwoIntsRequest = AddTwoIntsRequest { _a :: Int.Int64
, _b :: Int.Int64
} deriving (P.Show, P.Eq, P.Ord, T.Typeable, G.Generic)
$(makeLenses ''AddTwoIntsRequest)
instance RosBinary AddTwoIntsRequest where
put obj' = put (_a obj') *> put (_b obj')
get = AddTwoIntsRequest <$> get <*> get
instance Storable AddTwoIntsRequest where
sizeOf _ = sizeOf (P.undefined::Int.Int64) +
sizeOf (P.undefined::Int.Int64)
alignment _ = 8
peek = SM.runStorable (AddTwoIntsRequest <$> SM.peek <*> SM.peek)
poke ptr' obj' = SM.runStorable store' ptr'
where store' = SM.poke (_a obj') *> SM.poke (_b obj')
instance MsgInfo AddTwoIntsRequest where
sourceMD5 _ = "36d09b846be0b371c5f190354dd3153e"
msgTypeName _ = "test_srvs/AddTwoIntsRequest"
instance D.Default AddTwoIntsRequest
instance SrvInfo AddTwoIntsRequest where
srvMD5 _ = "6a2e34150c00229791cc89ff309fff21"
srvTypeName _ = "test_srvs/AddTwoInts"
|
bitemyapp/roshask
|
Tests/test_srvs/golden/AddTwoIntsRequest.hs
|
bsd-3-clause
| 1,693 | 1 | 11 | 313 | 450 | 258 | 192 | 40 | 0 |
-- #2735
module Bug where
data S = S { s1 :: (), s2 :: () }
f s = s { s1 = (), s2 = s1 s }
|
sdiehl/ghc
|
testsuite/tests/typecheck/should_compile/T2735.hs
|
bsd-3-clause
| 94 | 0 | 9 | 33 | 57 | 34 | 23 | 3 | 1 |
import Test.HUnit (Assertion, (@=?), runTestTT, Test(..), Counts(..))
import System.Exit (ExitCode(..), exitWith)
import Grains (square, total)
exitProperly :: IO Counts -> IO ()
exitProperly m = do
counts <- m
exitWith $ if failures counts /= 0 || errors counts /= 0 then ExitFailure 1 else ExitSuccess
testCase :: String -> Assertion -> Test
testCase label assertion = TestLabel label (TestCase assertion)
main :: IO ()
main = exitProperly $ runTestTT $ TestList
[ TestList grainsTests ]
i :: Integral a => a -> Integer
i = fromIntegral
grainsTests :: [Test]
grainsTests =
[ testCase "square 1" $
1 @=? i (square 1)
, testCase "square 2" $
2 @=? i (square 2)
, testCase "square 3" $
4 @=? i (square 3)
, testCase "square 4" $
8 @=? i (square 4)
, testCase "square 16" $
32768 @=? i (square 16)
, testCase "square 32" $
2147483648 @=? i (square 32)
, testCase "square 64" $
9223372036854775808 @=? i (square 64)
, testCase "total grains" $
18446744073709551615 @=? i total
]
|
tonyfischetti/exercism
|
haskell/grains/grains_test.hs
|
mit
| 1,042 | 0 | 12 | 238 | 413 | 210 | 203 | 32 | 2 |
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TemplateHaskell #-}
-- | An implementation of restricted, linear undo, as described in:
--
-- > T. Berlage, "A selective undo mechanism for graphical user interfaces
-- > based on command objects", ACM Transactions on Computer-Human
-- > Interaction 1(3), pp. 269-294, 1994.
--
-- Implementation based on a proposal by sjw.
--
-- From Berlage:
--
-- > All buffer-mutating commands are stored (in abstract form) in an
-- > Undo list. The most recent item in this list is the action that
-- > will be undone next. When it is undone, it is removed from the Undo
-- > list, and its inverse is added to the Redo list. The last command
-- > put into the Redo list can be redone, and again prepended to the
-- > Undo list. New commands are added to the Undo list without
-- > affecting the Redo list.
--
-- Now, the above assumes that commands can be _redone_ in a state other
-- than that in which it was orginally done. This is not the case in our
-- text editor: a user may delete, for example, between an undo and a
-- redo. Berlage addresses this in S2.3. A Yi example:
--
-- > Delete some characters
-- > Undo partialy
-- > Move prior in the file, and delete another _chunk_
-- > Redo some things == corruption.
--
-- Berlage describes the /stable execution property/:
--
-- > A command is always redone in the same state that it was originally
-- > executed in, and is always undone in the state that was reached
-- > after the original execution.
--
-- > The only case where the linear undo model violates the stable
-- > execution property is when _a new command is submitted while the
-- > redo list is not empty_. The _restricted linear undo model_ ...
-- > clears the redo list in this case.
--
-- Also some discussion of this in: /The Text Editor Sam/, Rob Pike, pg 19.
--
module Yi.Buffer.Undo (
emptyU
, addChangeU
, setSavedFilePointU
, isAtSavedFilePointU
, undoU
, redoU
, URList {- abstractly -}
, Change(AtomicChange, InteractivePoint)
) where
import GHC.Generics (Generic)
import Data.Binary (Binary (..))
import Yi.Buffer.Implementation
data Change = SavedFilePoint
| InteractivePoint
| AtomicChange !Update
-- !!! It's very important that the updates are forced, otherwise
-- !!! we'll keep a full copy of the buffer state for each update
-- !!! (thunk) put in the URList.
deriving (Show, Generic)
instance Binary Change
-- | A URList consists of an undo and a redo list.
data URList = URList ![Change] ![Change]
deriving (Show, Generic)
instance Binary URList
-- | A new empty 'URList'.
-- Notice we must have a saved file point as this is when we assume we are
-- opening the file so it is currently the same as the one on disk
emptyU :: URList
emptyU = URList [SavedFilePoint] []
-- | Add an action to the undo list.
-- According to the restricted, linear undo model, if we add a command
-- whilst the redo list is not empty, we will lose our redoable changes.
addChangeU :: Change -> URList -> URList
addChangeU InteractivePoint (URList us rs) = URList (addIP us) rs
addChangeU u (URList us _rs) = URList (u:us) []
-- | Add a saved file point so that we can tell that the buffer has not
-- been modified since the previous saved file point.
-- Notice that we must be sure to remove the previous saved file points
-- since they are now worthless.
setSavedFilePointU :: URList -> URList
setSavedFilePointU (URList undos redos) =
URList (SavedFilePoint : cleanUndos) cleanRedos
where
cleanUndos = filter isNotSavedFilePoint undos
cleanRedos = filter isNotSavedFilePoint redos
isNotSavedFilePoint :: Change -> Bool
isNotSavedFilePoint SavedFilePoint = False
isNotSavedFilePoint _ = True
-- | This undoes one interaction step.
undoU :: Mark -> URList -> BufferImpl syntax -> (BufferImpl syntax, (URList, [Update]))
undoU m = undoUntilInteractive m [] . undoInteractive
-- | This redoes one iteraction step.
redoU :: Mark -> URList -> BufferImpl syntax -> (BufferImpl syntax, (URList, [Update]))
redoU = asRedo . undoU
-- | Prepare undo by moving one interaction point from undoes to redoes.
undoInteractive :: URList -> URList
undoInteractive (URList us rs) = URList (remIP us) (addIP rs)
remIP, addIP :: [Change] -> [Change]
-- | Remove an initial interactive point, if there is one
remIP (InteractivePoint:xs) = xs
remIP xs = xs
-- | Insert an initial interactive point, if there is none
addIP xs@(InteractivePoint:_) = xs
addIP xs = InteractivePoint:xs
-- | Repeatedly undo actions, storing away the inverse operations in the
-- redo list.
undoUntilInteractive :: Mark -> [Update] -> URList -> BufferImpl syntax -> (BufferImpl syntax, (URList, [Update]))
undoUntilInteractive pointMark xs ur@(URList cs rs) b = case cs of
[] -> (b, (ur, xs))
[SavedFilePoint] -> (b, (ur, xs)) -- Why this special case?
(InteractivePoint:_) -> (b, (ur, xs))
(SavedFilePoint:cs') ->
undoUntilInteractive pointMark xs (URList cs' (SavedFilePoint:rs)) b
(AtomicChange u:cs') ->
let ur' = URList cs' (AtomicChange (reverseUpdateI u):rs)
b' = applyUpdateWithMoveI u b
(b'', (ur'', xs'')) = undoUntilInteractive pointMark xs ur' b'
in (b'', (ur'', u:xs''))
where
-- Apply a /valid/ update and also move point in buffer to update position
applyUpdateWithMoveI :: Update -> BufferImpl syntax -> BufferImpl syntax
applyUpdateWithMoveI u = case updateDirection u of
Forward -> apply . move
Backward -> move . apply
where move = modifyMarkBI pointMark (\v -> v {markPoint = updatePoint u})
apply = applyUpdateI u
-- | Run the undo-function @f@ on a swapped URList making it
-- operate in a redo fashion instead of undo.
asRedo :: (URList -> t -> (t, (URList, [Update]))) -> URList -> t -> (t, (URList, [Update]))
asRedo f ur x = let (y,(ur',rs)) = f (swapUndoRedo ur) x in (y,(swapUndoRedo ur',rs))
where
swapUndoRedo :: URList -> URList
swapUndoRedo (URList us rs) = URList rs us
-- | undoIsAtSavedFilePoint. @True@ if the undo list is at a SavedFilePoint indicating
-- that the buffer has not been modified since we last saved the file.
-- Note: that an empty undo list does NOT mean that the buffer is not modified since
-- the last save. Because we may have saved the file and then undone actions done before
-- the save.
isAtSavedFilePointU :: URList -> Bool
isAtSavedFilePointU (URList us _) = isUnchanged us
where
isUnchanged cs = case cs of
[] -> False
(SavedFilePoint : _) -> True
(InteractivePoint : cs') -> isUnchanged cs'
_ -> False
|
siddhanathan/yi
|
yi-core/src/Yi/Buffer/Undo.hs
|
gpl-2.0
| 6,977 | 0 | 17 | 1,675 | 1,219 | 692 | 527 | 85 | 6 |
{-# LANGUAGE MagicHash #-}
module Main where
data T a = MkT { runT :: a, (##) :: a } deriving (Read, Show)
data T# a = MkT# { runT# :: a, (###) :: a } deriving (Read, Show)
t1, t2 :: T Int
t1 = MkT (-1) 1
t2 = read $ show t1
t1#, t2# :: T# Int
t1# = MkT# (-1) 1
t2# = read $ show t1#
main :: IO ()
main = do
print t2
print t2#
|
sdiehl/ghc
|
testsuite/tests/deriving/should_run/T14918.hs
|
bsd-3-clause
| 339 | 6 | 8 | 94 | 176 | 100 | 76 | 14 | 1 |
{-# LANGUAGE UnboxedSums, MagicHash #-}
module Main where
type Ty = (# (Int -> Int) | (Int -> Int) #)
{-# NOINLINE apply #-}
apply :: Ty -> Int
apply (# f | #) = f 0
apply (# | f #) = f 1
main :: IO ()
main = do
print (apply (# (\x -> x * 2) | #))
print (apply (# | (\x -> x * 3) #))
|
olsner/ghc
|
testsuite/tests/unboxedsums/unboxedsums10.hs
|
bsd-3-clause
| 292 | 0 | 13 | 80 | 137 | 75 | 62 | 11 | 1 |
{-
rrdgraph-haskell – Haskell DSL for rendering RRD graphs using RRDtool
Copyright © 2011 Johan Kiviniemi <[email protected]>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-}
{-# LANGUAGE TemplateHaskell, GeneralizedNewtypeDeriving #-}
module Data.RRDGraph.State
( GraphState (..)
, runGraph
, runGraphRaw
, runGraphState
, evalGraphState
, execGraphState
, newName
, addCommand
, addCommandDef
)
where
import Data.RRDGraph.Command
import Data.RRDGraph.Internal
import Control.Applicative
import Control.Monad.State
import Data.Default
import qualified Data.DList as DL
import qualified Data.Map as M
import Data.Record.Label
-- | The state monad used to build a list of RRDtool commands.
newtype GraphState a = GraphState { fromGraphState :: State GraphStateData a }
deriving ( Functor, Applicative, Monad, MonadFix
, MonadState GraphStateData )
-- | The actual state data for 'GraphState'.
data GraphStateData = GraphStateData { _gsdCounter :: Integer
, _gsdDuplMap :: M.Map Command Name
, _gsdCommands :: DL.DList Command
}
instance Default GraphStateData where
def = GraphStateData def def defDList where defDList = DL.empty
mkLabels [''GraphStateData]
-- | Run a 'GraphState' computation, returning the resulting list of RRDtool
-- commands as strings.
runGraph :: GraphState a -> [String]
runGraph = map formatCommand . runGraphRaw
-- | Run a 'GraphState' computation, returning the resulting list of 'Command'
-- structures.
runGraphRaw :: GraphState a -> [Command]
runGraphRaw = DL.toList . getL gsdCommands . execGraphState
-- | Run a 'GraphState' computation, returning the result value and the
-- resulting state.
runGraphState :: GraphState a -> (a, GraphStateData)
runGraphState = flip runState def . fromGraphState
-- | Run a 'GraphState' computation, returning the result value.
evalGraphState :: GraphState a -> a
evalGraphState = flip evalState def . fromGraphState
-- | Run a 'GraphState' computation, returning the resulting state.
execGraphState :: GraphState a -> GraphStateData
execGraphState = flip execState def . fromGraphState
-- | Generate a unique RRDtool variable name.
newName :: GraphState Name
newName = Name . ("v" ++) . show <$> getM gsdCounter <* modM gsdCounter (+1)
-- | Add a 'Command' to the resulting list of commands.
addCommand :: Command -> GraphState ()
addCommand = modM gsdCommands . flip DL.snoc
-- | Given a 'Command' that defines an RRDtool variable, look up whether it has
-- already been added. If it’s a duplicate, change nothing and result in the
-- previously allocated name. If it’s a new command, allocate a new name, add
-- the command with the name and result in the name.
addCommandDef :: Command -> GraphState Name
addCommandDef cmd_ =
case cmd_ of
DataCommand {} -> addCommandDef' cmd_
CDefCommand {} -> addCommandDef' cmd_
VDefCommand {} -> addCommandDef' cmd_
GraphCommand {} ->
error "addCommandDef only applies to commands with cmdDefines"
where
addCommandDef' :: Command -> GraphState Name
addCommandDef' cmd = do
let cmd' = setL cmdDefines (Name "") cmd
maybeName <- lookupDuplMap cmd'
case maybeName of
Just name -> return name
Nothing -> do
name <- newName
insertDuplMap cmd' name
addCommand $ setL cmdDefines name cmd'
return name
lookupDuplMap :: Command -> GraphState (Maybe Name)
lookupDuplMap name = M.lookup name <$> getM gsdDuplMap
insertDuplMap :: Command -> Name -> GraphState ()
insertDuplMap = modM gsdDuplMap .: M.insert
|
ion1/rrdgraph-haskell
|
Data/RRDGraph/State.hs
|
isc
| 4,344 | 0 | 15 | 885 | 711 | 379 | 332 | 65 | 5 |
-----------------------------------------------------------------------------
--
-- Module : Language.PureScript.CodeGen.JS.Optimizer.Inliner
-- Copyright : (c) Phil Freeman 2013-14
-- License : MIT
--
-- Maintainer : Phil Freeman <[email protected]>
-- Stability : experimental
-- Portability :
--
-- |
-- This module provides basic inlining capabilities
--
-----------------------------------------------------------------------------
module Language.PureScript.CodeGen.JS.Optimizer.Inliner (
inlineVariables,
inlineValues,
inlineOperator,
inlineCommonOperators,
inlineFnComposition,
etaConvert,
unThunk,
evaluateIifes
) where
import Prelude ()
import Prelude.Compat
import Control.Monad.Supply.Class (MonadSupply, freshName)
import Data.Maybe (fromMaybe)
import Language.PureScript.CodeGen.JS.AST
import Language.PureScript.CodeGen.JS.Common
import Language.PureScript.Names
import Language.PureScript.CodeGen.JS.Optimizer.Common
import qualified Language.PureScript.Constants as C
-- TODO: Potential bug:
-- Shouldn't just inline this case: { var x = 0; x.toFixed(10); }
-- Needs to be: { 0..toFixed(10); }
-- Probably needs to be fixed in pretty-printer instead.
shouldInline :: JS -> Bool
shouldInline (JSVar _) = True
shouldInline (JSNumericLiteral _) = True
shouldInline (JSStringLiteral _) = True
shouldInline (JSBooleanLiteral _) = True
shouldInline (JSAccessor _ val) = shouldInline val
shouldInline (JSIndexer index val) = shouldInline index && shouldInline val
shouldInline _ = False
etaConvert :: JS -> JS
etaConvert = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSBlock [JSReturn (JSApp (JSFunction Nothing idents block@(JSBlock body)) args)])
| all shouldInline args &&
not (any (`isRebound` block) (map JSVar idents)) &&
not (any (`isRebound` block) args)
= JSBlock (map (replaceIdents (zip idents args)) body)
convert (JSFunction Nothing [] (JSBlock [JSReturn (JSApp fn [])])) = fn
convert js = js
unThunk :: JS -> JS
unThunk = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSBlock []) = JSBlock []
convert (JSBlock jss) =
case last jss of
JSReturn (JSApp (JSFunction Nothing [] (JSBlock body)) []) -> JSBlock $ init jss ++ body
_ -> JSBlock jss
convert js = js
evaluateIifes :: JS -> JS
evaluateIifes = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp (JSFunction Nothing [] (JSBlock [JSReturn ret])) []) = ret
convert js = js
inlineVariables :: JS -> JS
inlineVariables = everywhereOnJS $ removeFromBlock go
where
go :: [JS] -> [JS]
go [] = []
go (JSVariableIntroduction var (Just js) : sts)
| shouldInline js && not (any (isReassigned var) sts) && not (any (isRebound js) sts) && not (any (isUpdated var) sts) =
go (map (replaceIdent var js) sts)
go (s:sts) = s : go sts
inlineValues :: JS -> JS
inlineValues = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp fn [dict]) | isDict semiringNumber dict && isFn fnZero fn = JSNumericLiteral (Left 0)
| isDict semiringNumber dict && isFn fnOne fn = JSNumericLiteral (Left 1)
| isDict semiringInt dict && isFn fnZero fn = JSNumericLiteral (Left 0)
| isDict semiringInt dict && isFn fnOne fn = JSNumericLiteral (Left 1)
| isDict boundedBoolean dict && isFn fnBottom fn = JSBooleanLiteral False
| isDict boundedBoolean dict && isFn fnTop fn = JSBooleanLiteral True
convert (JSApp (JSApp (JSApp fn [dict]) [x]) [y])
| isDict semiringInt dict && isFn fnAdd fn = JSBinary BitwiseOr (JSBinary Add x y) (JSNumericLiteral (Left 0))
| isDict semiringInt dict && isFn fnMultiply fn = JSBinary BitwiseOr (JSBinary Multiply x y) (JSNumericLiteral (Left 0))
| isDict moduloSemiringInt dict && isFn fnDivide fn = JSBinary BitwiseOr (JSBinary Divide x y) (JSNumericLiteral (Left 0))
| isDict ringInt dict && isFn fnSubtract fn = JSBinary BitwiseOr (JSBinary Subtract x y) (JSNumericLiteral (Left 0))
convert other = other
fnZero = (C.prelude, C.zero)
fnOne = (C.prelude, C.one)
fnBottom = (C.prelude, C.bottom)
fnTop = (C.prelude, C.top)
fnAdd = (C.prelude, (C.+))
fnDivide = (C.prelude, (C./))
fnMultiply = (C.prelude, (C.*))
fnSubtract = (C.prelude, (C.-))
inlineOperator :: (String, String) -> (JS -> JS -> JS) -> JS -> JS
inlineOperator (m, op) f = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp (JSApp op' [x]) [y]) | isOp op' = f x y
convert other = other
isOp (JSAccessor longForm (JSVar m')) = m == m' && longForm == identToJs (Op op)
isOp (JSIndexer (JSStringLiteral op') (JSVar m')) = m == m' && op == op'
isOp _ = False
inlineCommonOperators :: JS -> JS
inlineCommonOperators = applyAll $
[ binary semiringNumber (C.+) Add
, binary semiringNumber (C.*) Multiply
, binary ringNumber (C.-) Subtract
, unary ringNumber C.negate Negate
, binary ringInt (C.-) Subtract
, unary ringInt C.negate Negate
, binary moduloSemiringNumber (C./) Divide
, binary moduloSemiringInt C.mod Modulus
, binary eqNumber (C.==) EqualTo
, binary eqNumber (C./=) NotEqualTo
, binary eqInt (C.==) EqualTo
, binary eqInt (C./=) NotEqualTo
, binary eqString (C.==) EqualTo
, binary eqString (C./=) NotEqualTo
, binary eqBoolean (C.==) EqualTo
, binary eqBoolean (C./=) NotEqualTo
, binary ordNumber (C.<) LessThan
, binary ordNumber (C.>) GreaterThan
, binary ordNumber (C.<=) LessThanOrEqualTo
, binary ordNumber (C.>=) GreaterThanOrEqualTo
, binary ordInt (C.<) LessThan
, binary ordInt (C.>) GreaterThan
, binary ordInt (C.<=) LessThanOrEqualTo
, binary ordInt (C.>=) GreaterThanOrEqualTo
, binary semigroupString (C.<>) Add
, binary semigroupString (C.++) Add
, binary booleanAlgebraBoolean (C.&&) And
, binary booleanAlgebraBoolean (C.||) Or
, binaryFunction booleanAlgebraBoolean C.conj And
, binaryFunction booleanAlgebraBoolean C.disj Or
, unary booleanAlgebraBoolean C.not Not
, binary' C.dataIntBits (C..|.) BitwiseOr
, binary' C.dataIntBits (C..&.) BitwiseAnd
, binary' C.dataIntBits (C..^.) BitwiseXor
, binary' C.dataIntBits C.shl ShiftLeft
, binary' C.dataIntBits C.shr ShiftRight
, binary' C.dataIntBits C.zshr ZeroFillShiftRight
, unary' C.dataIntBits C.complement BitwiseNot
] ++
[ fn | i <- [0..10], fn <- [ mkFn i, runFn i ] ]
where
binary :: (String, String) -> String -> BinaryOperator -> JS -> JS
binary dict opString op = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp (JSApp (JSApp fn [dict']) [x]) [y]) | isDict dict dict' && isPreludeFn opString fn = JSBinary op x y
convert other = other
binary' :: String -> String -> BinaryOperator -> JS -> JS
binary' moduleName opString op = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp (JSApp fn [x]) [y]) | isFn (moduleName, opString) fn = JSBinary op x y
convert other = other
binaryFunction :: (String, String) -> String -> BinaryOperator -> JS -> JS
binaryFunction dict fnName op = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp (JSApp (JSApp fn [dict']) [x]) [y]) | isPreludeFn fnName fn && isDict dict dict' = JSBinary op x y
convert other = other
unary :: (String, String) -> String -> UnaryOperator -> JS -> JS
unary dict fnName op = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp (JSApp fn [dict']) [x]) | isPreludeFn fnName fn && isDict dict dict' = JSUnary op x
convert other = other
unary' :: String -> String -> UnaryOperator -> JS -> JS
unary' moduleName fnName op = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp fn [x]) | isFn (moduleName, fnName) fn = JSUnary op x
convert other = other
mkFn :: Int -> JS -> JS
mkFn 0 = everywhereOnJS convert
where
convert :: JS -> JS
convert (JSApp mkFnN [JSFunction Nothing [_] (JSBlock js)]) | isNFn C.mkFn 0 mkFnN =
JSFunction Nothing [] (JSBlock js)
convert other = other
mkFn n = everywhereOnJS convert
where
convert :: JS -> JS
convert orig@(JSApp mkFnN [fn]) | isNFn C.mkFn n mkFnN =
case collectArgs n [] fn of
Just (args, js) -> JSFunction Nothing args (JSBlock js)
Nothing -> orig
convert other = other
collectArgs :: Int -> [String] -> JS -> Maybe ([String], [JS])
collectArgs 1 acc (JSFunction Nothing [oneArg] (JSBlock js)) | length acc == n - 1 = Just (reverse (oneArg : acc), js)
collectArgs m acc (JSFunction Nothing [oneArg] (JSBlock [JSReturn ret])) = collectArgs (m - 1) (oneArg : acc) ret
collectArgs _ _ _ = Nothing
isNFn :: String -> Int -> JS -> Bool
isNFn prefix n (JSVar name) = name == (prefix ++ show n)
isNFn prefix n (JSAccessor name (JSVar dataFunction)) | dataFunction == C.dataFunction = name == (prefix ++ show n)
isNFn _ _ _ = False
runFn :: Int -> JS -> JS
runFn n = everywhereOnJS convert
where
convert :: JS -> JS
convert js = fromMaybe js $ go n [] js
go :: Int -> [JS] -> JS -> Maybe JS
go 0 acc (JSApp runFnN [fn]) | isNFn C.runFn n runFnN && length acc == n = Just (JSApp fn acc)
go m acc (JSApp lhs [arg]) = go (m - 1) (arg : acc) lhs
go _ _ _ = Nothing
-- (f <<< g $ x) = f (g x)
-- (f <<< g) = \x -> f (g x)
inlineFnComposition :: (Applicative m, MonadSupply m) => JS -> m JS
inlineFnComposition = everywhereOnJSTopDownM convert
where
convert :: (MonadSupply m) => JS -> m JS
convert (JSApp (JSApp (JSApp (JSApp fn [dict']) [x]) [y]) [z]) | isFnCompose dict' fn =
return $ JSApp x [JSApp y [z]]
convert (JSApp (JSApp (JSApp fn [dict']) [x]) [y]) | isFnCompose dict' fn = do
arg <- freshName
return $ JSFunction Nothing [arg] (JSBlock [JSReturn $ JSApp x [JSApp y [JSVar arg]]])
convert other = return other
isFnCompose :: JS -> JS -> Bool
isFnCompose dict' fn = isDict semigroupoidFn dict' && (isPreludeFn (C.<<<) fn || isPreludeFn C.compose fn)
isDict :: (String, String) -> JS -> Bool
isDict (moduleName, dictName) (JSAccessor x (JSVar y)) = x == dictName && y == moduleName
isDict _ _ = False
isFn :: (String, String) -> JS -> Bool
isFn (moduleName, fnName) (JSAccessor x (JSVar y)) = x == fnName && y == moduleName
isFn (moduleName, fnName) (JSIndexer (JSStringLiteral x) (JSVar y)) = x == fnName && y == moduleName
isFn _ _ = False
isPreludeFn :: String -> JS -> Bool
isPreludeFn fnName = isFn (C.prelude, fnName)
semiringNumber :: (String, String)
semiringNumber = (C.prelude, C.semiringNumber)
semiringInt :: (String, String)
semiringInt = (C.prelude, C.semiringInt)
ringNumber :: (String, String)
ringNumber = (C.prelude, C.ringNumber)
ringInt :: (String, String)
ringInt = (C.prelude, C.ringInt)
moduloSemiringNumber :: (String, String)
moduloSemiringNumber = (C.prelude, C.moduloSemiringNumber)
moduloSemiringInt :: (String, String)
moduloSemiringInt = (C.prelude, C.moduloSemiringInt)
eqNumber :: (String, String)
eqNumber = (C.prelude, C.eqNumber)
eqInt :: (String, String)
eqInt = (C.prelude, C.eqInt)
eqString :: (String, String)
eqString = (C.prelude, C.eqNumber)
eqBoolean :: (String, String)
eqBoolean = (C.prelude, C.eqNumber)
ordNumber :: (String, String)
ordNumber = (C.prelude, C.ordNumber)
ordInt :: (String, String)
ordInt = (C.prelude, C.ordInt)
semigroupString :: (String, String)
semigroupString = (C.prelude, C.semigroupString)
boundedBoolean :: (String, String)
boundedBoolean = (C.prelude, C.boundedBoolean)
booleanAlgebraBoolean :: (String, String)
booleanAlgebraBoolean = (C.prelude, C.booleanAlgebraBoolean)
semigroupoidFn :: (String, String)
semigroupoidFn = (C.prelude, C.semigroupoidFn)
|
michaelficarra/purescript
|
src/Language/PureScript/CodeGen/JS/Optimizer/Inliner.hs
|
mit
| 11,775 | 0 | 20 | 2,406 | 4,499 | 2,367 | 2,132 | 237 | 16 |
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE NamedFieldPuns #-}
module Graphics.Ray.Types.Shape
( Shape(..)
, SomeShape(..)
, Texture(..)
, sphere
, triangle
, plane
) where
import Control.Exception.Base (assert)
import Data.Colour (Colour)
import Data.Vec (Vec, Normalized, dot, normalize, scale, cross)
import Data.Ray (Ray(..), applyRay)
import Graphics.Ray.Types.Material (Material, simpleMaterial)
import Graphics.Ray.Types.BoundingBox (BoundingBox, fromPoints)
import Graphics.Ray.Internal ((~/=), lInf, hInf)
data Texture = Solid Colour
| Procedure (Vec -> Colour)
| Bitmap
class Shape a where
intersect :: a -> Ray -> Maybe Double
normalAt :: a -> Vec -> Normalized Vec
texture :: a -> Texture
colourAt :: a -> Vec -> Colour
colourAt = go . texture where
go (Solid c) = const c
go (Procedure f) = f
go _t = undefined
{-# INLINE colourAt #-}
material :: a -> Material
boundingBox :: a -> BoundingBox
boundingBox _ = fromPoints [lInf, hInf]
data SomeShape = forall a. Shape a => SomeShape a
instance Shape SomeShape where
intersect (SomeShape shape) = intersect shape
normalAt (SomeShape shape) = normalAt shape
texture (SomeShape shape) = texture shape
material (SomeShape shape) = material shape
boundingBox (SomeShape shape) = boundingBox shape
-- * Shapes
data Sphere = Sphere
{ sphereCenter :: !Vec
, sphereRadius :: !Double
, sphereTexture :: !Texture
}
sphere :: Texture -> Vec -> Double -> Sphere
sphere sphereTexture sphereCenter sphereRadius = Sphere { .. }
{-# INLINE sphere #-}
instance Shape Sphere where
intersect (Sphere { .. }) ray@(Ray { .. }) =
-- Sphere equation:: (C - X)^2 == r^2
-- ray equation:: (O + t*D)
-- combined and simplified:
-- t^2 * D^2 -2t * D(C-O) + (C-O)^2 - r^2== 0
-- at^2 + 2bt + c == 0
if d < 0
then Nothing
else assert (miss1 + miss2 <= 0.00001) $
case filter (> 0) [t1, t2] of
[] -> Nothing
xs -> Just $! seq miss2 (minimum xs)
where
co = sphereCenter - rayOrigin
a = rayDirection `dot` rayDirection
b = rayDirection `dot` co
rr = sphereRadius*sphereRadius
c = (co `dot` co) - rr
d = b*b - a*c
rd = sqrt d
t1 = (b - rd) / a
t2 = (b + rd) / a
v1 = applyRay ray t1 - sphereCenter
v2 = applyRay ray t2 - sphereCenter
miss1 = v1 `dot` v1 - rr
miss2 = v2 `dot` v2 - rr
normalAt (Sphere { sphereCenter }) x = normalize $ x - sphereCenter
texture = sphereTexture
material = const simpleMaterial
data Triangle = Triangle
{ triangleA :: !Vec
, triangleB :: !Vec
, triangleC :: !Vec
, triangleTexture :: Texture
-- microoptimization: precomputed constants
, triangleBox :: !BoundingBox
, triangleN :: !Vec
, triangleABxNnorm :: !Vec
, triangleACxNnorm :: !Vec
}
triangle :: Texture -> Vec -> Vec -> Vec -> Triangle
triangle triangleTexture triangleA triangleB triangleC =
Triangle { .. }
where
triangleBox = fromPoints [triangleA, triangleB, triangleC]
triangleAB = triangleB - triangleA
triangleAC = triangleC - triangleA
triangleN = normalize $ triangleAB `cross` triangleAC
triangleABxN = triangleAB `cross` triangleN
triangleACxN = triangleAC `cross` triangleN
triangleABdACxN = triangleAB `dot` triangleACxN
triangleACdABxN = triangleAC `dot` triangleABxN
triangleABxNnorm = scale (1.0 / triangleACdABxN) triangleABxN
triangleACxNnorm = scale (1.0 / triangleABdACxN) triangleACxN
instance Shape Triangle where
intersect (Triangle { .. }) (Ray { .. }) =
-- B N = AB x AC
-- -/ \
-- / -
-- / \
-- A------>C
--
-- triangle equation:: pAB + qAC + A , 0<=p, q, p+q<=1
-- ray equation :: O + t*D
-- t*D = pAB + qAC + A - O -- `dot` N
-- t = (A - O)*N / DN
-- p = (t*D - (A - O)) * ACxN / (AB*ACxN)
-- q = (t*D - (A - O)) * ABxN / (AC*ABxN)
if denom * denom ~/= 0
&& t > 0
&& (0 <= p && p <= 1)
&& (0 <= q && q <= 1)
&& (p + q <= 1)
then Just t
else Nothing
where
ao = triangleA - rayOrigin
denom = rayDirection `dot` triangleN
t = (ao `dot` triangleN) / denom
tdo = scale t rayDirection - ao
p = tdo `dot` triangleACxNnorm
q = tdo `dot` triangleABxNnorm
normalAt = const . triangleN
texture = triangleTexture
material = const simpleMaterial
boundingBox = triangleBox
data Plane = Plane
{ planeOffset :: !Vec
, planeNormal :: !(Normalized Vec)
, planeTexture :: !Texture
}
plane :: Texture -> Vec -> Normalized Vec -> Plane
plane planeTexture planeOffset planeNormal = Plane { .. }
{-# INLINE plane #-}
instance Shape Plane where
intersect (Plane { .. }) (Ray { .. }) =
-- (X - P) * N = 0 Plane
-- X = O + t * D Ray
--
-- Combined:
-- (O + t * D - P) * N = 0
-- t * D * N + (O - P) * N = 0
-- t = (P - O) * N / (D * N)
if t >= 0 && q ~/= 0
then Just t
else Nothing
where
t = p / q
p = (planeOffset - rayOrigin) `dot` planeNormal
q = rayDirection `dot` planeNormal
normalAt = const . planeNormal
texture = planeTexture
material = const simpleMaterial
|
matklad/raytracer
|
src/Graphics/Ray/Types/Shape.hs
|
mit
| 5,691 | 0 | 14 | 1,832 | 1,513 | 856 | 657 | 156 | 1 |
{-|
Module : Text.LParse.Parser
Description : Core for LParse
Copyright : (c) Marcus Völker, 2017-2018
License : MIT
Maintainer : [email protected]
This module implements LParse's core: The parser data structure, instances of the important typeclasses and functions to run the parser
-}
module Text.LParse.Parser where
import Control.DoubleContinuations
import Control.Applicative
import Control.Arrow
import qualified Control.Category as C
import Control.Monad
import Control.Monad.Fail
import Data.Either
import Data.List
-- | The Parser structure itself wraps a function from a collection of tokens (collectively of type t) to a double continuation giving
-- back a string in case of an error (the error message) and a pair (a,t) in case of a success (the parsing result and rest of the input)
data Parser r t a = Parser {pFunc :: t -> DCont r String (a,t)}
-- | via Monad/Functor laws
instance Functor (Parser r t) where
fmap = liftM
-- | via Monad/Applicative laws
instance Applicative (Parser r t) where
pure = return
f <*> a = f >>= (<$> a)
-- | an empty parser in the sense of Alternative always fails and throws nothing. Branching between parsers means trying both in a row and
-- taking the first one that succeeds
instance Alternative (Parser r t) where
empty = Parser (const $ throw "Empty Fail")
p1 <|> p2 = Parser ((<|>) <$> pFunc p1 <*> pFunc p2)
-- | returning a value means building a parser that consumes no input and just gives back the value (i.e. always succeeds)
-- the bind operator means using the parser, creating a second parser from the result (with the given function) and then parsing with that.
-- Both parsers successively consume input, i.e. @consume "a" >>= (const $ consume "b")@ will consume the string "ab"
instance Monad (Parser r t) where
return a = Parser (\s -> return (a,s))
a >>= f = Parser (pFunc a >=> (\(r, s') -> pFunc (f r) s'))
-- | Defined via Alternative
instance MonadPlus (Parser r t) where
mzero = empty
mplus = (<|>)
-- | Pattern match failure via parsing failure
instance MonadFail (Parser r t) where
fail s = Parser (const $ throw s)
-- | @MonadFix@-analogue for @Parser@, using the @DCont@ function @dfix@
pfix :: (a -> Parser (Either String (a,t)) t a) -> Parser r t a
pfix f = Parser (dfix . flip (pFunc . f . fst . fromRight undefined))
-- | The identity parser returns the input. Concatenating two parsers means using the parsing result of the first as tokens for the second
instance C.Category (Parser r) where
id = Parser (\s -> return (s,s))
(.) b a = Parser (\s -> DCont (\btr etr -> run (pFunc a s) (\(x,r) -> run (pFunc b x) (\(y,_) -> btr (y,r)) etr) etr))
-- | Lifting a function to an arrow applies the function to the input. (***) executes two parsers in parallel, giving both results as a pair
-- (but only if both succeed)
instance Arrow (Parser r) where
arr f = Parser (\s -> return (f s, undefined))
(***) p1 p2 = Parser (\(a,b) -> DCont (\btr etr -> run (pFunc p1 a) (\(a',ra) -> run (pFunc p2 b) (\(b',rb) -> btr ((a',b'),(ra,rb))) etr) etr))
-- | Runs the parser on the tokens and returns whether the parse succeeded. Results are discarded.
check :: Parser Bool t a -> t -> Bool
check p s = parse p s (const True) (const False)
-- | Runs the parser on the tokens, using two functions to run the contained continuation
parse :: Parser r t a -> t -> (a -> r) -> (String -> r) -> r
parse p s = run (pFunc p s) . (. fst)
-- | Same as @parse@, but giving back the results via @Either@
doParse :: Parser (Either String a) t a -> t -> Either String a
doParse p s = invoke (fst <$> pFunc p s)
-- | Same as @parse@, but assuming the parsing succeeds, hard failing via @undefined@ otherwise
forceParse :: Parser a t a -> t -> a
forceParse p s = parse p s id undefined
-- | Runs the parser and prints the results
debugParse :: (Show a) => Parser (IO ()) t a -> t -> IO ()
debugParse p s = debugParse' p s (putStr . (\x -> show x ++ "\n"))
-- | Runs the parser and prints the results via a custom printing function
debugParse' :: Parser (IO ()) t a -> t -> (a -> IO()) -> IO ()
debugParse' p s a = run (pFunc p s) (a . fst) (\e -> putStr ("Error: "++ e ++ "\n"))
|
MarcusVoelker/LParse
|
src/Text/LParse/Parser.hs
|
mit
| 4,233 | 0 | 20 | 868 | 1,192 | 639 | 553 | 46 | 1 |
module Core(
coreServer
, module X
) where
import Core.Context as X
import Core.Monad as X
import Core.Event as X
import Core.Message as X
import Core.State as X
import Core.Log as X
import Core.Indexed as X
import Core.CoreEvent as X
import Network.Transport
import Control.Concurrent
import Control.Monad.STM
import Control.Concurrent.STM.TQueue
import Data.Map as M
import Data.Maybe
import Data.Serialize
import Network.Protocol.Message
import qualified Data.ByteString as BS
import Control.Monad
import Control.DeepSeq
import Authentication
import qualified Data.Text as T
import qualified Data.Text.IO as T
import Data.Text (Text)
import TextShow
import Data.Monoid
-- | Main server loop. Handle connections, handshake and authentification
coreServer :: EndPoint -- ^ Local end point (this server)
-> MVar () -- ^ Flag to let main thread exit
-> TQueue (Text, NetworkMessage) -- ^ Channel to send/receive messages from simulation thread
-> TQueue Text -- ^ Channel to inform about player login
-> TQueue Text -- ^ Channel to inform about player logout (disconnect)
-> IO ()
coreServer endpoint serverDone messageBus connectChan disconnectChan = do
name2connVar <- newMVar empty
_ <- forkIO $ forever $ readMessage name2connVar
go empty empty name2connVar
where
readMessage :: MVar (Map Text Connection) -> IO ()
readMessage name2connVar = do
(name, msg) <- atomically $ readTQueue messageBus
name2conn <- readMVar name2connVar
case M.lookup name name2conn of
Nothing -> T.putStrLn $ T.unwords ["Failed to find conn with name", name]
Just conn -> void $ send conn [encode msg]
go :: Map ConnectionId (MVar (Either Connection AuthConnection)) -- ^ Carry list of authorised connections and not authorised ones
-> Map EndPointAddress [ConnectionId] -- ^ Carry info about connections for each endpoint (to close them all properly)
-> MVar (Map Text Connection) -- ^ Mapping from player name to connection
-> IO ()
go cs endPointIds name2connVar = do
-- block on awaiting input events
event <- receive endpoint
case event of
ConnectionOpened cid rel addr -> do
T.putStrLn $ T.unwords [" New connection: ID ", showt cid, ", reliability: ", T.pack $ show rel, ", address: ", T.pack $ show addr]
connMVar <- newEmptyMVar
_ <- forkIO $ do
mconn <- connect endpoint addr rel defaultConnectHints
case mconn of
Right conn -> putMVar connMVar $! Left conn
Left err -> T.putStrLn $ T.unwords ["Failed to establish connection with"
, showt cid, ":", T.pack $ show err]
go (insert cid connMVar cs)
(alter (\ids -> Just $ maybe [cid] (cid :) ids) addr endPointIds)
name2connVar
-- Got message from connection
Received cid payload -> do
_ <- forkIO $ do
-- print $ payload -- DEBUG
let mvar = cs ! cid
conn <- readMVar mvar
case conn of
-- Connection that didn't handshake
Left c -> case decode $ BS.concat payload of
Right m -> if checkHandshake m
then do
T.putStrLn $ "Got handshake message from " <> showt cid
_ <- send c [encode handshakeMsg]
void $ swapMVar mvar (Right $! AuthConnection c Nothing)
else do
print m
_ <- send c [encode $ TerminationMsg "Protocol version missmatch"]
close c
_ -> do
T.putStrLn $ "Failed to deserialize message for " <> showt cid
close c
-- Connection that did handshake
Right c -> case decode $ BS.concat payload of
Right m -> if isAuthed c
-- If authed then send message to simulation thread
then do
T.putStrLn $ T.unwords ["Putting into bus", showt (fromJust (authName c), m)] -- DEBUG
atomically $ writeTQueue messageBus (fromJust (authName c), m)
yield
-- We can only check if it is an authorization message
else case m of
LoginMsg nameStr _ -> do
T.putStrLn $ "Got login message from " <> showt cid <> " with name " <> showt nameStr
-- TODO: password check
-- Disconnect logged with that name
name2conn <- readMVar name2connVar
case M.lookup nameStr name2conn of
Just _ -> do
_ <- send (authConn c) [encode $ TerminationMsg "Logged from another client"]
close (authConn c)
_ -> do
-- Send ACK that peer is authorised
_ <- send (authConn c) [encode LoginAccepted]
-- Update connection, set to authorized (has name)
void $ swapMVar mvar (Right $! c { authName = Just nameStr })
-- Update name2conn mapping
void $ swapMVar name2connVar $! M.insert nameStr (authConn c) name2conn
-- Inform simulation thread about connection
atomically $ nameStr `deepseq` writeTQueue connectChan nameStr
yield
_ -> do
_ <- send (authConn c) [encode $ TerminationMsg "Authentication needed"]
close (authConn c)
_ -> do
T.putStrLn $ "Failed to deserialize message for " <> showt cid
close $ authConn c
return ()
go cs endPointIds name2connVar
ConnectionClosed cid -> do
T.putStrLn $ " Closed connection: ID " <> showt cid
-- Close connection
_ <- forkIO $ do
conn <- readMVar (cs ! cid)
case conn of
Left c -> close c
Right c -> close $ authConn c
-- Update mapping
let cs' = delete cid cs
endPointIds' = fmap (Prelude.filter (/=cid)) endPointIds
name2conn <- readMVar name2connVar
void $ swapMVar name2connVar =<< deleteFromNameMapping cid name2conn
go cs' endPointIds' name2connVar
EndPointClosed -> do
T.putStrLn "Echo server exiting"
putMVar serverDone ()
-- | All connections from specific endpoint are broken
ErrorEvent (TransportError (EventConnectionLost addr) _) -> do
case M.lookup addr endPointIds of
Nothing -> do
T.putStrLn $ T.unwords ["Connection with (not initialized, it is not normal)", T.pack $ show addr, "is lost!"]
go cs endPointIds name2connVar
Just ids -> do
T.putStrLn $ T.unwords ["Connection with", T.pack $ show addr, "is lost!"]
let cs' = Prelude.foldr delete cs ids
endPointIds' = delete addr endPointIds
name2conn <- readMVar name2connVar
void $ swapMVar name2connVar =<< foldM (flip deleteFromNameMapping) name2conn ids
go cs' endPointIds' name2connVar
ErrorEvent err -> do
print err
putMVar serverDone ()
ReceivedMulticast _ _ -> go cs endPointIds name2connVar
where
deleteFromNameMapping :: ConnectionId -> Map Text Connection -> IO (Map Text Connection)
deleteFromNameMapping cid n2c =
case M.lookup cid cs of
Just mvar -> do
conn <- readMVar mvar
case conn of
(Right aconn) -> case authName aconn of
Just s -> do
-- Inform simulation thread about disconnection
atomically $ s `deepseq` writeTQueue disconnectChan s
yield
-- Update mapping
return $ M.delete s n2c
Nothing -> return n2c
_ -> return n2c
Nothing -> return n2c
|
NCrashed/sinister
|
src/server/Core.hs
|
mit
| 8,323 | 0 | 41 | 3,070 | 1,988 | 969 | 1,019 | 155 | 21 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# OPTIONS_GHC -Wno-orphans #-}
module Unison.Server.Types where
-- Types common to endpoints --
import Data.Aeson
import qualified Data.ByteString.Lazy as LZ
import Data.OpenApi
( ToParamSchema (..),
ToSchema (..),
)
import qualified Data.Text.Lazy as Text
import qualified Data.Text.Lazy.Encoding as Text
import Servant.API
( FromHttpApiData (..),
Get,
Header,
Headers,
JSON,
addHeader,
)
import Unison.Codebase.Editor.DisplayObject
( DisplayObject,
)
import qualified Unison.Codebase.ShortBranchHash as SBH
import Unison.Codebase.ShortBranchHash
( ShortBranchHash (..),
)
import Unison.ConstructorType (ConstructorType)
import qualified Unison.HashQualified as HQ
import Unison.Name (Name)
import Unison.Prelude
import Unison.Server.Doc (Doc)
import qualified Unison.Server.Doc as Doc
import Unison.Server.Syntax (SyntaxText)
import Unison.ShortHash (ShortHash)
import Unison.Util.Pretty ( Width (..) )
type APIHeaders x =
Headers
'[ Header "Access-Control-Allow-Origin" String,
Header "Cache-Control" String
]
x
type APIGet c = Get '[JSON] (APIHeaders c)
type HashQualifiedName = Text
type NamespaceFQN = Text
type Size = Int
type UnisonName = Text
type UnisonHash = Text
instance ToJSON Name where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema Name
deriving via Bool instance FromHttpApiData Suffixify
deriving instance ToParamSchema Suffixify
instance FromHttpApiData ShortBranchHash where
parseUrlPiece = maybe (Left "Invalid ShortBranchHash") Right . SBH.fromText
deriving instance ToParamSchema ShortBranchHash
deriving via Int instance FromHttpApiData Width
deriving instance ToParamSchema Width
instance (ToJSON b, ToJSON a) => ToJSON (DisplayObject b a) where
toEncoding = genericToEncoding defaultOptions
deriving instance (ToSchema b, ToSchema a) => ToSchema (DisplayObject b a)
instance ToJSON ShortHash where
toEncoding = genericToEncoding defaultOptions
instance ToJSONKey ShortHash
deriving instance ToSchema ShortHash
instance ToJSON n => ToJSON (HQ.HashQualified n) where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema n => ToSchema (HQ.HashQualified n)
instance ToJSON ConstructorType where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema ConstructorType
instance ToJSON TypeDefinition where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema TypeDefinition
instance ToJSON TermDefinition where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema TermDefinition
instance ToJSON DefinitionDisplayResults where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema DefinitionDisplayResults
newtype Suffixify = Suffixify { suffixified :: Bool }
deriving (Eq, Ord, Show, Generic)
data TermDefinition = TermDefinition
{ termNames :: [HashQualifiedName]
, bestTermName :: HashQualifiedName
, defnTermTag :: Maybe TermTag
, termDefinition :: DisplayObject SyntaxText SyntaxText
, signature :: SyntaxText
, termDocs :: [(HashQualifiedName, UnisonHash, Doc)]
} deriving (Eq, Show, Generic)
data TypeDefinition = TypeDefinition
{ typeNames :: [HashQualifiedName]
, bestTypeName :: HashQualifiedName
, defnTypeTag :: Maybe TypeTag
, typeDefinition :: DisplayObject SyntaxText SyntaxText
, typeDocs :: [(HashQualifiedName, UnisonHash, Doc)]
} deriving (Eq, Show, Generic)
data DefinitionDisplayResults =
DefinitionDisplayResults
{ termDefinitions :: Map UnisonHash TermDefinition
, typeDefinitions :: Map UnisonHash TypeDefinition
, missingDefinitions :: [HashQualifiedName]
} deriving (Eq, Show, Generic)
data TermTag = Doc | Test
deriving (Eq, Ord, Show, Generic)
data TypeTag = Ability | Data
deriving (Eq, Ord, Show, Generic)
data UnisonRef
= TypeRef UnisonHash
| TermRef UnisonHash
deriving (Eq, Ord, Show, Generic)
data FoundEntry
= FoundTerm NamedTerm
| FoundType NamedType
deriving (Eq, Show, Generic)
instance ToJSON FoundEntry where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema FoundEntry
unisonRefToText :: UnisonRef -> Text
unisonRefToText = \case
TypeRef r -> r
TermRef r -> r
data NamedTerm = NamedTerm
{ termName :: HashQualifiedName
, termHash :: UnisonHash
, termType :: Maybe SyntaxText
, termTag :: Maybe TermTag
}
deriving (Eq, Generic, Show)
instance ToJSON NamedTerm where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema NamedTerm
data NamedType = NamedType
{ typeName :: HashQualifiedName
, typeHash :: UnisonHash
, typeTag :: TypeTag
}
deriving (Eq, Generic, Show)
instance ToJSON NamedType where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema NamedType
instance ToJSON TermTag where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema TermTag
instance ToJSON TypeTag where
toEncoding = genericToEncoding defaultOptions
deriving instance ToSchema TypeTag
instance ToJSON Doc where
instance ToJSON Doc.SpecialForm where
instance ToJSON Doc.Src where
instance ToJSON a => ToJSON (Doc.Ref a) where
instance ToSchema Doc where
instance ToSchema Doc.SpecialForm where
instance ToSchema Doc.Src where
instance ToSchema a => ToSchema (Doc.Ref a) where
munge :: Text -> LZ.ByteString
munge = Text.encodeUtf8 . Text.fromStrict
mungeShow :: Show s => s -> LZ.ByteString
mungeShow = mungeString . show
mungeString :: String -> LZ.ByteString
mungeString = Text.encodeUtf8 . Text.pack
defaultWidth :: Width
defaultWidth = 80
discard :: Applicative m => a -> m ()
discard = const $ pure ()
mayDefault :: Maybe Width -> Width
mayDefault = fromMaybe defaultWidth
addHeaders :: v -> APIHeaders v
addHeaders = addHeader "*" . addHeader "public"
|
unisonweb/platform
|
parser-typechecker/src/Unison/Server/Types.hs
|
mit
| 6,037 | 0 | 10 | 967 | 1,549 | 864 | 685 | -1 | -1 |
import Debug.Trace (trace)
-- Try to implement and use a `putString` function without the RW and
-- see the behaviour of calling it and calling it multiple times
-- type RW = RW
type RW = Integer
type MIO a = (RW -> (a, RW))
-- Try not to put `(show w)` in the trace and look at the order of the traces
putString :: String -> MIO ()
putString s w = (trace $ "putString " ++ s ++ (show w)) ((), w + 1)
-- Try not to put `(show w)` in the trace and look at the order of the traces
-- getString :: RW -> (String, RW)
getString :: MIO String
getString w = (trace $ "getString" ++ (show w)) ("Hello", w + 1)
-- entrypoint :: RW -> ((), RW)
entrypoint :: MIO ()
entrypoint w0 = let (a, w1) = ask "What is your name?" w0
(b, w2) = ask "How old are you?" w1
ask s wi0 = let ((), wi1) = (putString s) wi0
(r, wi2) = getString wiuntil1
in (r, wi2)
in ((), w2)
entrypoint2 :: Integer -> MIO ()
entrypoint2 n = when (n > 0) (putString "Hello2")
entrypoint3 :: Integer -> MIO ()
entrypoint3 n = untilZero n (putString "Hello3")
-- when :: Bool -> (RW -> ((), RW)) -> RW -> ((), RW)
-- when :: Bool -> MIO () -> RW -> ((), RW)
when :: Bool -> MIO () -> MIO ()
when condition action world =
if condition
then action world
else ((), world)
-- untilZero :: Integer -> (RW -> ((), RW)) -> RW -> ((), RW)
-- untilZero :: Integer -> MIO () -> RW -> ((), RW)
untilZero :: Integer -> MIO () -> MIO ()
untilZero n action w0 = when (n > 0) (untilZero (n - 1) action) w1
where (_, w1) = action w0
|
Muzietto/transformerz
|
haskell/IO_inside/gist.hs
|
mit
| 1,614 | 0 | 15 | 457 | 488 | 259 | 229 | 26 | 2 |
{-# LANGUAGE CPP #-}
module GHCJS.DOM.Internals (
#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)
module GHCJS.DOM.JSFFI.Generated.Internals
#else
#endif
) where
#if (defined(ghcjs_HOST_OS) && defined(USE_JAVASCRIPTFFI)) || !defined(USE_WEBKIT)
import GHCJS.DOM.JSFFI.Generated.Internals
#else
#endif
|
plow-technologies/ghcjs-dom
|
src/GHCJS/DOM/Internals.hs
|
mit
| 340 | 0 | 5 | 33 | 33 | 26 | 7 | 4 | 0 |
-- Using names.txt (right click and 'Save Link/Target As...'), a 46K text file containing over five-thousand first names, begin by sorting it into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.
-- For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would obtain a score of 938 × 53 = 49714.
-- What is the total of all the name scores in the file?
import System.IO
import Data.List
import Data.Char
nameScore :: String -> Int
nameScore name = sum $ map (\c -> (ord c)-64) name
calc :: [String] -> Int
calc input = do
let nameScores = map (\x -> nameScore x) $ sort input
sum $ zipWith (*) [1..] nameScores
main :: IO ()
main = do
withFile "Resources/p22.txt" ReadMode (\handle -> do
contents <- hGetContents handle
print $ calc $ lines contents)
|
daniel-beard/projecteulerhaskell
|
Problems/p22.hs
|
mit
| 997 | 0 | 14 | 215 | 189 | 97 | 92 | 14 | 1 |
{-# LANGUAGE OverloadedStrings #-}
module ResponseHeaderSpec (main, spec) where
import Data.ByteString
import qualified Network.HTTP.Types as H
import Network.Wai.Handler.Warp.ResponseHeader
import Network.Wai.Handler.Warp.Response
import Network.Wai.Handler.Warp.Header
import Network.Wai.Handler.Warp.HTTP2.HPACK
import Network.HPACK
import Network.HPACK.Token
import Test.Hspec
main :: IO ()
main = hspec spec
spec :: Spec
spec = do
describe "composeHeader" $ do
it "composes a HTTP header" $
composeHeader H.http11 H.ok200 headers `shouldReturn` composedHeader
describe "addServer" $ do
it "adds Server if not exist" $ do
let hdrs = []
rspidxhdr = indexResponseHeader hdrs
addServer "MyServer" rspidxhdr hdrs `shouldBe` [("Server","MyServer")]
it "does not add Server if exists" $ do
let hdrs = [("Server","MyServer")]
rspidxhdr = indexResponseHeader hdrs
addServer "MyServer2" rspidxhdr hdrs `shouldBe` hdrs
it "does not add Server if empty" $ do
let hdrs = []
rspidxhdr = indexResponseHeader hdrs
addServer "" rspidxhdr hdrs `shouldBe` hdrs
it "deletes Server " $ do
let hdrs = [("Server","MyServer")]
rspidxhdr = indexResponseHeader hdrs
addServer "" rspidxhdr hdrs `shouldBe` []
describe "addHeader" $ do
it "adds Server if not exist" $ do
let v = "MyServer"
hdrs = []
hdrs1 = [("Server",v)]
(thl, vt) <- toHeaderTable hdrs
(thl1, _) <- toHeaderTable hdrs1
addHeader tokenServer v vt thl `shouldBe` thl1
it "does not add Server if exists" $ do
let v = "MyServer2"
hdrs = [("Server","MyServer")]
(thl, vt) <- toHeaderTable hdrs
addHeader tokenServer v vt thl `shouldBe` thl
it "does not add Server if empty" $ do
let v = ""
hdrs = []
(thl, vt) <- toHeaderTable hdrs
addHeader tokenServer v vt thl `shouldBe` thl
it "deletes Server" $ do
let v = ""
hdrs = [("Server","MyServer")]
hdrs1 = []
(thl, vt) <- toHeaderTable hdrs
(thl1, _) <- toHeaderTable hdrs1
addHeader tokenServer v vt thl `shouldBe` thl1
it "keeps Server" $ do
let v = ""
hdrs = [("Server","MyServer"),("Content-Type","Text/HTML")]
(thl, vt) <- toHeaderTable hdrs
addHeader tokenContentType v vt thl `shouldBe` thl
headers :: H.ResponseHeaders
headers = [
("Date", "Mon, 13 Aug 2012 04:22:55 GMT")
, ("Content-Lenght", "151")
, ("Server", "Mighttpd/2.5.8")
, ("Last-Modified", "Fri, 22 Jun 2012 01:18:08 GMT")
, ("Content-Type", "text/html")
]
composedHeader :: ByteString
composedHeader = "HTTP/1.1 200 OK\r\nDate: Mon, 13 Aug 2012 04:22:55 GMT\r\nContent-Lenght: 151\r\nServer: Mighttpd/2.5.8\r\nLast-Modified: Fri, 22 Jun 2012 01:18:08 GMT\r\nContent-Type: text/html\r\n\r\n"
|
creichert/wai
|
warp/test/ResponseHeaderSpec.hs
|
mit
| 3,150 | 0 | 17 | 957 | 816 | 433 | 383 | 74 | 1 |
{- |
Module : Tarefa1 - LI1
Description : Módulo Haskell que contém as funções da Tarefa 1 do Projeto de Laboratórios de Informática I.
Copyright: Rogério Moreira <[email protected]>
Samuel Ferreira <[email protected]>
Módulo da Tarefa 1 que contém as funções relativas à verificação dos tabuleiros no âmbito do Projeto de Laboratórios de Informática I.
-}
module Main where
import Data.Char
import Data.List
import Data.String
outStr :: [String] -> String
outStr [] = "\n"
outStr t = unlines t
main = do inp <- getContents
putStr (outStr (tarefa (lines inp)))
-- | 'tarefa': função que recebe a validade do tabuleiro « e que retorna a linha do erro ou "Ok"
tarefa :: [String] -> [String]
tarefa [] = ["1"]
tarefa [a] = ["1"]
tarefa [a,b] = if isLetter(head a)then ["2"] else ["1"]
tarefa input = [linha]
where linha | testaTab tabuleiro > 0 = show (testaTab tabuleiro)
| testaPos posicao (length input -1) > 0 = show (testaPos posicao (length input - 1) )
| (testax (input!!0) (words posicao!!0) + testay tabuleiro ( words posicao!!1) )> 0 = show ((length input) - 1 )
| (validaComV (selCom input) )> 0 = show (length input)
| length input > length tabuleiro +2 = show (length input)
| otherwise = "OK"
tabuleiro = (selTab input) -- linhas respetivas ao tabuleiro
posicao = (selPos input) -- linha respetiva à posição inicial
-- |==Funções de seleção e teste do tabuleiro
-- | 'selTab': função que filtra as linhas do tabuleiro
selTab :: [String] -> [String]
selTab [] = []
selTab inp = takeWhile (notElem ' ') inp
-- | 'testaTab': função que testa a validade do tabuleiro recorrendo à função verificaTab e testarLetras
testaTab :: [String] -> Int
testaTab [] = 1
testaTab [a] = 2
testaTab (x:xs) = verificaTab (length x) 1 (x:xs)
-- | 'verificaTab': função que esta se todas as linhas do tabuleiro têm o mesmo comprimento.
verificaTab :: Int -> Int -> [String] -> Int
verificaTab tam n [] = 0
verificaTab tam n (x:xs) = if length x == tam && testarLetras x
then verificaTab tam (n+1) xs
else n
-- | 'testarLetras': função que valida se o tabuleiro tem apenas letras na sua constituição
testarLetras :: String -> Bool
testarLetras [] = True
testarLetras (x:xs) = ( ord x >= 65 && (ord x) <= 90 || ord x >= 97 && ord x <= 122 ) && testarLetras xs
-- |==Funções seleção e teste das coordenadas da posição inicial
-- | 'selPos': função que filtra a linha da posição inicial
selPos :: [String] -> String
selPos [] = []
selPos inp = inp !! (length (selTab inp))
-- | 'testaPos': função que valida se a posição inicial tem 3 comandos, e que chama as restantes funções de validação.
testaPos :: String -> Int -> Int
testaPos "" n = n
testaPos l n = if ( length (words l) == 3 && validaNum ((words l) !! 0) && validaNum ((words l) !! 1) && isAlpha (head ((words l) !! 2)) && validaCoord ((words l) !! 2) )
then 0
else n
-- | 'validaCoord': função que verifica se a terceira coordenada é uma das letras
validaCoord :: String -> Bool
validaCoord [] = True
validaCoord l | l == "O" || l == "E" || l == "S" || l == "N" = True
|otherwise = False
-- | 'validaNum': função que valida se as duas primeiras coordenadas são números
validaNum :: String -> Bool
validaNum [] = True
validaNum (h:t) = isDigit h && validaNum t
-- |==Funções que validam se a posição
-- | 'testax': valida se o comprimento de cada linha é menor do que o valor da primeira coordenada, ou seja, se a coordenada X está dentro do tabuleiro.
testax :: String -> String -> Int
testax t x = if read x <= ((length t) -1)
then 0
else 1
-- | 'testay': valida se o número total de linahs é menor do que o valor da segunda coordenada, ou seja, se a coordenada Y está dentro do tabuleiro.
testay :: [String] -> String -> Int
testay t y = if read y <= ((length t) -1)
then 0
else 1
-- |==Funções de seleção e teste dos comandos
-- | 'selCom': seleciona a linha dos comandos
selCom :: [String] -> String
selCom [] = []
selCom inp = inp !! (length (selTab inp) +1)
-- | 'validaComV': verifica se existem apenas os comandos válidos: *A=Avançar *S=Saltar *L=Luz *E=Esquerda *D=Direita
validaComV :: String -> Int
valigaComV [] = 1
validaComV x = validaCom x
where validaCom [] = 0
validaCom (h:t) |elem h "ASLED" = validaCom t
|otherwise = 1
|
rgllm/uminho
|
01/LI1/lightbot/src/TA/tarefa1.hs
|
mit
| 4,778 | 0 | 16 | 1,276 | 1,278 | 659 | 619 | 69 | 2 |
-- This is the land of the orphans, so NO WHINING
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Control.Dangerous.Extensions where
import Prelude hiding ( log )
import Control.Dangerous
import Control.Monad.Cont
import Control.Monad.Maybe
import Control.Monad.Reader
import Control.Monad.State
import Control.Monad.Writer
instance (Errorable m) => Errorable (ContT s m) where
log = lift . log
exit = lift . exit
instance (Errorable m) => Errorable (MaybeT m) where
log = lift . log
exit = lift . exit
instance (Monoid s, Errorable m) => Errorable (WriterT s m) where
log = lift . log
exit = lift . exit
instance (Errorable m) => Errorable (ReaderT s m) where
log = lift . log
exit = lift . exit
instance (Errorable m) => Errorable (StateT s m) where
log = lift . log
exit = lift . exit
|
Soares/Dangerous.hs
|
src/Control/Dangerous/Extensions.hs
|
mit
| 830 | 0 | 7 | 177 | 272 | 153 | 119 | 24 | 0 |
{- Create a list containing all integers within a given range. -}
{- Simplest solution could be 'range a y = [x..y] -}
range :: Int -> Int -> [Int]
range x y | x > y = error "x cannot be lower than y"
| x == y = [x]
| otherwise = [x] ++ range (x + 1) y
|
andrewaguiar/s99-haskell
|
p22.hs
|
mit
| 282 | 0 | 9 | 89 | 86 | 43 | 43 | 4 | 1 |
{-# LANGUAGE OverloadedStrings
, OverloadedLists #-}
module Network.NTCE.FlowRecord.Pretty (renderText, renderBS) where
import Text.PrettyPrint.Leijen.Text
import Data.Text.Encoding
import Data.Text (Text)
import qualified Data.Text as T
import Data.Text.Lazy (fromChunks, toChunks)
import Data.ByteString (ByteString)
import Network.NTCE.Types
mkDoc :: FlowRecord -> Doc
mkDoc r = entry
where expired = if fExpired r
then text "E"
else text "N"
txt = text . fromChunks . (:[])
entry = cat $ punctuate (text "|") [ expired
, txt (fProto r)
, txt (fIpA r)
, int (fPortA r)
, txt (fIpB r)
, int (fPortB r)
, int (fPkts r)
, int (fBytes r)
, cat $ punctuate (text ",") (map txt (fCat r))
]
renderText :: FlowRecord -> Text
renderText r = T.concat $ toChunks $ displayT $ renderOneLine (mkDoc r)
renderBS :: FlowRecord -> ByteString
renderBS = encodeUtf8 . renderText
|
voidlizard/ntced-tcp-proxy
|
src/Network/NTCE/FlowRecord/Pretty.hs
|
mit
| 1,275 | 0 | 15 | 546 | 335 | 184 | 151 | 29 | 2 |
import Data.Char
import Data.List
import Data.Maybe
main = do
contents <- readFile "day15input.txt"
let result = compute $ map words $ lines contents
print result
type Disk = (Int, Int)
compute :: [[String]] -> Int
compute input = findValidTime $ parse input ++ [(11, 0)]
findValidTime :: [Disk] -> Int
findValidTime disks = fromJust $ findIndex (id) $ map (validTime disks) [0..]
validTime :: [Disk] -> Int -> Bool
validTime disks time = and $ map (\i -> isReached (time + i) $ disks !! (i - 1)) [1..length disks]
where isReached rotations (numPos, pos) = (rotations + pos) `mod` numPos == 0
parse :: [[String]] -> [Disk]
parse = map (tuple . (map read . filter (\x -> not (x == "" || x == "0")) . drop 2 . map (filter isDigit)))
where tuple [a,b] = (a,b)
|
aBhallo/AoC2016
|
Day 15/day15part2.hs
|
mit
| 808 | 0 | 19 | 190 | 388 | 206 | 182 | 18 | 1 |
module Main (main, spec) where
import Prelude
import Test.Hspec.Core.Spec
import Test.Hspec.Core.Runner
import Test.Hspec.Expectations
import Test.QuickCheck
main :: IO ()
main = hspec spec
spec :: Spec
spec = do
describe "reverse" $ do
it "reverses a list" $ do
reverse [1 :: Int, 2, 3] `shouldBe` [3, 2, 1]
it "gives the original list, if applied twice" $ property $
\xs -> (reverse . reverse) xs == (xs :: [Int])
|
hspec/hspec
|
hspec-core/example/Spec.hs
|
mit
| 442 | 0 | 15 | 96 | 163 | 92 | 71 | 15 | 1 |
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE PatternGuards #-}
-- | A sqlite backend for persistent.
--
-- Note: If you prepend @WAL=off @ to your connection string, it will disable
-- the write-ahead log. This functionality is now deprecated in favour of using SqliteConnectionInfo.
module Database.Persist.Sqlite
( withSqlitePool
, withSqlitePoolInfo
, withSqliteConn
, withSqliteConnInfo
, createSqlitePool
, createSqlitePoolFromInfo
, module Database.Persist.Sql
, SqliteConf (..)
, SqliteConnectionInfo
, mkSqliteConnectionInfo
, sqlConnectionStr
, walEnabled
, fkEnabled
, runSqlite
, runSqliteInfo
, wrapConnection
, wrapConnectionInfo
, mockMigration
) where
import Database.Persist.Sql
import Database.Persist.Sql.Types.Internal (mkPersistBackend)
import qualified Database.Sqlite as Sqlite
import Control.Applicative as A
import qualified Control.Exception as E
import Control.Monad (when)
import Control.Monad.IO.Class (MonadIO (..))
import Control.Monad.Logger (NoLoggingT, runNoLoggingT, MonadLogger)
import Control.Monad.Trans.Control (control)
import Control.Monad.Trans.Control (MonadBaseControl)
import Control.Monad.Trans.Reader (ReaderT, runReaderT)
import Control.Monad.Trans.Resource (ResourceT, runResourceT)
import Control.Monad.Trans.Writer (runWriterT)
import Data.Acquire (Acquire, mkAcquire, with)
import Data.Aeson
import Data.Aeson.Types (modifyFailure)
import Data.Conduit
import qualified Data.Conduit.List as CL
import qualified Data.HashMap.Lazy as HashMap
import Data.Int (Int64)
import Data.IORef
import qualified Data.Map as Map
import Data.Monoid ((<>))
import Data.Pool (Pool)
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.IO as TIO
import Lens.Micro.TH (makeLenses)
-- | Create a pool of SQLite connections.
--
-- Note that this should not be used with the @:memory:@ connection string, as
-- the pool will regularly remove connections, destroying your database.
-- Instead, use 'withSqliteConn'.
createSqlitePool :: (MonadIO m, MonadLogger m, MonadBaseControl IO m, IsSqlBackend backend)
=> Text -> Int -> m (Pool backend)
createSqlitePool = createSqlitePoolFromInfo . conStringToInfo
-- | Create a pool of SQLite connections.
--
-- Note that this should not be used with the @:memory:@ connection string, as
-- the pool will regularly remove connections, destroying your database.
-- Instead, use 'withSqliteConn'.
--
-- @since 2.6.2
createSqlitePoolFromInfo :: (MonadIO m, MonadLogger m, MonadBaseControl IO m, IsSqlBackend backend)
=> SqliteConnectionInfo -> Int -> m (Pool backend)
createSqlitePoolFromInfo connInfo = createSqlPool $ open' connInfo
-- | Run the given action with a connection pool.
--
-- Like 'createSqlitePool', this should not be used with @:memory:@.
withSqlitePool :: (MonadBaseControl IO m, MonadIO m, MonadLogger m, IsSqlBackend backend)
=> Text
-> Int -- ^ number of connections to open
-> (Pool backend -> m a) -> m a
withSqlitePool connInfo = withSqlPool . open' $ conStringToInfo connInfo
-- | Run the given action with a connection pool.
--
-- Like 'createSqlitePool', this should not be used with @:memory:@.
--
-- @since 2.6.2
withSqlitePoolInfo :: (MonadBaseControl IO m, MonadIO m, MonadLogger m, IsSqlBackend backend)
=> SqliteConnectionInfo
-> Int -- ^ number of connections to open
-> (Pool backend -> m a) -> m a
withSqlitePoolInfo connInfo = withSqlPool $ open' connInfo
withSqliteConn :: (MonadBaseControl IO m, MonadIO m, MonadLogger m, IsSqlBackend backend)
=> Text -> (backend -> m a) -> m a
withSqliteConn = withSqliteConnInfo . conStringToInfo
-- | @since 2.6.2
withSqliteConnInfo :: (MonadBaseControl IO m, MonadIO m, MonadLogger m, IsSqlBackend backend)
=> SqliteConnectionInfo -> (backend -> m a) -> m a
withSqliteConnInfo = withSqlConn . open'
open' :: (IsSqlBackend backend) => SqliteConnectionInfo -> LogFunc -> IO backend
open' connInfo logFunc = do
conn <- Sqlite.open $ _sqlConnectionStr connInfo
wrapConnectionInfo connInfo conn logFunc `E.onException` Sqlite.close conn
-- | Wrap up a raw 'Sqlite.Connection' as a Persistent SQL 'Connection'.
--
-- @since 1.1.5
wrapConnection :: (IsSqlBackend backend) => Sqlite.Connection -> LogFunc -> IO backend
wrapConnection = wrapConnectionInfo (mkSqliteConnectionInfo "")
-- | Wrap up a raw 'Sqlite.Connection' as a Persistent SQL
-- 'Connection', allowing full control over WAL and FK constraints.
--
-- @since 2.6.2
wrapConnectionInfo :: (IsSqlBackend backend)
=> SqliteConnectionInfo
-> Sqlite.Connection
-> LogFunc
-> IO backend
wrapConnectionInfo connInfo conn logFunc = do
when (_walEnabled connInfo) $ do
-- Turn on the write-ahead log
-- https://github.com/yesodweb/persistent/issues/363
turnOnWal <- Sqlite.prepare conn "PRAGMA journal_mode=WAL;"
_ <- Sqlite.stepConn conn turnOnWal
Sqlite.reset conn turnOnWal
Sqlite.finalize turnOnWal
when (_fkEnabled connInfo) $ do
-- Turn on foreign key constraints
-- https://github.com/yesodweb/persistent/issues/646
turnOnFK <- Sqlite.prepare conn "PRAGMA foreign_keys = on;"
_ <- Sqlite.stepConn conn turnOnFK
Sqlite.reset conn turnOnFK
Sqlite.finalize turnOnFK
smap <- newIORef $ Map.empty
return . mkPersistBackend $ SqlBackend
{ connPrepare = prepare' conn
, connStmtMap = smap
, connInsertSql = insertSql'
, connUpsertSql = Nothing
, connInsertManySql = Nothing
, connClose = Sqlite.close conn
, connMigrateSql = migrate'
, connBegin = helper "BEGIN"
, connCommit = helper "COMMIT"
, connRollback = ignoreExceptions . helper "ROLLBACK"
, connEscapeName = escape
, connNoLimit = "LIMIT -1"
, connRDBMS = "sqlite"
, connLimitOffset = decorateSQLWithLimitOffset "LIMIT -1"
, connLogFunc = logFunc
, connMaxParams = Just 999
}
where
helper t getter = do
stmt <- getter t
_ <- stmtExecute stmt []
stmtReset stmt
ignoreExceptions = E.handle (\(_ :: E.SomeException) -> return ())
-- | A convenience helper which creates a new database connection and runs the
-- given block, handling @MonadResource@ and @MonadLogger@ requirements. Note
-- that all log messages are discarded.
--
-- @since 1.1.4
runSqlite :: (MonadBaseControl IO m, MonadIO m, IsSqlBackend backend)
=> Text -- ^ connection string
-> ReaderT backend (NoLoggingT (ResourceT m)) a -- ^ database action
-> m a
runSqlite connstr = runResourceT
. runNoLoggingT
. withSqliteConn connstr
. runSqlConn
-- | A convenience helper which creates a new database connection and runs the
-- given block, handling @MonadResource@ and @MonadLogger@ requirements. Note
-- that all log messages are discarded.
--
-- @since 2.6.2
runSqliteInfo :: (MonadBaseControl IO m, MonadIO m, IsSqlBackend backend)
=> SqliteConnectionInfo
-> ReaderT backend (NoLoggingT (ResourceT m)) a -- ^ database action
-> m a
runSqliteInfo conInfo = runResourceT
. runNoLoggingT
. withSqliteConnInfo conInfo
. runSqlConn
prepare' :: Sqlite.Connection -> Text -> IO Statement
prepare' conn sql = do
stmt <- Sqlite.prepare conn sql
return Statement
{ stmtFinalize = Sqlite.finalize stmt
, stmtReset = Sqlite.reset conn stmt
, stmtExecute = execute' conn stmt
, stmtQuery = withStmt' conn stmt
}
insertSql' :: EntityDef -> [PersistValue] -> InsertSqlResult
insertSql' ent vals =
case entityPrimary ent of
Just _ ->
ISRManyKeys sql vals
where sql = T.concat
[ "INSERT INTO "
, escape $ entityDB ent
, "("
, T.intercalate "," $ map (escape . fieldDB) $ entityFields ent
, ") VALUES("
, T.intercalate "," (map (const "?") $ entityFields ent)
, ")"
]
Nothing ->
ISRInsertGet ins sel
where
sel = T.concat
[ "SELECT "
, escape $ fieldDB (entityId ent)
, " FROM "
, escape $ entityDB ent
, " WHERE _ROWID_=last_insert_rowid()"
]
ins = T.concat
[ "INSERT INTO "
, escape $ entityDB ent
, if null (entityFields ent)
then " VALUES(null)"
else T.concat
[ "("
, T.intercalate "," $ map (escape . fieldDB) $ entityFields ent
, ") VALUES("
, T.intercalate "," (map (const "?") $ entityFields ent)
, ")"
]
]
execute' :: Sqlite.Connection -> Sqlite.Statement -> [PersistValue] -> IO Int64
execute' conn stmt vals = flip finally (liftIO $ Sqlite.reset conn stmt) $ do
Sqlite.bind stmt vals
_ <- Sqlite.stepConn conn stmt
Sqlite.changes conn
withStmt'
:: MonadIO m
=> Sqlite.Connection
-> Sqlite.Statement
-> [PersistValue]
-> Acquire (Source m [PersistValue])
withStmt' conn stmt vals = do
_ <- mkAcquire
(Sqlite.bind stmt vals >> return stmt)
(Sqlite.reset conn)
return pull
where
pull = do
x <- liftIO $ Sqlite.stepConn conn stmt
case x of
Sqlite.Done -> return ()
Sqlite.Row -> do
cols <- liftIO $ Sqlite.columns stmt
yield cols
pull
showSqlType :: SqlType -> Text
showSqlType SqlString = "VARCHAR"
showSqlType SqlInt32 = "INTEGER"
showSqlType SqlInt64 = "INTEGER"
showSqlType SqlReal = "REAL"
showSqlType (SqlNumeric precision scale) = T.concat [ "NUMERIC(", T.pack (show precision), ",", T.pack (show scale), ")" ]
showSqlType SqlDay = "DATE"
showSqlType SqlTime = "TIME"
showSqlType SqlDayTime = "TIMESTAMP"
showSqlType SqlBlob = "BLOB"
showSqlType SqlBool = "BOOLEAN"
showSqlType (SqlOther t) = t
migrate' :: [EntityDef]
-> (Text -> IO Statement)
-> EntityDef
-> IO (Either [Text] [(Bool, Text)])
migrate' allDefs getter val = do
let (cols, uniqs, _) = mkColumns allDefs val
let newSql = mkCreateTable False def (filter (not . safeToRemove val . cName) cols, uniqs)
stmt <- getter "SELECT sql FROM sqlite_master WHERE type='table' AND name=?"
oldSql' <- with (stmtQuery stmt [PersistText $ unDBName table]) ($$ go)
case oldSql' of
Nothing -> return $ Right [(False, newSql)]
Just oldSql -> do
if oldSql == newSql
then return $ Right []
else do
sql <- getCopyTable allDefs getter val
return $ Right sql
where
def = val
table = entityDB def
go = do
x <- CL.head
case x of
Nothing -> return Nothing
Just [PersistText y] -> return $ Just y
Just y -> error $ "Unexpected result from sqlite_master: " ++ show y
-- | Mock a migration even when the database is not present.
-- This function performs the same functionality of 'printMigration'
-- with the difference that an actual database isn't needed for it.
mockMigration :: Migration -> IO ()
mockMigration mig = do
smap <- newIORef $ Map.empty
let sqlbackend = SqlBackend
{ connPrepare = \_ -> do
return Statement
{ stmtFinalize = return ()
, stmtReset = return ()
, stmtExecute = undefined
, stmtQuery = \_ -> return $ return ()
}
, connStmtMap = smap
, connInsertSql = insertSql'
, connInsertManySql = Nothing
, connClose = undefined
, connMigrateSql = migrate'
, connBegin = helper "BEGIN"
, connCommit = helper "COMMIT"
, connRollback = ignoreExceptions . helper "ROLLBACK"
, connEscapeName = escape
, connNoLimit = "LIMIT -1"
, connRDBMS = "sqlite"
, connLimitOffset = decorateSQLWithLimitOffset "LIMIT -1"
, connLogFunc = undefined
, connUpsertSql = undefined
, connMaxParams = Just 999
}
result = runReaderT . runWriterT . runWriterT $ mig
resp <- result sqlbackend
mapM_ TIO.putStrLn $ map snd $ snd resp
where
helper t getter = do
stmt <- getter t
_ <- stmtExecute stmt []
stmtReset stmt
ignoreExceptions = E.handle (\(_ :: E.SomeException) -> return ())
-- | Check if a column name is listed as the "safe to remove" in the entity
-- list.
safeToRemove :: EntityDef -> DBName -> Bool
safeToRemove def (DBName colName)
= any (elem "SafeToRemove" . fieldAttrs)
$ filter ((== DBName colName) . fieldDB)
$ entityFields def
getCopyTable :: [EntityDef]
-> (Text -> IO Statement)
-> EntityDef
-> IO [(Bool, Text)]
getCopyTable allDefs getter def = do
stmt <- getter $ T.concat [ "PRAGMA table_info(", escape table, ")" ]
oldCols' <- with (stmtQuery stmt []) ($$ getCols)
let oldCols = map DBName $ filter (/= "id") oldCols' -- need to update for table id attribute ?
let newCols = filter (not . safeToRemove def) $ map cName cols
let common = filter (`elem` oldCols) newCols
let id_ = fieldDB (entityId def)
return [ (False, tmpSql)
, (False, copyToTemp $ id_ : common)
, (common /= filter (not . safeToRemove def) oldCols, dropOld)
, (False, newSql)
, (False, copyToFinal $ id_ : newCols)
, (False, dropTmp)
]
where
getCols = do
x <- CL.head
case x of
Nothing -> return []
Just (_:PersistText name:_) -> do
names <- getCols
return $ name : names
Just y -> error $ "Invalid result from PRAGMA table_info: " ++ show y
table = entityDB def
tableTmp = DBName $ unDBName table <> "_backup"
(cols, uniqs, _) = mkColumns allDefs def
cols' = filter (not . safeToRemove def . cName) cols
newSql = mkCreateTable False def (cols', uniqs)
tmpSql = mkCreateTable True def { entityDB = tableTmp } (cols', uniqs)
dropTmp = "DROP TABLE " <> escape tableTmp
dropOld = "DROP TABLE " <> escape table
copyToTemp common = T.concat
[ "INSERT INTO "
, escape tableTmp
, "("
, T.intercalate "," $ map escape common
, ") SELECT "
, T.intercalate "," $ map escape common
, " FROM "
, escape table
]
copyToFinal newCols = T.concat
[ "INSERT INTO "
, escape table
, " SELECT "
, T.intercalate "," $ map escape newCols
, " FROM "
, escape tableTmp
]
mkCreateTable :: Bool -> EntityDef -> ([Column], [UniqueDef]) -> Text
mkCreateTable isTemp entity (cols, uniqs) =
case entityPrimary entity of
Just pdef ->
T.concat
[ "CREATE"
, if isTemp then " TEMP" else ""
, " TABLE "
, escape $ entityDB entity
, "("
, T.drop 1 $ T.concat $ map (sqlColumn isTemp) cols
, ", PRIMARY KEY "
, "("
, T.intercalate "," $ map (escape . fieldDB) $ compositeFields pdef
, ")"
, ")"
]
Nothing -> T.concat
[ "CREATE"
, if isTemp then " TEMP" else ""
, " TABLE "
, escape $ entityDB entity
, "("
, escape $ fieldDB (entityId entity)
, " "
, showSqlType $ fieldSqlType $ entityId entity
," PRIMARY KEY"
, mayDefault $ defaultAttribute $ fieldAttrs $ entityId entity
, T.concat $ map (sqlColumn isTemp) cols
, T.concat $ map sqlUnique uniqs
, ")"
]
mayDefault :: Maybe Text -> Text
mayDefault def = case def of
Nothing -> ""
Just d -> " DEFAULT " <> d
sqlColumn :: Bool -> Column -> Text
sqlColumn noRef (Column name isNull typ def _cn _maxLen ref) = T.concat
[ ","
, escape name
, " "
, showSqlType typ
, if isNull then " NULL" else " NOT NULL"
, mayDefault def
, case ref of
Nothing -> ""
Just (table, _) -> if noRef then "" else " REFERENCES " <> escape table
]
sqlUnique :: UniqueDef -> Text
sqlUnique (UniqueDef _ cname cols _) = T.concat
[ ",CONSTRAINT "
, escape cname
, " UNIQUE ("
, T.intercalate "," $ map (escape . snd) cols
, ")"
]
escape :: DBName -> Text
escape (DBName s) =
T.concat [q, T.concatMap go s, q]
where
q = T.singleton '"'
go '"' = "\"\""
go c = T.singleton c
-- | Information required to setup a connection pool.
data SqliteConf = SqliteConf
{ sqlDatabase :: Text
, sqlPoolSize :: Int
}
| SqliteConfInfo
{ sqlConnInfo :: SqliteConnectionInfo
, sqlPoolSize :: Int
} deriving Show
instance FromJSON SqliteConf where
parseJSON v = modifyFailure ("Persistent: error loading Sqlite conf: " ++) $ flip (withObject "SqliteConf") v parser where
parser o = if HashMap.member "database" o
then SqliteConf
A.<$> o .: "database"
A.<*> o .: "poolsize"
else SqliteConfInfo
A.<$> o .: "connInfo"
A.<*> o .: "poolsize"
instance PersistConfig SqliteConf where
type PersistConfigBackend SqliteConf = SqlPersistT
type PersistConfigPool SqliteConf = ConnectionPool
createPoolConfig (SqliteConf cs size) = runNoLoggingT $ createSqlitePoolFromInfo (conStringToInfo cs) size -- FIXME
createPoolConfig (SqliteConfInfo info size) = runNoLoggingT $ createSqlitePoolFromInfo info size -- FIXME
runPool _ = runSqlPool
loadConfig = parseJSON
finally :: MonadBaseControl IO m
=> m a -- ^ computation to run first
-> m b -- ^ computation to run afterward (even if an exception was raised)
-> m a
finally a sequel = control $ \runInIO ->
E.finally (runInIO a)
(runInIO sequel)
{-# INLINABLE finally #-}
-- | Creates a SqliteConnectionInfo from a connection string, with the
-- default settings.
--
-- @since 2.6.2
mkSqliteConnectionInfo :: Text -> SqliteConnectionInfo
mkSqliteConnectionInfo fp = SqliteConnectionInfo fp True True
-- | Parses connection options from a connection string. Used only to provide deprecated API.
conStringToInfo :: Text -> SqliteConnectionInfo
conStringToInfo connStr = SqliteConnectionInfo connStr' enableWal True where
(connStr', enableWal) = case () of
()
| Just cs <- T.stripPrefix "WAL=on " connStr -> (cs, True)
| Just cs <- T.stripPrefix "WAL=off " connStr -> (cs, False)
| otherwise -> (connStr, True)
-- | Information required to connect to a sqlite database. We export
-- lenses instead of fields to avoid being limited to the current
-- implementation.
--
-- @since 2.6.2
data SqliteConnectionInfo = SqliteConnectionInfo
{ _sqlConnectionStr :: Text -- ^ connection string for the database. Use @:memory:@ for an in-memory database.
, _walEnabled :: Bool -- ^ if the write-ahead log is enabled - see https://github.com/yesodweb/persistent/issues/363.
, _fkEnabled :: Bool -- ^ if foreign-key constraints are enabled.
} deriving Show
makeLenses ''SqliteConnectionInfo
instance FromJSON SqliteConnectionInfo where
parseJSON v = modifyFailure ("Persistent: error loading SqliteConnectionInfo: " ++) $
flip (withObject "SqliteConnectionInfo") v $ \o -> SqliteConnectionInfo
<$> o .: "connectionString"
<*> o .: "walEnabled"
<*> o .: "fkEnabled"
|
psibi/persistent
|
persistent-sqlite/Database/Persist/Sqlite.hs
|
mit
| 20,820 | 0 | 21 | 6,285 | 4,950 | 2,615 | 2,335 | 435 | 5 |
{-# OPTIONS_GHC -Wall #-}
module Todo.Show (showTask, showTasks, showStatus, showDate) where
import Todo.Data
import Data.Time (formatTime)
showTasks :: [Task] -> String
showTasks = unlines . map showTask
showTask :: Task -> String
showTask t = merge [st, date, text]
where
merge = unwords . skipEmpty
skipEmpty = filter (not . null)
st = showStatus t
date = case maybeDate t of
Just d -> showDate d
_ -> ""
text = content t
showStatus :: Task -> String
showStatus t = case status t of
Todo (Just p) -> '(' : unPriority p : ")"
Done x -> "x " ++ case x of
Just d -> showDate d
_ -> ""
_ -> ""
showDate :: Date -> String
showDate = onDate formatTime
|
nadirs/todohs
|
src/lib/Todo/Show.hs
|
mit
| 720 | 0 | 12 | 195 | 269 | 140 | 129 | 24 | 4 |
{-# OPTIONS -funbox-strict-fields #-}
-- |
-- This module implements the Kind Inference algorithm, and the routines which
-- use the product of kind inference to convert haskell source types into the
-- simplified kind annotated types used by the rest of the FrontEnd.
module FrontEnd.KindInfer (
kiDecls,
KindEnv(),
hsQualTypeToSigma,
hsAsstToPred,
kiHsQualType,
kindOfClass,
kindOf,
restrictKindEnv,
hsTypeToType,
getConstructorKinds
) where
import Control.Monad.Identity
import Control.Monad.Reader
import Control.Monad.Writer
import Data.Binary
import Data.Generics(Typeable, everything, mkQ, Data)
import Data.IORef
import Data.List
import System.IO.Unsafe
import Util.Inst()
import qualified Data.Map as Map
import qualified Data.Set as Set
import qualified Data.Traversable as T
import Doc.DocLike
import Doc.PPrint
import FrontEnd.HsSyn
import FrontEnd.SrcLoc
import FrontEnd.Tc.Kind
import FrontEnd.Tc.Type
import FrontEnd.Utils
import FrontEnd.Warning
import Name.Name
import Options
import Support.FreeVars
import Support.MapBinaryInstance
import Util.ContextMonad
import Util.Gen
import Util.HasSize
import qualified FlagDump as FD
import qualified Util.Seq as Seq
data KindEnv = KindEnv {
kindEnv :: Map.Map Name Kind,
kindEnvAssocs :: Map.Map Name (Int,Int),
kindEnvClasses :: Map.Map Name [Kind]
} deriving(Typeable,Show)
{-!derive: Monoid !-}
instance Binary KindEnv where
put KindEnv { kindEnv = a, kindEnvAssocs = b, kindEnvClasses = c } =
putMap a >> putMap b >> putMap c
get = do
a <- getMap
b <- getMap
c <- getMap
return KindEnv { kindEnv = a, kindEnvAssocs = b, kindEnvClasses = c }
instance HasSize KindEnv where
size KindEnv { kindEnv = env } = size env
instance FreeVars Kind (Set.Set Kindvar) where
freeVars (KVar kindvar) = Set.singleton kindvar
freeVars (kind1 `Kfun` kind2) = freeVars kind1 `Set.union` freeVars kind2
freeVars KBase {} = mempty
instance DocLike d => PPrint d KindEnv where
pprint KindEnv { kindEnv = m, kindEnvAssocs = ev, kindEnvClasses = cs } = vcat $
[ pprint x <+> text "=>" <+> pprint y | (x,y) <- Map.toList m] ++
[ text "associated type" <+> pprint n <+> pprint ab | (n,ab) <- Map.toList ev] ++
[ text "class" <+> pprint n <+> pprint ab | (n,ab) <- Map.toList cs] ++
[empty]
--------------------------------------------------------------------------------
-- The kind inference monad
data KiWhere = InClass | InInstance | Other
deriving(Eq)
data KiEnv = KiEnv {
kiSrcLoc :: SrcLoc,
kiContext :: [String],
kiEnv :: !(IORef KindEnv),
kiWhere :: !KiWhere,
kiVarnum :: !(IORef Int)
}
newtype Ki a = Ki (ReaderT KiEnv IO a)
deriving(Monad,MonadReader KiEnv,MonadIO,Functor,MonadWarn)
instance MonadSrcLoc Ki where
getSrcLoc = asks kiSrcLoc
instance MonadSetSrcLoc Ki where
withSrcLoc sl = local (\s -> s { kiSrcLoc = sl })
restrictKindEnv :: (Name -> Bool) -> KindEnv -> KindEnv
restrictKindEnv f ke = ke { kindEnv = Map.filterWithKey (\k _ -> f k) (kindEnv ke) }
findKind :: MonadIO m => Kind -> m Kind
findKind tv@(KVar Kindvar {kvarRef = r, kvarConstraint = con }) = liftIO $ do
rt <- readIORef r
case rt of
Nothing
| con == KindStar -> writeIORef r (Just kindStar) >> return kindStar
| otherwise -> return tv
Just t -> do
t' <- findKind t
writeIORef r (Just t')
return t'
findKind tv = return tv
-- useful operations in the inference monad
runKI :: KindEnv -> Ki a -> IO a
runKI env (Ki ki) = (kienv >>= ki') where
kienv = do
env <- newIORef env
varnum <- newIORef 0
return KiEnv {
kiSrcLoc = bogusASrcLoc,
kiContext = [],
kiEnv = env,
kiVarnum = varnum,
kiWhere = Other }
ki' e = runReaderT ki e
instance ContextMonad Ki where
type ContextOf Ki = String
withContext nc x = local (\s -> s { kiContext = nc :kiContext s }) x
getEnv :: Ki KindEnv
getEnv = do asks kiEnv >>= liftIO . readIORef
unify :: Kind -> Kind -> Ki ()
unify k1 k2 = do
k1 <- flattenKind k1
k2 <- flattenKind k2
printRule $ "unify:" <+> pprint k1 <+> text "<->" <+> pprint k2
mgu k1 k2
mgu :: Kind -> Kind -> Ki ()
mgu (KBase a) (KBase b) | a == b = return ()
mgu (Kfun a b) (Kfun a' b') = do
unify a a'
unify b b'
mgu (KVar u) k = varBind u k
mgu k (KVar u) = varBind u k
mgu k1 k2 = addWarn UnificationError $
"kind unification error, attempt to unify (" ++ show k1 ++ ") with (" ++ show k2 ++ ")"
varBind :: Kindvar -> Kind -> Ki ()
varBind u k = do
k <- flattenKind k
printRule $ "varBind:" <+> pprint u <+> text ":=" <+> pprint k
if k == KVar u then return () else do
when (u `Set.member` freeVars k) $ addWarn OccursCheck $ "occurs check failed in kind inference: " ++ show u ++ " := " ++ show k
v <- liftIO $ readIORef (kvarRef u)
case v of
Just v -> fail $ "varBind unfree"
Nothing -> do
liftIO $ writeIORef (kvarRef u) (Just k)
constrain (kvarConstraint u) k
zonkConstraint :: KindConstraint -> Kindvar -> Ki ()
zonkConstraint nk mv = do
let fk = mappend nk (kvarConstraint mv)
if fk == kvarConstraint mv then return () else do
nref <- liftIO $ newIORef Nothing
let nmv = mv { kvarConstraint = fk, kvarRef = nref }
liftIO $ modifyIORef (kvarRef mv) (\Nothing -> Just $ KVar nmv)
constrain KindAny k = return ()
constrain KindStar (KBase Star) = return ()
constrain KindQuest k@KBase {} = kindCombine kindFunRet k >> return ()
constrain KindQuestQuest (KBase KQuest) = fail "cannot constrain ? to be ??"
constrain KindQuestQuest k@KBase {} = kindCombine kindArg k >> return ()
constrain KindSimple (KBase Star) = return ()
constrain KindSimple (a `Kfun` b) = do
a <- findKind a
b <- findKind b
constrain KindSimple a
constrain KindSimple b
constrain con (KVar v) = zonkConstraint con v
constrain con k = fail $ "constraining kind: " ++ show (con,k)
flattenKind :: Kind -> Ki Kind
flattenKind k = f' k where
f (a `Kfun` b) = return Kfun `ap` f' a `ap` f' b
f k = return k
f' k = findKind k >>= f
newKindVar :: KindConstraint -> Ki Kindvar
newKindVar con = do
KiEnv { kiVarnum = vr } <- ask
liftIO $ do
n <- readIORef vr
writeIORef vr $! (n + 1)
nr <- newIORef Nothing
return Kindvar { kvarUniq = n, kvarRef = nr, kvarConstraint = con }
lookupKind :: KindConstraint -> Name -> Ki Kind
lookupKind con name = do
KindEnv { kindEnv = env } <- getEnv
case Map.lookup name env of
Just k -> do
k <- f k
k <- findKind k
constrain con k
findKind k
Nothing -> do
kv <- newKindVar con
extendEnv mempty { kindEnv = Map.singleton name (KVar kv) }
return (KVar kv)
where
-- ?? and ? aren't *really* kinds
f (KBase KQuestQuest) = liftM KVar $ newKindVar KindQuestQuest
f (KBase KQuest) = liftM KVar $ newKindVar KindQuest
f k@(KBase _) = return k
f (Kfun k1 k2) = liftM2 Kfun (f k1) (f k2)
f k@(KVar _) = return k
extendEnv :: KindEnv -> Ki ()
extendEnv newEnv = do
ref <- asks kiEnv
liftIO $ modifyIORef ref (mappend newEnv) -- (\ (KindEnv env x) -> KindEnv (env `Map.union` newEnv) (nx `mappend` x))
getConstructorKinds :: KindEnv -> Map.Map Name Kind
getConstructorKinds ke = kindEnv ke -- Map.fromList [ (toName TypeConstructor x,y) | (x,y)<- Map.toList m]
--------------------------------------------------------------------------------
-- kind inference proper
-- this is what gets called from outside of this module
printRule :: String -> Ki ()
printRule s
| dump FD.KindSteps = liftIO $ putStrLn s
| otherwise = return ()
{-# NOINLINE kiDecls #-}
kiDecls :: KindEnv -> [HsDecl] -> IO KindEnv
kiDecls inputEnv classAndDataDecls = ans where
ans = do
ke <- run
return ke -- TODO (Map.fromList (concatMap kgAssocs kindGroups) `mappend` as))
run = runKI inputEnv $ withContext ("kiDecls: " ++ show (map getDeclName classAndDataDecls)) $ do
kiInitClasses classAndDataDecls
mapM_ kiDecl classAndDataDecls
getEnv >>= postProcess
postProcess ke = do
kindEnv <- T.mapM flattenKind (kindEnv ke)
kindEnvClasses <- T.mapM (mapM flattenKind) (kindEnvClasses ke)
let defs = Set.toList (freeVars (Map.elems kindEnv,Map.elems kindEnvClasses))
printRule $ "defaulting the following kinds: " ++ pprint defs
mapM_ (flip varBind kindStar) defs
kindEnv <- T.mapM flattenKind kindEnv
kindEnvClasses <- T.mapM (mapM flattenKind) kindEnvClasses
return ke { kindEnvClasses = kindEnvClasses, kindEnv = kindEnv }
kiType,kiType' :: Kind -> HsType -> Ki ()
kiType' k t = do
k <- findKind k
kiType k t
kiType k (HsTyTuple ts) = do
unify kindStar k
mapM_ (kiType' kindStar) ts
kiType k (HsTyUnboxedTuple ts) = do
unify kindUTuple k
flip mapM_ ts $ \t -> do
kt <- newKindVar KindQuestQuest
kiType (KVar kt) t
kiType k (HsTyFun a b) = do
unify kindStar k
ka <- newKindVar KindQuestQuest
kb <- newKindVar KindQuest
kiType (KVar ka) a
kiType (KVar kb) b
kiType k (HsTyApp a b) = do
kv <- newKindVar KindAny
kiType (KVar kv `Kfun` k) a
kiType' (KVar kv) b
kiType k (HsTyVar v) = do
kv <- lookupKind KindAny (toName TypeVal v)
unify k kv
kiType k (HsTyCon v) = do
kv <- lookupKind KindAny (toName TypeConstructor v)
unify k kv
kiType k HsTyAssoc = do
constrain KindSimple k
kiType _ HsTyEq {} = error "kiType.HsTyEq"
kiType k HsTyForall { hsTypeVars = vs, hsTypeType = HsQualType con t } = do
mapM_ initTyVarBind vs
mapM_ kiPred con
kiType' k t
kiType k HsTyExpKind { hsTyLType = Located _ t, hsTyKind = ek } = do
unify (hsKindToKind ek) k
kiType' k t
kiType k HsTyExists { hsTypeVars = vs, hsTypeType = HsQualType con t } = do
mapM_ initTyVarBind vs
mapM_ kiPred con
kiType' k t
initTyVarBind HsTyVarBind { hsTyVarBindName = name, hsTyVarBindKind = kk } = do
nk <- lookupKind KindSimple (toName TypeVal name)
case kk of
Nothing -> return ()
Just kk -> unify nk (hsKindToKind kk)
hsKindToKind (HsKindFn a b) = hsKindToKind a `Kfun` hsKindToKind b
hsKindToKind a | a == hsKindStar = kindStar
| a == hsKindHash = kindHash
| a == hsKindQuest = kindFunRet
| a == hsKindQuestQuest = kindArg
hsKindToKind (HsKind n) = KBase (KNamed (toName SortName n))
-- hsKindToKind (HsKind n) = toName SortName n
kiApps :: Kind -> [HsType] -> Kind -> Ki ()
kiApps ca args fk = f ca args fk where
f ca [] fk = unify ca fk
f (x `Kfun` y) (a:as) fk = do
kiType' x a
y <- findKind y
f y as fk
f (KVar var) as fk = do
x <- newKindVar KindAny
y <- newKindVar KindAny
let nv = (KVar x `Kfun` KVar y)
varBind var nv
f nv as fk
kiApps' :: Kind -> [Kind] -> Kind -> Ki ()
kiApps' ca args fk = f ca args fk where
f ca [] fk = unify ca fk
f (x `Kfun` y) (a:as) fk = do
unify a x
y <- findKind y
f y as fk
f (KVar var) as fk = do
x <- newKindVar KindAny
y <- newKindVar KindAny
let nv = (KVar x `Kfun` KVar y)
varBind var nv
f nv as fk
kiPred :: HsAsst -> Ki ()
kiPred asst@(HsAsst n ns) = do
env <- getEnv
let f k n = do
k' <- lookupKind KindAny (toName TypeVal n)
unify k k'
case Map.lookup n (kindEnvClasses env) of
Nothing -> do
addWarn (UndefinedName n) ("Incorrect number of class parameters for " ++ show asst)
-- ,fail $ "unknown class: " ++ show asst
Just ks -> do
when (length ks /= length ns) $
addWarn InvalidDecl ("Incorrect number of class parameters for " ++ show n)
zipWithM_ f ks ns
kiPred (HsAsstEq a b) = do
mv <- newKindVar KindSimple
kiType (KVar mv) a
kiType' (KVar mv) b
-- first pass over declarations adds classes to environment.
kiInitClasses :: [HsDecl] -> Ki ()
kiInitClasses ds = do mapM_ kiInitDecl ds
kiInitDecl :: HsDecl -> Ki ()
kiInitDecl d = withSrcLoc (srcLoc d) (f d) where
f HsClassDecl { .. } = do
args <- mapM (\_ -> newKindVar KindAny) (hsClassHeadArgs hsDeclClassHead)
extendEnv mempty { kindEnvClasses =
Map.singleton (hsClassHead hsDeclClassHead) (map KVar args) }
f _ = return ()
kiDecl :: HsDecl -> Ki ()
kiDecl d = withSrcLoc (srcLoc d) (f d) where
varLike HsTyVar {} = True
varLike HsTyExpKind { hsTyLType = Located _ t } = varLike t
varLike _ = False
consLike (HsTyFun a b) = varLike a && varLike b
consLike (HsTyTuple ts) = all varLike ts
consLike t = case fromHsTypeApp t of
(HsTyCon {},as) -> all varLike as
_ -> False
f HsTypeFamilyDecl { .. } = do
kc <- lookupKind KindSimple (toName TypeConstructor hsDeclName)
kiApps kc hsDeclTArgs (maybe kindStar hsKindToKind hsDeclHasKind)
f HsDataDecl { hsDeclDeclType = DeclTypeKind, .. } = kiDataKind hsDeclName hsDeclCons
f HsDataDecl {
hsDeclContext = context,
hsDeclName = tyconName,
hsDeclArgs = args,
hsDeclCons = [],
hsDeclHasKind = Just kk } = do
args <- mapM (lookupKind KindSimple . toName TypeVal) args
kc <- lookupKind KindAny (toName TypeConstructor tyconName)
kiApps' kc args (hsKindToKind kk)
mapM_ kiPred context
f HsDataDecl { hsDeclDeclType = DeclTypeNewtype, .. } = kiAlias hsDeclContext hsDeclName hsDeclArgs (head hsDeclCons)
f HsDataDecl { .. } = kiData hsDeclContext hsDeclName hsDeclArgs hsDeclCons
f HsTypeDecl { hsDeclName = name, hsDeclTArgs = args, hsDeclType = ty } = do
wh <- asks kiWhere
let theconstraint = if wh == Other then KindAny else KindSimple
kc <- lookupKind theconstraint (toName TypeConstructor name)
mv <- newKindVar theconstraint
kiApps kc args (KVar mv)
kiType' (KVar mv) ty
f (HsTypeSig _ _ (HsQualType ps t)) = do
mapM_ kiPred ps
kiType kindStar t
f (HsClassDecl _sloc HsClassHead { .. } sigsAndDefaults) = do
when (length hsClassHeadArgs /= 1) $
addWarn UnsupportedFeature "Multi-parameter type classes not supported"
unless (all varLike hsClassHeadArgs) $
addWarn InvalidDecl "Class parameters must be variables"
env <- getEnv
let ks = kindOfClass hsClassHead env
[fromHsTyVar -> Just classArg] = hsClassHeadArgs
zipWithM_ kiType' ks hsClassHeadArgs
mapM_ kiPred hsClassHeadContext
let rn = Seq.toList $ everything (Seq.<>) (mkQ Seq.empty g) newClassBodies
newClassBodies = map typeFromSig $ filter isHsTypeSig sigsAndDefaults
typeFromSig (HsTypeSig _sloc _names qualType) = qualType
g (HsTyVar n') | hsNameToOrig n' == hsNameToOrig classArg = Seq.single (toName TypeVal n')
g _ = Seq.empty
carg <- lookupKind KindSimple (toName TypeVal classArg)
mapM_ (\n -> lookupKind KindSimple n >>= unify carg ) rn
local (\e -> e { kiWhere = InClass }) $ mapM_ kiDecl sigsAndDefaults
f HsDeclDeriving { hsDeclClassHead = ch } = checkInstance ch
f HsInstDecl { hsDeclClassHead = ch } = checkInstance ch
f _ = return ()
checkInstance HsClassHead { .. } = do
unless (all consLike hsClassHeadArgs) $
addWarn InvalidDecl "Instance parameters must be of the form 'C v1 v2'"
mapM_ kiPred hsClassHeadContext
env <- getEnv
let ks = kindOfClass hsClassHead env
when (length ks /= length hsClassHeadArgs) $
addWarn InvalidDecl "Incorrect number of class parameters in instance head"
zipWithM_ kiType' ks hsClassHeadArgs
-- HsQualType contxt (HsTyApp (HsTyCon _className) (HsTyVar classArg)) = qualType
-- ans = do
-- carg <- lookupKind KindSimple (toName TypeVal classArg)
-- mapM_ kiPred contxt
-- extendEnv mempty { kindEnvAssocs = Map.fromList assocs }
-- mapM_ (\n -> lookupKind KindSimple n >>= unify carg ) rn
-- local (\e -> e { kiWhere = InClass }) $ mapM_ kiDecl sigsAndDefaults
-- numClassArgs = 1
-- newAssocs = [ (name,[ n | ~(HsTyVar n) <- names],t,names) | HsTypeDecl _sloc name names t <- sigsAndDefaults ]
-- assocs = [ (toName TypeConstructor n,(numClassArgs,length names - numClassArgs)) | (n,names,_,_) <- newAssocs ]
-- rn = Seq.toList $ everything (Seq.<>) (mkQ Seq.empty f) (newClassBodies,newAssocs)
-- newClassBodies = map typeFromSig $ filter isHsTypeSig sigsAndDefaults
-- f (HsTyVar n') | hsNameToOrig n' == hsNameToOrig classArg = Seq.single (toName TypeVal n')
-- f _ = Seq.empty
-- typeFromSig :: HsDecl -> HsQualType
-- typeFromSig (HsTypeSig _sloc _names qualType) = qualType
fromHsTypeApp t = f t [] where
f (HsTyApp a b) rs = f a (b:rs)
f t rs = (t,rs)
kiAlias context tyconName args condecl = do
args <- mapM (lookupKind KindSimple . toName TypeVal) args
kc <- lookupKind KindAny (toName TypeConstructor tyconName)
let [a] = hsConDeclArgs condecl
va <- newKindVar KindQuestQuest
kiApps' kc args (KVar va)
kiType (KVar va) (hsBangType a)
mapM_ kiPred context
kiData context tyconName args condecls = do
args <- mapM (lookupKind KindSimple . toName TypeVal) args
kc <- lookupKind KindSimple (toName TypeConstructor tyconName)
kiApps' kc args kindStar
mapM_ kiPred context
flip mapM_ (concatMap (map hsBangType . hsConDeclArgs) condecls) $ \t -> do
v <- newKindVar KindQuestQuest
kiType (KVar v) t
kiDataKind tyconName condecls = do
unless (nameType tyconName == SortName) $ fail "tycon isn't sort"
flip mapM_ condecls $ \ HsConDecl { .. } -> do
kc <- lookupKind KindAny (toName TypeConstructor hsConDeclName)
let args = [ KBase (KNamed t) | HsTyCon t <- map hsBangType hsConDeclConArg ]
kiApps' kc args (KBase (KNamed tyconName))
kiHsQualType :: KindEnv -> HsQualType -> KindEnv
kiHsQualType inputEnv qualType@(HsQualType ps t) = newState where
newState = unsafePerformIO $ runKI inputEnv $ withContext ("kiHsQualType: " ++ show qualType) $ do
kiType kindStar t
mapM_ kiPred ps
getEnv >>= postProcess
--------------------------------------------------------------------------------
kindOf :: Name -> KindEnv -> Kind
kindOf name KindEnv { kindEnv = env } = case Map.lookup name env of
-- Nothing | nameType name `elem` [TypeConstructor,TypeVal] -> kindStar
Just k -> k
_ -> error $ "kindOf: could not find kind of : " ++ show (nameType name,name)
kindOfClass :: Name -> KindEnv -> [Kind]
kindOfClass name KindEnv { kindEnvClasses = cs } = case Map.lookup name cs of
--Nothing -> Star
--Nothing -> error $ "kindOf: could not find kind of class : " ++ show (nameType name,name)
Nothing -> [] -- error $ "kindOf: could not find kind of class : " ++ show (nameType name,name)
Just k -> k
----------------------
-- Conversion of Types
----------------------
fromTyApp t = f t [] where
f (HsTyApp a b) rs = f a (b:rs)
f t rs = (t,rs)
aHsTypeToType :: KindEnv -> HsType -> Type
aHsTypeToType kt@KindEnv { kindEnvAssocs = at } t | (HsTyCon con,xs) <- fromTyApp t, let nn = toName TypeConstructor con, Just (n1,n2) <- Map.lookup nn at =
TAssoc {
typeCon = Tycon nn (kindOf nn kt),
typeClassArgs = map (aHsTypeToType kt) (take n1 xs),
typeExtraArgs = map (aHsTypeToType kt) (take n2 $ drop n1 xs)
}
aHsTypeToType kt (HsTyFun t1 t2) = aHsTypeToType kt t1 `fn` aHsTypeToType kt t2
aHsTypeToType kt HsTyExpKind { hsTyLType = Located _ t } = aHsTypeToType kt t
aHsTypeToType kt tuple@(HsTyTuple types) = tTTuple $ map (aHsTypeToType kt) types
aHsTypeToType kt tuple@(HsTyUnboxedTuple types) = tTTuple' $ map (aHsTypeToType kt) types
aHsTypeToType kt (HsTyApp t1 t2) = tAp (aHsTypeToType kt t1) (aHsTypeToType kt t2)
-- variables, we must know the kind of the variable here!
-- they are assumed to already exist in the kindInfoTable
-- which was generated by the process of KindInference
aHsTypeToType kt (HsTyVar name) = TVar $ toTyvar kt name -- tyvar name (kindOf name kt) Nothing
-- type constructors, we must know the kind of the constructor.
-- here we also qualify the type constructor if it is
-- currently unqualified
aHsTypeToType kt (HsTyCon name) = TCon $ Tycon nn (kindOf nn kt) where
nn = (toName TypeConstructor name)
aHsTypeToType kt (HsTyForall vs qt) = TForAll (map (toTyvar kt . hsTyVarBindName) vs) (aHsQualTypeToQualType kt qt)
aHsTypeToType kt (HsTyExists vs qt) = TExists (map (toTyvar kt . hsTyVarBindName) vs) (aHsQualTypeToQualType kt qt)
aHsTypeToType _ t = error $ "aHsTypeToType: " ++ show t
toTyvar kt name = tyvar nn (kindOf nn kt) where
nn = toName TypeVal name
aHsQualTypeToQualType :: KindEnv -> HsQualType -> Qual Type
aHsQualTypeToQualType kt (HsQualType cntxt t) = map (hsAsstToPred kt) cntxt :=> aHsTypeToType kt t
hsAsstToPred :: KindEnv -> HsAsst -> Pred
hsAsstToPred kt (HsAsst className [varName])
-- = IsIn className (TVar $ Tyvar varName (kindOf varName kt))
| isConstructorLike varName = IsIn (toName ClassName className) (TCon (Tycon (toName TypeConstructor varName) (head $ kindOfClass (toName ClassName className) kt)))
| otherwise = IsIn (toName ClassName className) (TVar $ tyvar (toName TypeVal varName) (head $ kindOfClass (toName ClassName className) kt))
hsAsstToPred kt (HsAsstEq t1 t2) = IsEq (runIdentity $ hsTypeToType' kt t1) (runIdentity $ hsTypeToType' kt t2)
hsQualTypeToSigma kt qualType = hsQualTypeToType kt (Just []) qualType
hsTypeToType :: Monad m => KindEnv -> HsType -> m Type
hsTypeToType kt t = return $ unsafePerformIO $ runKI kt $
do kv <- newKindVar KindAny
kiType (KVar kv) t
kt' <- postProcess =<< getEnv
hsTypeToType' kt' t
hsTypeToType' :: Monad m => KindEnv -> HsType -> m Type
hsTypeToType' kt t = return $ hoistType $ aHsTypeToType kt t -- (forallHoist t)
hsQualTypeToType :: Monad m =>
KindEnv -- ^ the kind environment
-> Maybe [HsName] -- ^ universally quantify free variables excepting those in list.
-> HsQualType -- ^ the type to convert
-> m Sigma
hsQualTypeToType kindEnv qs qualType = return $ hoistType $ tForAll quantOver ( ps' :=> t') where
newEnv = kiHsQualType kindEnv qualType
--newEnv = kindEnv
Just t' = hsTypeToType' newEnv (hsQualTypeType qualType)
ps = hsQualTypeContext qualType
ps' = map (hsAsstToPred newEnv) ps
quantOver = nub $ freeVars ps' ++ fvs
fvs = case qs of
Nothing -> []
Just xs -> [ v | v <- freeVars t', nameName (tyvarName v) `notElem` xs]
hoistType :: Type -> Type
hoistType t = f t where
f t@TVar {} = t
f t@TCon {} = t
f t@TMetaVar {} = t
f t@TAssoc {} = t { typeClassArgs = map f (typeClassArgs t), typeExtraArgs = map f (typeExtraArgs t) }
f (TAp a b) = TAp (f a) (f b)
f (TForAll vs (ps :=> (f -> nt)))
| (TForAll vs' (ps' :=> t')) <- nt = f $ TForAll (vs ++ vs') ((ps ++ ps') :=> t')
| otherwise = TForAll vs (ps :=> nt)
f (TExists vs (ps :=> (f -> nt)))
| (TExists vs' (ps' :=> t')) <- nt = f $ TExists (vs ++ vs') ((ps ++ ps') :=> t')
| otherwise = TExists vs (ps :=> nt)
f (TArrow (f -> na) (f -> nb))
| TForAll vs (ps :=> t) <- nb = f $ TForAll vs (ps :=> TArrow na t)
| TExists vs (ps :=> t) <- na = f $ TForAll vs (ps :=> TArrow t nb)
| otherwise = TArrow na nb
fromHsTyVar (HsTyVar v) = return v
fromHsTyVar (HsTyExpKind (Located _ t) _) = fromHsTyVar t
fromHsTyVar _ = fail "fromHsTyVar"
|
dec9ue/jhc_copygc
|
src/FrontEnd/KindInfer.hs
|
gpl-2.0
| 24,216 | 0 | 18 | 6,311 | 8,252 | 4,038 | 4,214 | -1 | -1 |
-- | Basis functions of various kinds, useful for e.g. use with the LinearRegression module
module Algorithms.MachineLearning.BasisFunctions where
import Algorithms.MachineLearning.Framework
import Algorithms.MachineLearning.LinearAlgebra
import Algorithms.MachineLearning.Utilities
-- | Basis function that is 1 everywhere
constantBasis :: a -> Double
constantBasis = const 1
-- | /Unnormalized/ 1D Gaussian, suitable for use as a basis function.
gaussianBasis :: Mean -- ^ Mean of the Gaussian
-> Variance -- ^ Variance of the Gaussian
-> Double -- ^ Point on X axis to sample
-> Double
gaussianBasis mean variance x = exp (negate $ (square (x - mean)) / (2 * variance))
-- | Family of gaussian basis functions with constant variance and the given means, with
-- a constant basis function to capture the mean of the target variable.
gaussianBasisFamily :: [Mean] -> Variance -> [Double -> Double]
gaussianBasisFamily means variance = constantBasis : map (flip gaussianBasis variance) means
-- | /Unnormalized/ multi-dimensional Gaussian, suitable for use as a basis function.
multivariateGaussianBasis :: Vector Mean -- ^ Mean of the Gaussian
-> Matrix Variance -- ^ Covariance matrix
-> Vector Double -- ^ Point to sample
-> Double
multivariateGaussianBasis mean covariance x = exp (negate $ (deviation <.> (inv covariance <> deviation)) / 2)
where deviation = x - mean
-- | Family of multi-dimensional gaussian basis functions with constant, isotropic variance and
-- the given means, with a constant basis function to capture the mean of the target variable.
multivariateIsotropicGaussianBasisFamily :: [Vector Mean] -> Variance -> [Vector Double -> Double]
multivariateIsotropicGaussianBasisFamily means common_variance = constantBasis : map (flip multivariateGaussianBasis covariance) means
where covariance = (1 / common_variance) .* ident (dim (head means))
|
batterseapower/machine-learning
|
Algorithms/MachineLearning/BasisFunctions.hs
|
gpl-2.0
| 2,009 | 0 | 13 | 412 | 338 | 184 | 154 | 22 | 1 |
{-# LANGUAGE TemplateHaskell #-}
module Helpers(tailN) where
import Data.List
import Control.Monad
import Language.Haskell.TH
tailN n e = Data.List.foldr (\_ -> appE (conE (mkName "Tail"))) e [1..n]
|
laugh-at-me/recurrence
|
src/Helpers.hs
|
gpl-3.0
| 202 | 0 | 12 | 29 | 74 | 42 | 32 | 6 | 1 |
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneDeriving #-}
module Control.Monad.Select.Internal
( Packed' (..)
, Packed (..)
, Select
, Some (..)
, chance
, modify
, pack
, runSelect
, select
, updateState
) where
import Control.Monad (ap)
import Data.Dist (Dist)
import Data.Some (Some(..))
data Select' s a b where
Finished' :: s t -> b -> Select' s a b
Option' :: s t -> (a t -> Select' s a b) -> Select' s a b
Chance' :: Dist (Select' s a b) -> Select' s a b
deriving instance Functor (Select' s a)
newtype Select s a b = Select {runSelect :: forall t. s t -> Select' s a b}
deriving instance Functor (Select s a)
instance Applicative (Select s a) where
pure = return
(<*>) = ap
instance Monad (Select s a) where
return x = Select (`Finished'` x)
(>>=) :: forall x y. Select s a x -> (x -> Select s a y) -> Select s a y
Select infunc >>= f = Select outfunc
where
outfunc :: forall t. s t -> Select' s a y
outfunc s = op (infunc s)
op (Finished' s' z) = runSelect (f z) s'
op (Option' s' zfn) = Option' s' (op . zfn)
op (Chance' d) = Chance' $ fmap op d
modify :: forall s t a. (forall t'. s t' -> s t) -> Select s a (a t)
modify func = Select (\s -> Option' (func s) (Finished' s))
select :: Select s a (Some a)
select = Select (\s -> Option' s (Finished' s . Some))
chance :: Dist b -> Select s a b
chance d = Select (\s -> Chance' (Finished' s <$> d))
updateState :: (forall t. s t -> Some s) -> Select s a ()
updateState alterfn = Select $ \s ->
case alterfn s of
Some res -> Finished' res ()
data Packed s a b = forall t. Packed (Packed' s a t b)
data Packed' s a t b where
Finished :: b -> Packed' s a t b
Option :: s t -> (a t -> Dist (Packed s a b)) -> Packed' s a t b
pack :: Select' s a b -> Packed s a b
pack (Finished' _ x) = Packed $ Finished x
pack (Chance' _) = error "Chance node cannot come before first option."
pack (Option' s choice) = Packed $ Option s (helper . choice)
where
helper (Finished' _ x) = return $ Packed $ Finished x
helper (Option' s' choice') = return $ Packed $ Option s' (helper . choice')
helper (Chance' d) = d >>= helper
|
davidspies/regret-solver
|
select-game/src/Control/Monad/Select/Internal.hs
|
gpl-3.0
| 2,389 | 0 | 12 | 617 | 1,047 | 550 | 497 | 61 | 3 |
{-# LANGUAGE RecursiveDo, OverloadedStrings, DeriveDataTypeable #-}
module InnerEar.Widgets.Client where
import Control.Monad
import Data.Maybe
import Control.Monad.IO.Class (liftIO)
import GHCJS.Types
import GHCJS.Marshal.Internal
import GHCJS.Foreign.Callback
import Data.Map(Map, fromList, empty)
import Data.JSString(JSString, pack)
import Reflex
import Reflex.Dom
import Text.JSON
import Text.JSON.Generic
import InnerEar.Types.Response
import InnerEar.Types.Request
import InnerEar.Widgets.Utility
import InnerEar.Widgets.Login
import InnerEar.Widgets.Navigation
import qualified InnerEar.WebSocket as WS
import Sound.MusicW
-- | The clientWidget is the top-level widget in the Inner Ear web client.
-- At first it displays the login widget plus a choice to continue without logging in.
-- Successfully logging in (or choosing to continue without logging in) loads
-- the excercise navigationWidget instead.
performSynth :: MonadWidget t m => Event t (Maybe (Synth ())) -> m ()
performSynth selectedSynth = mdo
-- Behaviour t (Maybe Synthstance) - the previously instantiated synth
prevSynthstance <- hold Nothing newSynthstances
-- Event t (Maybe Synthstance, Maybe (Synth ())) - prev and current
let synthstnacePair = attach prevSynthstance selectedSynth
-- Event t (Maybe Synthstance)
newSynthstances <- performEvent $ ffor synthstnacePair $ \(prev, curr) -> liftIO $ do
-- Stop the old one if it existed
maybe (return ()) stopSynthNow prev
-- Start the new one if given
maybe (return Nothing) (\s -> instantiateSynth s >>= startSynthNow >>= return . Just) curr
return ()
clientWidget :: MonadWidget t m => Map String AudioBuffer -> m ()
clientWidget sysResources = elClass "div" "innerEar" $ mdo
(wsRcvd,wsStatus) <- WS.reflexWebSocket wsSend
elClass "div" "title" $ text "Inner Ear"
loginVisible <- holdDyn True $ leftmost [True <$ loggedIn, False <$ noLogin, True <$ loggedOut]
navVisible <- holdDyn False $ leftmost [True <$ loggedIn, True <$ noLogin, False <$ loggedOut]
(loginRequests,currentRole) <- visibleWhen loginVisible $ elClass "div" "login" $ loginWidget wsRcvd
let loggedIn = ffilter isJust $ updated currentRole
let loggedOut = ffilter isNothing $ updated currentRole
noLogin <- visibleWhen loginVisible $ button "Continue without logging in"
(navRequests,sounds) <- visibleWhen navVisible $ navigationWidget sysResources wsRcvd currentRole
let wsSend = leftmost [loginRequests,navRequests]
performSynth sounds
return ()
loadGlobalResources :: MonadWidget t m => m ( Event t (Map String AudioBuffer))
loadGlobalResources = do
let sources = ["pinknoise.wav", "whitenoise.wav"]
pb <- getPostBuild
bufferEv <- loadResources $ fmap (const sources) pb -- Ev (Map String Buffer)
let r = fmap (fmap js_getAudioBuffer) bufferEv -- Ev (Map String (IO AudioBuffer))
let r' = fmap (liftIO . sequence) r -- ev (io (Map String AudioBuffer))
performEvent r'
loadResources:: MonadWidget t m => Event t [String] -> m (Event t (Map String Buffer))
loadResources ev = do
bufferEv <- performEvent $ ffor ev $ \fileNames -> liftIO $ do -- Ev t [(String,Buffer)]
ctx <- globalAudioContext -- really just get global ac
forM fileNames $ \s -> do
buf <- js_createBufferFromURL (pack s) ctx
return (s,buf)
stateChangeEv <- performEventAsync $ ffor bufferEv $ \buffers evTrigger -> liftIO $ do -- Event t [Buffer]
-- cbs <- forM buffers $ \(s,buf) -> asyncCallback1 $ \buf -> evTrigger (Buffer buf) -- IO [cb]
cb <- asyncCallback1 $ \bufs -> do
maybeBufs <- fromJSValListOf bufs -- IO (Maybe [Buffer])
evTrigger (maybe [] (fmap Buffer) maybeBufs)
func (fmap snd buffers) cb
releaseCallback cb
statusEv <- performEvent $ ffor stateChangeEv $ \buffers -> do -- Event t [Maybe BufferStatus]
liftIO $ sequence $ fmap bufferStatus buffers -- IO [(Maybe BufferStatus)] then lifted
let areLoaded = fmap (and . fmap (maybe False (isBufferLoaded))) statusEv
dynBuffers <- holdDyn Data.Map.empty $ fmap fromList bufferEv
return $ tagDyn dynBuffers $ ffilter id areLoaded
where
func:: [Buffer] -> Callback (JSVal -> IO ()) -> IO ()
func b cb = do
listJSVal <- toJSValListOf b
js_startLoadingAndDecodingMultiple listJSVal cb
|
JamieBeverley/InnerEar
|
src/InnerEar/Widgets/Client.hs
|
gpl-3.0
| 4,404 | 0 | 22 | 879 | 1,174 | 584 | 590 | 73 | 1 |
#!/usr/bin/env runhaskell
{-
hakyll build script for hledger.org
requires Hakyll >= 2.1, pandoc >= 1.5
-}
import Control.Monad (forM_)
import Control.Monad.Trans (liftIO)
import System.Process (system)
import Text.Hakyll (hakyllWithConfiguration, defaultHakyllConfiguration)
import Text.Hakyll.HakyllMonad (HakyllConfiguration(..))
import Text.Hakyll.Render (renderChain, static)
import Text.Hakyll.CreateContext (createPage, createCustomPage, createListing)
import Text.Pandoc (ParserState(..), WriterOptions(..), defaultParserState, defaultWriterOptions)
import Text.Printf
baseurl = "http://hledger.org"
main = hakyllWithConfiguration cfg $ do
mapM_ renderParentDirPage
["README.md"
,"DOWNLOAD.md"
,"DEVELOPMENT.md"
,"NEWS.md"
,"SCREENSHOTS.md"
,"MANUAL.md"
,"CONTRIBUTORS.md"
]
mapM_ static
["style.css"
,"highslide/highslide.js"
,"highslide/highslide.css"
,"highslide/highslide-ie6.css"
,"highslide/graphics/zoomin.cur"
,"highslide/graphics/zoomout.cur"
,"highslide/graphics/outlines/rounded-black.png"
,"highslide/graphics/outlines/rounded-white.png"
,"highslide/graphics/outlines/beveled.png"
,"highslide/graphics/outlines/drop-shadow.png"
,"highslide/graphics/outlines/glossy-dark.png"
,"highslide/graphics/outlines/outer-glow.png"
,"highslide/graphics/loader.gif"
,"highslide/graphics/loader.white.gif"
,"highslide/graphics/icon.gif"
,"highslide/graphics/resize.gif"
,"highslide/graphics/fullexpand.gif"
,"highslide/graphics/geckodimmer.png"
,"highslide/graphics/close.png"
,"highslide/graphics/closeX.png"
,"linux.png"
,"mac.png"
,"windows.png"
,"sshot.png"
,"watchhours.png"
,"hledger-screen-1.png"
,"hledger-charts-2.png"
,"hledger-web-journal.png"
]
where
-- Render a page from the parent directory as if it was in the hakyll
-- root dir, setting up a symbolic link when needed.
renderParentDirPage p = do
liftIO $ system $ printf "[ -f %s ] || ln -s ../%s" p p
renderChain ["site.tmpl"] $ createPage p
cfg :: HakyllConfiguration
cfg = (defaultHakyllConfiguration baseurl) {
-- additionalContext = Context, -- An additional context to use when rendering. This additional context is used globally.
-- siteDirectory = FilePath, -- Directory where the site is placed.
-- cacheDirectory = FilePath, -- Directory for cache files.
-- enableIndexUrl = False, -- Enable index links.
-- previewPollDelay = Int, -- Delay between polls in preview mode.
pandocParserState = defaultParserState {
-- stateParseRaw = False, -- ^ Parse raw HTML and LaTeX?
-- stateParserContext = NullState, -- ^ Inside list?
-- stateQuoteContext = NoQuote, -- ^ Inside quoted environment?
-- stateSanitizeHTML = False, -- ^ Sanitize HTML?
-- stateKeys = [], -- ^ List of reference keys
-- stateNotes = [], -- ^ List of notes
-- stateTabStop = 4, -- ^ Tab stop
-- stateStandalone = False, -- ^ Parse bibliographic info?
-- stateTitle = [], -- ^ Title of document
-- stateAuthors = [], -- ^ Authors of document
-- stateDate = [], -- ^ Date of document
-- stateStrict = False, -- ^ Use strict markdown syntax?
stateSmart = False -- ^ Use smart typography?
-- stateLiterateHaskell = False, -- ^ Treat input as literate haskell
-- stateColumns = 80, -- ^ Number of columns in terminal
-- stateHeaderTable = [], -- ^ Ordered list of header types used
-- stateIndentedCodeClasses = [] -- ^ Classes to use for indented code blocks
},
pandocWriterOptions = defaultWriterOptions {
-- so we can have a TOC:
writerStandalone = True, -- ^ Include header and footer
writerTemplate = pandocTemplate, -- ^ Template to use in standalone mode
-- writerVariables = [], -- ^ Variables to set in template
-- writerIncludeBefore = "", -- ^ Text to include before the body
-- writerIncludeAfter = "", -- ^ Text to include after the body
-- writerTabStop = 4, -- ^ Tabstop for conversion btw spaces and tabs
writerTableOfContents = True -- ^ Include table of contents
-- writerS5 = False, -- ^ We're writing S5
-- writerXeTeX = False, -- ^ Create latex suitable for use by xetex
-- writerHTMLMathMethod = PlainMath, -- ^ How to print math in HTML
-- writerIgnoreNotes = False, -- ^ Ignore footnotes (used in making toc)
-- writerIncremental = False, -- ^ Incremental S5 lists
-- writerNumberSections = False, -- ^ Number sections in LaTeX
-- writerStrictMarkdown = False, -- ^ Use strict markdown syntax
-- writerReferenceLinks = False, -- ^ Use reference links in writing markdown, rst
-- writerWrapText = True, -- ^ Wrap text to line length
-- writerLiterateHaskell = False, -- ^ Write as literate haskell
-- writerEmailObfuscation = JavascriptObfuscation, -- ^ How to obfuscate emails
-- writerIdentifierPrefix = "", -- ^ Prefix for section & note ids in HTML
}
}
-- the body part of pandoc 1.5.1.1's html output template
pandocTemplate = unlines
[ "$if(title)$"
, "<h1 class=\"title\">$title$</h1>"
, "$endif$"
, "$for(include-before)$"
, "$include-before$"
, "$endfor$"
, "$if(toc)$"
, "$toc$"
, "$endif$"
, "$body$"
, "$for(include-after)$"
, "$include-after$"
, "$endfor$"
]
|
trygvis/hledger
|
site/hakyll.hs
|
gpl-3.0
| 5,765 | 0 | 9 | 1,473 | 463 | 297 | 166 | 73 | 1 |
module Grains (square, total) where
import Data.Maybe (mapMaybe)
square :: Integral a => a -> Maybe a
square 1 = Just 1
square n
| n <= 0 = Nothing
| n > 64 = Nothing
| otherwise = fmap (*2) $ square (n - 1)
total :: (Integral a) => a
total = sum $ mapMaybe square [1..64]
|
daewon/til
|
exercism/haskell/grains/src/Grains.hs
|
mpl-2.0
| 282 | 0 | 9 | 68 | 146 | 75 | 71 | 10 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- |
-- Module : Network.Google.Resource.AndroidEnterprise.Products.GetPermissions
-- Copyright : (c) 2015-2016 Brendan Hay
-- License : Mozilla Public License, v. 2.0.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves the Android app permissions required by this app.
--
-- /See:/ <https://developers.google.com/android/work/play/emm-api Google Play EMM API Reference> for @androidenterprise.products.getPermissions@.
module Network.Google.Resource.AndroidEnterprise.Products.GetPermissions
(
-- * REST Resource
ProductsGetPermissionsResource
-- * Creating a Request
, productsGetPermissions
, ProductsGetPermissions
-- * Request Lenses
, pgpEnterpriseId
, pgpProductId
) where
import Network.Google.AndroidEnterprise.Types
import Network.Google.Prelude
-- | A resource alias for @androidenterprise.products.getPermissions@ method which the
-- 'ProductsGetPermissions' request conforms to.
type ProductsGetPermissionsResource =
"androidenterprise" :>
"v1" :>
"enterprises" :>
Capture "enterpriseId" Text :>
"products" :>
Capture "productId" Text :>
"permissions" :>
QueryParam "alt" AltJSON :>
Get '[JSON] ProductPermissions
-- | Retrieves the Android app permissions required by this app.
--
-- /See:/ 'productsGetPermissions' smart constructor.
data ProductsGetPermissions = ProductsGetPermissions'
{ _pgpEnterpriseId :: !Text
, _pgpProductId :: !Text
} deriving (Eq,Show,Data,Typeable,Generic)
-- | Creates a value of 'ProductsGetPermissions' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'pgpEnterpriseId'
--
-- * 'pgpProductId'
productsGetPermissions
:: Text -- ^ 'pgpEnterpriseId'
-> Text -- ^ 'pgpProductId'
-> ProductsGetPermissions
productsGetPermissions pPgpEnterpriseId_ pPgpProductId_ =
ProductsGetPermissions'
{ _pgpEnterpriseId = pPgpEnterpriseId_
, _pgpProductId = pPgpProductId_
}
-- | The ID of the enterprise.
pgpEnterpriseId :: Lens' ProductsGetPermissions Text
pgpEnterpriseId
= lens _pgpEnterpriseId
(\ s a -> s{_pgpEnterpriseId = a})
-- | The ID of the product.
pgpProductId :: Lens' ProductsGetPermissions Text
pgpProductId
= lens _pgpProductId (\ s a -> s{_pgpProductId = a})
instance GoogleRequest ProductsGetPermissions where
type Rs ProductsGetPermissions = ProductPermissions
type Scopes ProductsGetPermissions =
'["https://www.googleapis.com/auth/androidenterprise"]
requestClient ProductsGetPermissions'{..}
= go _pgpEnterpriseId _pgpProductId (Just AltJSON)
androidEnterpriseService
where go
= buildClient
(Proxy :: Proxy ProductsGetPermissionsResource)
mempty
|
rueshyna/gogol
|
gogol-android-enterprise/gen/Network/Google/Resource/AndroidEnterprise/Products/GetPermissions.hs
|
mpl-2.0
| 3,535 | 0 | 15 | 785 | 385 | 231 | 154 | 65 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.