Curry.Module.Prelude

Documentation

type C_Float = Prim Float

data C_IO t0

Constructors

C_IO (State -> IO (IOVal t0))

C_IOFail C_Exceptions

C_IOOr OrRef (Branches (C_IO t0))

Instances

Read (C_IO a)

Show (C_IO a)

BaseCurry t0 => BaseCurry (C_IO t0)

BaseCurry a => Curry (C_IO a)

data IOVal t0

Constructors

IOVal t0

IOValFail C_Exceptions

IOValOr OrRef (Branches (IO (IOVal t0)))

Instances

Read (IO (IOVal a))

Read t0 => Read (IOVal t0)

Show (IO (IOVal a))

Show t0 => Show (IOVal t0)

BaseCurry t0 => BaseCurry (IO (IOVal t0))

BaseCurry t0 => BaseCurry (IOVal t0)

BaseCurry a => Curry (IO (IOVal a))

data C_Bool

Constructors

C_False

C_True

C_BoolFail C_Exceptions

C_BoolOr OrRef (Branches C_Bool)

C_BoolAnd [C_Bool]

Instances

Read C_Bool

Show C_Bool

BaseCurry C_Bool

Curry C_Bool

ConvertCH C_Bool Bool

data C_Char

Constructors

C_Char !Char

SearchChar C_Four C_Four C_Four C_Four

C_CharFail C_Exceptions

C_CharOr OrRef (Branches C_Char)

Instances

Read C_Char

Show C_Char

BaseCurry C_Char

Curry C_Char

ConvertCH C_Char Char

Eq (List C_Char)

trace :: String -> a -> a

type StrEqResult = C_Bool

class (BaseCurry a, Show a, Read a) => Curry a where

Methods

strEq :: a -> a -> Result StrEqResult

eq :: a -> a -> Result C_Bool

propagate :: (forall b. Curry b => Int -> b -> Result b) -> a -> Result a

foldCurry :: (forall c. Curry c => c -> b -> Result b) -> b -> a -> Result b

typeName :: a -> String

showQ :: Int -> a -> String -> String

showQList :: [a] -> String -> String

Instances

Curry C_Success

Curry C_Int

Curry C_Nat

Curry C_Ordering

Curry T0

Curry C_Four

Curry C_Char

Curry C_Bool

Curry C_CalendarTime

Curry C_ClockTime

Curry C_GlobalSpec

Curry C_SeekMode

Curry C_IOMode

Curry C_Tokens

Curry C_Doc

Curry C_Color

Curry C_Exception

Curry C_OrRef

Curry C_Config

Curry C_Result

Curry C_Test

Curry C_ProtocolMsg

Curry C_XmlDocParams

Curry C_Encoding

Curry C_XmlExp

Curry C_Token

Curry C_FrontendParams

Curry C_FrontendTarget

Curry C_Literal

Curry C_Pattern

Curry C_BranchExpr

Curry C_Expr

Curry C_CombType

Curry C_CaseType

Curry C_Rule

Curry C_FuncDecl

Curry C_Fixity

Curry C_OpDecl

Curry C_TypeExpr

Curry C_ConsDecl

Curry C_TypeDecl

Curry C_Visibility

Curry C_Prog

Curry C_FlexRigidResult

Curry C_CLiteral

Curry C_CBranchExpr

Curry C_CPattern

Curry C_CStatement

Curry C_CExpr

Curry C_CLocalDecl

Curry C_CRule

Curry C_CEvalAnnot

Curry C_CRules

Curry C_CFuncDecl

Curry C_CFixity

Curry C_COpDecl

Curry C_CTypeExpr

Curry C_CConsDecl

Curry C_CTypeDecl

Curry C_CVisibility

Curry C_CurryProg

Curry C_RequiredSpec

Curry C_Option

Curry C_InfixOp

Curry C_Literal

Curry C_TypeExpr

Curry C_CallConv

Curry C_EvalAnnotation

Curry C_Infix

Curry C_Import

Curry C_Export

Curry C_QualIdent

Curry C_Ident

Curry C_Position

BaseCurry a => Curry (IO (IOVal a))

Curry t0 => Curry (C_SearchTree t0)

Curry t0 => Curry (C_Maybe t0)

Curry t0 => Curry (List t0)

(Generate a, Show a, Read a, Eq a) => Curry (Prim a)

BaseCurry a => Curry (C_IO a)

Curry t0 => Curry (C_Queue t0)

Curry t0 => Curry (C_Entry t0)

Curry t0 => Curry (C_Array t0)

Curry t0 => Curry (C_Tree t0)

Curry t0 => Curry (C_RedBlackTree t0)

Curry t0 => Curry (C_Seq t0)

Curry t0 => Curry (C_RichSearchTree t0)

Curry t0 => Curry (C_Assertion t0)

Curry t0 => Curry (C_Alt t0)

Curry t0 => Curry (C_Statement t0)

Curry t0 => Curry (C_Expression t0)

Curry t0 => Curry (C_ConstrTerm t0)

Curry t0 => Curry (C_CondExpr t0)

Curry t0 => Curry (C_Rhs t0)

Curry t0 => Curry (C_Lhs t0)

Curry t0 => Curry (C_Equation t0)

Curry t0 => Curry (C_NewConstrDecl t0)

Curry t0 => Curry (C_ConstrDecl t0)

Curry t0 => Curry (C_Decl t0)

Curry t0 => Curry (C_ImportSpec t0)

Curry t0 => Curry (C_ExportSpec t0)

Curry t0 => Curry (C_Module t0)

(Curry t0, Curry t1) => Curry (C_Either t0 t1)

(Curry t0, Curry t1) => Curry (T2 t0 t1)

(Curry t0, Curry t1) => Curry (C_FiniteMap t0 t1)

(Curry t0, Curry t1) => Curry (C_FM t0 t1)

(Curry t0, Curry t1) => Curry (C_Graph t0 t1)

(Curry t0, Curry t1) => Curry (C_Field t0 t1)

(Curry t0, Curry t1, Curry t2) => Curry (T3 t0 t1 t2)

(Curry t0, Curry t1, Curry t2, Curry t3) => Curry (T4 t0 t1 t2 t3)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4) => Curry (T5 t0 t1 t2 t3 t4)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5) => Curry (T6 t0 t1 t2 t3 t4 t5)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6) => Curry (T7 t0 t1 t2 t3 t4 t5 t6)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7) => Curry (T8 t0 t1 t2 t3 t4 t5 t6 t7)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8) => Curry (T9 t0 t1 t2 t3 t4 t5 t6 t7 t8)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9) => Curry (T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10) => Curry (T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11) => Curry (T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11, Curry t12) => Curry (T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11, Curry t12, Curry t13) => Curry (T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11, Curry t12, Curry t13, Curry t14) => Curry (T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14)

class Generate a where

Methods

genFree :: Int -> [a]

maxArity :: a -> Int

Instances

Generate Float

Generate Socket

Generate IOHandle

Generate (IORef a)

BaseCurry b => Generate (a -> Result b)

showsPrecList :: (a -> ShowS) -> ([a] -> ShowS) -> Int -> List a -> ShowS

showQStandardList :: Curry a => [a] -> ShowS

fourToInt :: C_Four -> Either String Int

intToFour :: Int -> C_Four

scToChar :: C_Four -> C_Four -> C_Four -> C_Four -> Either String Char

charToSc :: Char -> C_Char

protectEsc :: (Char -> Bool) -> ([Char] -> c) -> [Char] -> c

asciiTab :: [(Char, [Char])]

isFreeNat :: C_Nat -> Bool

showsPrecNat :: Int -> C_Nat -> ShowS

class ConvertCH a b where

Methods

fromCurry :: a -> b

toCurry :: b -> a

Instances

ConvertCH C_Int Int

ConvertCH C_Int Integer

ConvertCH C_Int ExitCode

ConvertCH C_Int PortID

ConvertCH C_Nat Integer

ConvertCH T0 ()

ConvertCH C_Char Char

ConvertCH C_Bool Bool

ConvertCH C_CalendarTime CalendarTime

ConvertCH C_ClockTime ClockTime

ConvertCH C_SeekMode SeekMode

ConvertCH C_IOMode IOMode

ConvertCH C_Exception Exception

ConvertCH (Prim a) a

ConvertCH a b => ConvertCH (C_Maybe a) (Maybe b)

ConvertCH a b => ConvertCH (List a) [b]

(ConvertCH a ha, ConvertCH b hb) => ConvertCH (T2 a b) (ha, hb)

(ConvertCH a ha, ConvertCH b hb, ConvertCH c hc) => ConvertCH (T3 a b c) (ha, hb, hc)

isC_True :: C_Bool -> Bool

toHaskellList :: List a -> [a]

fromHaskellList :: [a] -> List a

fromHaskellString :: String -> List C_Char

concAnd :: StrEqResult -> StrEqResult -> Result StrEqResult

maySwitch :: StrEqResult -> StrEqResult -> Result StrEqResult

genEq :: Curry t0 => t0 -> t0 -> Result C_Bool

genStrEq :: Curry t0 => t0 -> t0 -> Result StrEqResult

strEqFail :: String -> StrEqResult

strEqSuccess :: StrEqResult

mkBranches :: BaseCurry b => b -> [a -> Result b]

preturn :: a -> IO a

optChangeStore :: a -> (b -> Store -> a) -> ((Int -> Store) -> a) -> OrRef -> Branches b -> Store -> a

curryIO :: Curry a => Result (C_IO a) -> IO a

curryIOVoid :: Curry a => Result (C_IO a) -> IO ()

ioStart :: Curry a => Store -> C_IO a -> IO a

curryDo :: Curry a => Store -> IOVal a -> IO a

mkChoice :: BaseCurry a => (Int -> Store) -> Int -> a -> (Store, a)

searchValC_IO :: Curry a => [C_Exceptions] -> [(Store, C_IO a)] -> IO a

searchIOVal :: Curry a => [C_Exceptions] -> [(Store, IO (IOVal a))] -> IO a

searchVal :: (Store -> a -> b) -> Store -> OrRef -> Branches a -> b

printException :: C_Exceptions -> IO ()

printExceptions :: C_Exceptions -> IO a

($#) :: (Curry a, Curry b) => Prim (a -> Result b) -> a -> Result b

($!) :: (Curry a, Curry b) => Prim (a -> Result b) -> a -> Result b

($!!) :: (Curry a, Curry b) => Prim (a -> Result b) -> a -> Result b

($##) :: (Curry a, Curry b) => Prim (a -> Result b) -> a -> Result b

prim_error :: Curry a => C_String -> Result a

failed :: Curry a => Result a

(==) :: Curry a => a -> a -> Result C_Bool

prim_ord :: C_Char -> Result C_Int

prim_chr :: C_Int -> Result C_Char

(===) :: Curry a => a -> a -> Result C_Bool

prim_negateFloat :: C_Float -> Result C_Float

success :: C_Success

(&) :: C_Success -> C_Success -> Result C_Success

boolToSuccess :: C_Bool -> State -> C_Success

successToBool :: C_Success -> Result C_Bool

(>>=) :: (Curry a, Curry b) => C_IO a -> Prim (a -> Result (C_IO b)) -> Result (C_IO b)

exec :: (Curry a, Curry b) => Prim (a -> Result (C_IO b)) -> C_IO a -> Result (IO (IOVal b))

prim_do :: (Curry a, Curry b) => Prim (a -> Result (C_IO b)) -> IOVal a -> Result (IO (IOVal b))

exec2 :: C_IO b -> Result (IO (IOVal b))

return :: a -> Result (C_IO a)

prim_putChar :: C_Char -> Result (C_IO T0)

getChar :: Result (C_IO C_Char)

prim_readFile :: C_String -> Result (C_IO C_String)

prim_writeFile :: C_String -> C_String -> Result (C_IO T0)

prim_appendFile :: C_String -> C_String -> Result (C_IO T0)

catchFail :: Curry a => C_IO a -> C_IO a -> Result (C_IO a)

searchValCatch :: Curry a => [(Store, C_IO a)] -> C_IO a -> C_IO a

prim_show :: (Show a, Curry a) => a -> Result C_String

getSearchTree :: Curry a => a -> Result (C_IO (C_SearchTree a))

searchTr :: Curry a => a -> Result (C_SearchTree a)

prepApply :: (BaseCurry a, BaseCurry b) => ((b -> Result a) -> b -> Result a) -> b -> Prim (b -> Result a) -> Result a

apply :: BaseCurry b => Prim (t -> State -> b) -> t -> State -> b

pf :: Curry b => (a -> Result b) -> Prim (a -> Result b)

pc :: Curry b => (a -> b) -> Prim (a -> Result b)

pa :: Curry c => (a -> Prim (b -> Result c)) -> Prim (a -> Result (Prim (b -> Result c)))

cp :: (b -> c) -> (a -> b) -> a -> c

cond :: Curry a => C_Success -> a -> Result a

ifVar :: (Curry a, Curry b) => b -> a -> a -> a

extFunc1 :: (Curry a, Curry d, ConvertCH a b, ConvertCH d c) => (b -> c) -> a -> Result d

extFunc2 :: (Curry a, Curry c, Curry f, ConvertCH a b, ConvertCH c d, ConvertCH f e) => (b -> d -> e) -> a -> c -> Result f

extFunc3 :: (Curry c1, Curry c2, Curry c3, Curry cv, ConvertCH c1 h1, ConvertCH c2 h2, ConvertCH c3 h3, ConvertCH cv hv) => (h1 -> h2 -> h3 -> hv) -> c1 -> c2 -> c3 -> Result cv

extFunc4 :: (Curry c1, Curry c2, Curry c3, Curry c4, Curry cv, ConvertCH c1 h1, ConvertCH c2 h2, ConvertCH c3 h3, ConvertCH c4 h4, ConvertCH cv hv) => (h1 -> h2 -> h3 -> h4 -> hv) -> c1 -> c2 -> c3 -> c4 -> Result cv

hnf2 :: (Curry a, Curry b, Curry c) => (a -> b -> c) -> a -> b -> Result c

ioFunc0 :: (Curry b, ConvertCH b a) => IO a -> Result (C_IO b)

ioFunc1 :: (Curry a, Curry d, ConvertCH a b, ConvertCH d c) => (b -> IO c) -> a -> Result (C_IO d)

ioFunc2 :: (Curry a, Curry c, Curry f, ConvertCH a b, ConvertCH c d, ConvertCH f e) => (b -> d -> IO e) -> a -> c -> Result (C_IO f)

ioFunc3 :: (ConvertCH t0 b3, ConvertCH a2 b2, ConvertCH a1 b1, ConvertCH a b) => (b -> b1 -> b2 -> IO b3) -> a -> a1 -> a2 -> t -> C_IO t0

ghnfCTC2 :: (Curry a, Curry b, Curry c) => (a -> b -> c) -> a -> b -> Result c

(=:<=) :: t

data Prim t0

Constructors

PrimValue t0

PrimFail C_Exceptions

PrimOr OrRef (Branches (Prim t0))

Instances

Floating C_Float

Fractional C_Float

RealFrac C_Float

Enum a => Enum (Prim a)

Eq a => Eq (Prim a)

Integral a => Integral (Prim a)

Num a => Num (Prim a)

Ord a => Ord (Prim a)

Read a => Read (Prim a)

Real a => Real (Prim a)

Show a => Show (Prim a)

Generate a => BaseCurry (Prim a)

(Generate a, Show a, Read a, Eq a) => Curry (Prim a)

ConvertCH (Prim a) a

data C_Four

Constructors

C_F0

C_F1

C_F2

C_F3

C_FourFail C_Exceptions

C_FourOr OrRef (Branches C_Four)

Instances

Eq C_Four

Read C_Four

Show C_Four

BaseCurry C_Four

Curry C_Four

type C_String = List C_Char

data T0

Constructors

T0

T0Fail C_Exceptions

T0Or OrRef (Branches T0)

Instances

Read T0

Show T0

BaseCurry T0

Curry T0

ConvertCH T0 ()

data List t0

Constructors

List

:< t0 (List t0)

ListFail C_Exceptions

ListOr OrRef (Branches (List t0))

Instances

Eq (List C_Char)

Read a => Read (List a)

Show a => Show (List a)

BaseCurry t0 => BaseCurry (List t0)

Curry t0 => Curry (List t0)

ConvertCH a b => ConvertCH (List a) [b]

data T2 t0 t1

Constructors

T2 t0 t1

T2Fail C_Exceptions

T2Or OrRef (Branches (T2 t0 t1))

Instances

(Read t0, Read t1) => Read (T2 t0 t1)

(Show t0, Show t1) => Show (T2 t0 t1)

(BaseCurry t0, BaseCurry t1) => BaseCurry (T2 t0 t1)

(Curry t0, Curry t1) => Curry (T2 t0 t1)

(ConvertCH a ha, ConvertCH b hb) => ConvertCH (T2 a b) (ha, hb)

data T3 t0 t1 t2

Constructors

T3 t0 t1 t2

T3Fail C_Exceptions

T3Or OrRef (Branches (T3 t0 t1 t2))

Instances

(Read t0, Read t1, Read t2) => Read (T3 t0 t1 t2)

(Show t0, Show t1, Show t2) => Show (T3 t0 t1 t2)

(BaseCurry t0, BaseCurry t1, BaseCurry t2) => BaseCurry (T3 t0 t1 t2)

(Curry t0, Curry t1, Curry t2) => Curry (T3 t0 t1 t2)

(ConvertCH a ha, ConvertCH b hb, ConvertCH c hc) => ConvertCH (T3 a b c) (ha, hb, hc)

data T4 t0 t1 t2 t3

Constructors

T4 t0 t1 t2 t3

T4Fail C_Exceptions

T4Or OrRef (Branches (T4 t0 t1 t2 t3))

Instances

(Read t0, Read t1, Read t2, Read t3) => Read (T4 t0 t1 t2 t3)

(Show t0, Show t1, Show t2, Show t3) => Show (T4 t0 t1 t2 t3)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3) => BaseCurry (T4 t0 t1 t2 t3)

(Curry t0, Curry t1, Curry t2, Curry t3) => Curry (T4 t0 t1 t2 t3)

data T5 t0 t1 t2 t3 t4

Constructors

T5 t0 t1 t2 t3 t4

T5Fail C_Exceptions

T5Or OrRef (Branches (T5 t0 t1 t2 t3 t4))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4) => Read (T5 t0 t1 t2 t3 t4)

(Show t0, Show t1, Show t2, Show t3, Show t4) => Show (T5 t0 t1 t2 t3 t4)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4) => BaseCurry (T5 t0 t1 t2 t3 t4)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4) => Curry (T5 t0 t1 t2 t3 t4)

data T6 t0 t1 t2 t3 t4 t5

Constructors

T6 t0 t1 t2 t3 t4 t5

T6Fail C_Exceptions

T6Or OrRef (Branches (T6 t0 t1 t2 t3 t4 t5))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5) => Read (T6 t0 t1 t2 t3 t4 t5)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5) => Show (T6 t0 t1 t2 t3 t4 t5)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5) => BaseCurry (T6 t0 t1 t2 t3 t4 t5)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5) => Curry (T6 t0 t1 t2 t3 t4 t5)

data T7 t0 t1 t2 t3 t4 t5 t6

Constructors

T7 t0 t1 t2 t3 t4 t5 t6

T7Fail C_Exceptions

T7Or OrRef (Branches (T7 t0 t1 t2 t3 t4 t5 t6))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6) => Read (T7 t0 t1 t2 t3 t4 t5 t6)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6) => Show (T7 t0 t1 t2 t3 t4 t5 t6)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6) => BaseCurry (T7 t0 t1 t2 t3 t4 t5 t6)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6) => Curry (T7 t0 t1 t2 t3 t4 t5 t6)

data T8 t0 t1 t2 t3 t4 t5 t6 t7

Constructors

T8 t0 t1 t2 t3 t4 t5 t6 t7

T8Fail C_Exceptions

T8Or OrRef (Branches (T8 t0 t1 t2 t3 t4 t5 t6 t7))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7) => Read (T8 t0 t1 t2 t3 t4 t5 t6 t7)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7) => Show (T8 t0 t1 t2 t3 t4 t5 t6 t7)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7) => BaseCurry (T8 t0 t1 t2 t3 t4 t5 t6 t7)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7) => Curry (T8 t0 t1 t2 t3 t4 t5 t6 t7)

data T9 t0 t1 t2 t3 t4 t5 t6 t7 t8

Constructors

T9 t0 t1 t2 t3 t4 t5 t6 t7 t8

T9Fail C_Exceptions

T9Or OrRef (Branches (T9 t0 t1 t2 t3 t4 t5 t6 t7 t8))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7, Read t8) => Read (T9 t0 t1 t2 t3 t4 t5 t6 t7 t8)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7, Show t8) => Show (T9 t0 t1 t2 t3 t4 t5 t6 t7 t8)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7, BaseCurry t8) => BaseCurry (T9 t0 t1 t2 t3 t4 t5 t6 t7 t8)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8) => Curry (T9 t0 t1 t2 t3 t4 t5 t6 t7 t8)

data T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9

Constructors

T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9

T10Fail C_Exceptions

T10Or OrRef (Branches (T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7, Read t8, Read t9) => Read (T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7, Show t8, Show t9) => Show (T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7, BaseCurry t8, BaseCurry t9) => BaseCurry (T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9) => Curry (T10 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9)

data T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10

Constructors

T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10

T11Fail C_Exceptions

T11Or OrRef (Branches (T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7, Read t8, Read t9, Read t10) => Read (T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7, Show t8, Show t9, Show t10) => Show (T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7, BaseCurry t8, BaseCurry t9, BaseCurry t10) => BaseCurry (T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10) => Curry (T11 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10)

data T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11

Constructors

T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11

T12Fail C_Exceptions

T12Or OrRef (Branches (T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7, Read t8, Read t9, Read t10, Read t11) => Read (T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7, Show t8, Show t9, Show t10, Show t11) => Show (T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7, BaseCurry t8, BaseCurry t9, BaseCurry t10, BaseCurry t11) => BaseCurry (T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11) => Curry (T12 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11)

data T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12

Constructors

T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12

T13Fail C_Exceptions

T13Or OrRef (Branches (T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7, Read t8, Read t9, Read t10, Read t11, Read t12) => Read (T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7, Show t8, Show t9, Show t10, Show t11, Show t12) => Show (T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7, BaseCurry t8, BaseCurry t9, BaseCurry t10, BaseCurry t11, BaseCurry t12) => BaseCurry (T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11, Curry t12) => Curry (T13 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12)

data T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13

Constructors

T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13

T14Fail C_Exceptions

T14Or OrRef (Branches (T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7, Read t8, Read t9, Read t10, Read t11, Read t12, Read t13) => Read (T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7, Show t8, Show t9, Show t10, Show t11, Show t12, Show t13) => Show (T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7, BaseCurry t8, BaseCurry t9, BaseCurry t10, BaseCurry t11, BaseCurry t12, BaseCurry t13) => BaseCurry (T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11, Curry t12, Curry t13) => Curry (T14 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13)

data T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14

Constructors

T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14

T15Fail C_Exceptions

T15Or OrRef (Branches (T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14))

Instances

(Read t0, Read t1, Read t2, Read t3, Read t4, Read t5, Read t6, Read t7, Read t8, Read t9, Read t10, Read t11, Read t12, Read t13, Read t14) => Read (T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14)

(Show t0, Show t1, Show t2, Show t3, Show t4, Show t5, Show t6, Show t7, Show t8, Show t9, Show t10, Show t11, Show t12, Show t13, Show t14) => Show (T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14)

(BaseCurry t0, BaseCurry t1, BaseCurry t2, BaseCurry t3, BaseCurry t4, BaseCurry t5, BaseCurry t6, BaseCurry t7, BaseCurry t8, BaseCurry t9, BaseCurry t10, BaseCurry t11, BaseCurry t12, BaseCurry t13, BaseCurry t14) => BaseCurry (T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14)

(Curry t0, Curry t1, Curry t2, Curry t3, Curry t4, Curry t5, Curry t6, Curry t7, Curry t8, Curry t9, Curry t10, Curry t11, Curry t12, Curry t13, Curry t14) => Curry (T15 t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14)

data C_Ordering

Constructors

C_LT

C_EQ

C_GT

C_OrderingFail C_Exceptions

C_OrderingOr OrRef (Branches C_Ordering)

Instances

Read C_Ordering

Show C_Ordering

BaseCurry C_Ordering

Curry C_Ordering

data C_Nat

Constructors

C_IHi

C_O C_Nat

C_I C_Nat

C_NatFail C_Exceptions

C_NatOr OrRef (Branches C_Nat)

Instances

Read C_Nat

Show C_Nat

BaseCurry C_Nat

Curry C_Nat

ConvertCH C_Nat Integer

data C_Int

Constructors

C_Neg C_Nat

C_Zero

C_Pos C_Nat

C_IntFail C_Exceptions

C_IntOr OrRef (Branches C_Int)

Instances

Eq C_Int

Num C_Int

Read C_Int

Show C_Int

BaseCurry C_Int

Curry C_Int

ConvertCH C_Int Int

ConvertCH C_Int Integer

ConvertCH C_Int ExitCode

ConvertCH C_Int PortID

data C_Success

Constructors

C_Success

C_SuccessFail C_Exceptions

C_SuccessOr OrRef (Branches C_Success)

Instances

Read C_Success

Show C_Success

BaseCurry C_Success

Curry C_Success

data C_Maybe t0

Constructors

C_Nothing

C_Just t0

C_MaybeFail C_Exceptions

C_MaybeOr OrRef (Branches (C_Maybe t0))

Instances

Read t0 => Read (C_Maybe t0)

Show t0 => Show (C_Maybe t0)

BaseCurry t0 => BaseCurry (C_Maybe t0)

Curry t0 => Curry (C_Maybe t0)

ConvertCH a b => ConvertCH (C_Maybe a) (Maybe b)

data C_Either t0 t1

Constructors

C_Left t0

C_Right t1

C_EitherFail C_Exceptions

C_EitherOr OrRef (Branches (C_Either t0 t1))

Instances

(Read t0, Read t1) => Read (C_Either t0 t1)

(Show t0, Show t1) => Show (C_Either t0 t1)

(BaseCurry t0, BaseCurry t1) => BaseCurry (C_Either t0 t1)

(Curry t0, Curry t1) => Curry (C_Either t0 t1)

data C_SearchTree t0

Constructors

C_Fail

C_Value t0

C_Choice (List (C_SearchTree t0))

C_Suspend

C_SearchTreeFail C_Exceptions

C_SearchTreeOr OrRef (Branches (C_SearchTree t0))

Instances

Read t0 => Read (C_SearchTree t0)

Show t0 => Show (C_SearchTree t0)

BaseCurry t0 => BaseCurry (C_SearchTree t0)

Curry t0 => Curry (C_SearchTree t0)

op_46 :: (Curry t0, Curry t1, Curry t2) => Prim (t0 -> State -> t1) -> Prim (t2 -> State -> t0) -> State -> Prim (t2 -> State -> t1)

c_'46'46_'35lambda2 :: (Curry t9, Curry t11, Curry t7) => Prim (t9 -> State -> t11) -> Prim (t7 -> State -> t9) -> t7 -> State -> t11

c_id :: Curry t0 => t0 -> State -> t0

c_const :: (Curry t0, Curry t1) => t0 -> t1 -> State -> t0

c_curry :: (Curry t0, Curry t1, Curry t2) => Prim (T2 t0 t1 -> State -> t2) -> t0 -> t1 -> State -> t2

c_uncurry :: (Curry t0, Curry t1, Curry t2) => Prim (t0 -> State -> Prim (t1 -> State -> t2)) -> T2 t0 t1 -> State -> t2

c_flip :: (Curry t0, Curry t1, Curry t2) => Prim (t0 -> State -> Prim (t1 -> State -> t2)) -> t1 -> t0 -> State -> t2

c_until :: Curry t0 => Prim (t0 -> State -> C_Bool) -> Prim (t0 -> State -> t0) -> t0 -> State -> t0

op_36 :: (Curry t0, Curry t1) => Prim (t0 -> State -> t1) -> t0 -> State -> t1

c_ensureSpine :: Curry t0 => State -> Prim (List t0 -> State -> List t0)

c_ensureSpine'46ensureList'4621 :: Curry t0 => List t0 -> State -> List t0

c_seq :: (Curry t0, Curry t1) => t0 -> t1 -> State -> t1

c_error :: Curry t0 => List C_Char -> State -> t0

op_38_38 :: C_Bool -> C_Bool -> State -> C_Bool

op_124_124 :: C_Bool -> C_Bool -> State -> C_Bool

c_not :: C_Bool -> State -> C_Bool

c_otherwise :: State -> C_Bool

c_if_then_else :: Curry t0 => C_Bool -> t0 -> t0 -> State -> t0

c_isLT :: C_Ordering -> State -> C_Bool

c_isGT :: C_Ordering -> State -> C_Bool

c_isEQ :: C_Ordering -> State -> C_Bool

c_compare :: C_Int -> C_Int -> State -> C_Ordering

op_60 :: C_Int -> C_Int -> State -> C_Bool

op_62 :: C_Int -> C_Int -> State -> C_Bool

op_60_61 :: C_Int -> C_Int -> State -> C_Bool

op_62_61 :: C_Int -> C_Int -> State -> C_Bool

c_max :: C_Int -> C_Int -> State -> C_Int

c_min :: C_Int -> C_Int -> State -> C_Int

op_47_61 :: Curry t0 => t0 -> t0 -> State -> C_Bool

c_fst :: (Curry t0, Curry t1) => T2 t0 t1 -> State -> t0

c_snd :: (Curry t0, Curry t1) => T2 t0 t1 -> State -> t1

c_head :: Curry t0 => List t0 -> State -> t0

c_tail :: Curry t0 => List t0 -> State -> List t0

c_null :: Curry t0 => List t0 -> State -> C_Bool

op_43_43 :: Curry t0 => List t0 -> List t0 -> State -> List t0

c_length :: Curry t0 => List t0 -> State -> C_Int

op_33_33 :: Curry t0 => List t0 -> C_Int -> State -> t0

c_map :: (Curry t0, Curry t1) => Prim (t0 -> State -> t1) -> List t0 -> State -> List t1

c_foldl :: (Curry t0, Curry t1) => Prim (t0 -> State -> Prim (t1 -> State -> t0)) -> t0 -> List t1 -> State -> t0

c_foldl1 :: Curry t0 => Prim (t0 -> State -> Prim (t0 -> State -> t0)) -> List t0 -> State -> t0

c_foldr :: (Curry t0, Curry t1) => Prim (t0 -> State -> Prim (t1 -> State -> t1)) -> t1 -> List t0 -> State -> t1

c_foldr1 :: Curry t0 => Prim (t0 -> State -> Prim (t0 -> State -> t0)) -> List t0 -> State -> t0

c_filter :: Curry t0 => Prim (t0 -> State -> C_Bool) -> List t0 -> State -> List t0

c_zip :: (Curry t0, Curry t1) => List t0 -> List t1 -> State -> List (T2 t0 t1)

c_zip3 :: (Curry t0, Curry t1, Curry t2) => List t0 -> List t1 -> List t2 -> State -> List (T3 t0 t1 t2)

c_zipWith :: (Curry t0, Curry t1, Curry t2) => Prim (t0 -> State -> Prim (t1 -> State -> t2)) -> List t0 -> List t1 -> State -> List t2

c_zipWith3 :: (Curry t0, Curry t1, Curry t2, Curry t3) => Prim (t0 -> State -> Prim (t1 -> State -> Prim (t2 -> State -> t3))) -> List t0 -> List t1 -> List t2 -> State -> List t3

c_unzip :: (Curry t0, Curry t1) => List (T2 t0 t1) -> State -> T2 (List t0) (List t1)

c_unzip'46_'35selFP3'35xs :: (Curry t476, Curry t477) => T2 (List t476) (List t477) -> State -> List t476

c_unzip'46_'35selFP4'35ys :: (Curry t476, Curry t477) => T2 (List t476) (List t477) -> State -> List t477

c_unzip3 :: (Curry t0, Curry t1, Curry t2) => List (T3 t0 t1 t2) -> State -> T3 (List t0) (List t1) (List t2)

c_unzip3'46_'35selFP6'35xs :: (Curry t493, Curry t494, Curry t495) => T3 (List t493) (List t494) (List t495) -> State -> List t493

c_unzip3'46_'35selFP7'35ys :: (Curry t493, Curry t494, Curry t495) => T3 (List t493) (List t494) (List t495) -> State -> List t494

c_unzip3'46_'35selFP8'35zs :: (Curry t493, Curry t494, Curry t495) => T3 (List t493) (List t494) (List t495) -> State -> List t495

c_concat :: Curry t0 => List (List t0) -> State -> List t0

c_concatMap :: (Curry t0, Curry t1) => Prim (t0 -> State -> List t1) -> State -> Prim (List t0 -> State -> List t1)

c_iterate :: Curry t0 => Prim (t0 -> State -> t0) -> t0 -> State -> List t0

c_repeat :: Curry t0 => t0 -> State -> List t0

c_replicate :: Curry t0 => C_Int -> t0 -> State -> List t0

c_take :: Curry t0 => C_Int -> List t0 -> State -> List t0

c_drop :: Curry t0 => C_Int -> List t0 -> State -> List t0

c_drop'46dropp'46272 :: Curry t0 => C_Int -> List t0 -> State -> List t0

c_splitAt :: Curry t0 => C_Int -> List t0 -> State -> T2 (List t0) (List t0)

c_splitAt'46splitAtp'46282 :: Curry t0 => C_Int -> List t0 -> State -> T2 (List t0) (List t0)

c_splitAt'46splitAtp'46282'46_'35selFP10'35ys :: Curry t576 => T2 (List t576) (List t576) -> State -> List t576

c_splitAt'46splitAtp'46282'46_'35selFP11'35zs :: Curry t576 => T2 (List t576) (List t576) -> State -> List t576

c_takeWhile :: Curry t0 => Prim (t0 -> State -> C_Bool) -> List t0 -> State -> List t0

c_dropWhile :: Curry t0 => Prim (t0 -> State -> C_Bool) -> List t0 -> State -> List t0

c_span :: Curry t0 => Prim (t0 -> State -> C_Bool) -> List t0 -> State -> T2 (List t0) (List t0)

c_span'46_'35selFP13'35ys :: Curry t627 => T2 (List t627) (List t627) -> State -> List t627

c_span'46_'35selFP14'35zs :: Curry t627 => T2 (List t627) (List t627) -> State -> List t627

c_break :: Curry t0 => Prim (t0 -> State -> C_Bool) -> State -> Prim (List t0 -> State -> T2 (List t0) (List t0))

c_lines :: List C_Char -> State -> List (List C_Char)

c_lines'46splitline'46314 :: List C_Char -> State -> T2 (List C_Char) (List C_Char)

c_lines'46splitline'46314'46_'35selFP16'35ds :: T2 (List C_Char) (List C_Char) -> State -> List C_Char

c_lines'46splitline'46314'46_'35selFP17'35es :: T2 (List C_Char) (List C_Char) -> State -> List C_Char

c_lines'46_'35selFP19'35l :: T2 (List C_Char) (List C_Char) -> State -> List C_Char

c_lines'46_'35selFP20'35xs_l :: T2 (List C_Char) (List C_Char) -> State -> List C_Char

c_unlines :: List (List C_Char) -> State -> List C_Char

c_words :: List C_Char -> State -> List (List C_Char)

c_words'46isSpace'46326 :: C_Char -> State -> C_Bool

c_words'46_'35selFP22'35w :: T2 (List C_Char) (List C_Char) -> State -> List C_Char

c_words'46_'35selFP23'35s2 :: T2 (List C_Char) (List C_Char) -> State -> List C_Char

c_unwords :: List (List C_Char) -> State -> List C_Char

c_unwords'46_'35lambda6 :: List C_Char -> List C_Char -> State -> List C_Char

c_reverse :: Curry t0 => State -> Prim (List t0 -> State -> List t0)

c_and :: State -> Prim (List C_Bool -> State -> C_Bool)

c_or :: State -> Prim (List C_Bool -> State -> C_Bool)

c_any :: Curry t0 => Prim (t0 -> State -> C_Bool) -> State -> Prim (List t0 -> State -> C_Bool)

c_all :: Curry t0 => Prim (t0 -> State -> C_Bool) -> State -> Prim (List t0 -> State -> C_Bool)

c_elem :: Curry t0 => t0 -> State -> Prim (List t0 -> State -> C_Bool)

c_notElem :: Curry t0 => t0 -> State -> Prim (List t0 -> State -> C_Bool)

c_lookup :: (Curry t0, Curry t1) => t0 -> List (T2 t0 t1) -> State -> C_Maybe t1

c_enumFrom :: C_Int -> State -> List C_Int

c_enumFromThen :: C_Int -> C_Int -> State -> List C_Int

c_enumFromTo :: C_Int -> C_Int -> State -> List C_Int

c_enumFromThenTo :: C_Int -> C_Int -> C_Int -> State -> List C_Int

c_enumFromThenTo'46p'46364 :: C_Int -> C_Int -> C_Int -> C_Int -> State -> C_Bool

c_ord :: C_Char -> State -> C_Int

c_chr :: C_Int -> State -> C_Char

c_succ :: C_Nat -> State -> C_Nat

op_43_94 :: C_Nat -> C_Nat -> State -> C_Nat

c_cmpNat :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNatLT :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNatGT :: C_Nat -> C_Nat -> State -> C_Ordering

op_60_94 :: C_Nat -> C_Nat -> State -> C_Bool

op_62_94 :: C_Nat -> C_Nat -> State -> C_Bool

op_60_61_94 :: C_Nat -> C_Nat -> State -> C_Bool

op_62_61_94 :: C_Nat -> C_Nat -> State -> C_Bool

op_42_94 :: C_Nat -> C_Nat -> State -> C_Nat

c_pred :: C_Nat -> State -> C_Nat

c_inc :: C_Int -> State -> C_Int

c_dec :: C_Int -> State -> C_Int

c_mult2 :: C_Int -> State -> C_Int

op_45_94 :: C_Nat -> C_Nat -> State -> C_Int

c_div2 :: C_Nat -> State -> C_Nat

c_mod2 :: C_Nat -> State -> C_Int

c_divmodNat :: C_Nat -> C_Nat -> State -> T2 C_Int C_Int

c_divmodNat'46shift'46523 :: C_Nat -> C_Nat -> State -> C_Nat

op_43 :: C_Int -> C_Int -> State -> C_Int

op_45 :: C_Int -> C_Int -> State -> C_Int

op_42 :: C_Int -> C_Int -> State -> C_Int

c_divmod :: C_Int -> C_Int -> State -> T2 C_Int C_Int

c_divmod'46_'35selFP25'35d :: T2 C_Int C_Int -> State -> C_Int

c_divmod'46_'35selFP26'35m :: T2 C_Int C_Int -> State -> C_Int

c_divmod'46_'35selFP28'35d :: T2 C_Int C_Int -> State -> C_Int

c_divmod'46_'35selFP29'35m :: T2 C_Int C_Int -> State -> C_Int

c_divmod'46_'35selFP31'35d :: T2 C_Int C_Int -> State -> C_Int

c_divmod'46_'35selFP32'35m :: T2 C_Int C_Int -> State -> C_Int

c_div :: C_Int -> C_Int -> State -> C_Int

c_mod :: C_Int -> C_Int -> State -> C_Int

c_negate :: C_Int -> State -> C_Int

c_negateFloat :: C_Float -> State -> C_Float

c_success :: State -> C_Success

op_61_58_61 :: Curry t0 => t0 -> t0 -> State -> C_Success

op_38_62 :: Curry t0 => C_Success -> t0 -> State -> t0

c_maybe :: (Curry t0, Curry t1) => t0 -> Prim (t1 -> State -> t0) -> C_Maybe t1 -> State -> t0

c_either :: (Curry t0, Curry t1, Curry t2) => Prim (t0 -> State -> t1) -> Prim (t2 -> State -> t1) -> C_Either t0 t2 -> State -> t1

op_62_62 :: (Curry t0, Curry t1) => C_IO t0 -> C_IO t1 -> State -> C_IO t1

c_done :: State -> C_IO T0

c_putChar :: C_Char -> State -> C_IO T0

c_readFile :: List C_Char -> State -> C_IO (List C_Char)

c_writeFile :: List C_Char -> List C_Char -> State -> C_IO T0

c_appendFile :: List C_Char -> List C_Char -> State -> C_IO T0

c_putStr :: List C_Char -> State -> C_IO T0

c_putStrLn :: List C_Char -> State -> C_IO T0

c_getLine :: State -> C_IO (List C_Char)

c_getLine'46_'35lambda10 :: C_Char -> State -> C_IO (List C_Char)

c_getLine'46_'35lambda10'46_'35lambda11 :: C_Char -> List C_Char -> State -> C_IO (List C_Char)

c_show :: Curry t0 => t0 -> State -> List C_Char

c_print :: Curry t0 => t0 -> State -> C_IO T0

c_doSolve :: C_Success -> State -> C_IO T0

c_sequenceIO :: Curry t0 => List (C_IO t0) -> State -> C_IO (List t0)

c_sequenceIO'46_'35lambda12 :: Curry t940 => List (C_IO t940) -> t940 -> State -> C_IO (List t940)

c_sequenceIO'46_'35lambda12'46_'35lambda13 :: Curry t940 => t940 -> List t940 -> State -> C_IO (List t940)

c_sequenceIO_ :: Curry t0 => State -> Prim (List (C_IO t0) -> State -> C_IO T0)

c_mapIO :: (Curry t0, Curry t1) => Prim (t0 -> State -> C_IO t1) -> State -> Prim (List t0 -> State -> C_IO (List t1))

c_mapIO_ :: (Curry t0, Curry t1) => Prim (t0 -> State -> C_IO t1) -> State -> Prim (List t0 -> State -> C_IO T0)

op_63 :: Curry t0 => t0 -> t0 -> State -> t0

c_allValuesD :: Curry t0 => C_SearchTree t0 -> State -> List t0

c_allValuesB :: Curry t0 => C_SearchTree t0 -> State -> List t0

c_allValuesB'46partition'46694 :: Curry t0 => C_SearchTree t0 -> T2 (List t0) (List (C_SearchTree t0)) -> State -> T2 (List t0) (List (C_SearchTree t0))

c_allValuesB'46partition'46694'46_'35selFP34'35vs :: Curry t1004 => T2 (List t1004) (List (C_SearchTree t1004)) -> State -> List t1004

c_allValuesB'46partition'46694'46_'35selFP35'35ors :: Curry t1004 => T2 (List t1004) (List (C_SearchTree t1004)) -> State -> List (C_SearchTree t1004)

c_allValuesB'46partition'46694'46_'35selFP37'35vs :: Curry t1004 => T2 (List t1004) (List (C_SearchTree t1004)) -> State -> List t1004

c_allValuesB'46partition'46694'46_'35selFP38'35ors :: Curry t1004 => T2 (List t1004) (List (C_SearchTree t1004)) -> State -> List (C_SearchTree t1004)

c_allValuesB'46unfoldOrs'46694 :: Curry t0 => List (C_SearchTree t0) -> State -> List t0

c_allValuesB'46unfoldOrs'46694'46_'35selFP40'35vals :: Curry t1017 => T2 (List t1017) (List (C_SearchTree t1017)) -> State -> List t1017

c_allValuesB'46unfoldOrs'46694'46_'35selFP41'35ors :: Curry t1017 => T2 (List t1017) (List (C_SearchTree t1017)) -> State -> List (C_SearchTree t1017)

c_inject :: Curry t0 => Prim (t0 -> State -> C_Success) -> Prim (t0 -> State -> C_Success) -> State -> Prim (t0 -> State -> C_Success)

c_inject'46_'35lambda14 :: Curry t1028 => Prim (t1028 -> State -> C_Success) -> Prim (t1028 -> State -> C_Success) -> t1028 -> State -> C_Success

c_PEVAL :: Curry t0 => t0 -> State -> t0

c_unknown :: Curry t0 => State -> t0

c_getLine'46_'35lambda10_case_0 :: C_Char -> C_Bool -> State -> C_IO (List C_Char)

c_'61'58'61_case_1 :: t -> t1 -> C_Bool -> State -> C_Success

c_divmod_case_2 :: C_Nat -> C_Int -> State -> T2 C_Int C_Int

c_divmod_case_3 :: C_Nat -> C_Int -> State -> T2 C_Int C_Int

c_'42_case_4 :: C_Nat -> C_Int -> State -> C_Int

c_'42_case_5 :: C_Nat -> C_Int -> State -> C_Int

c_'43_case_6 :: C_Int -> C_Nat -> C_Int -> State -> C_Int

c_'43_case_7 :: C_Int -> C_Nat -> C_Int -> State -> C_Int

c_divmodNat_case_14 :: C_Nat -> C_Nat -> C_Bool -> State -> T2 C_Int C_Int

c_divmodNat_case_13 :: C_Nat -> C_Nat -> C_Ordering -> State -> T2 C_Int C_Int

c_divmodNat_case_12 :: C_Nat -> C_Nat -> T2 C_Int C_Int -> State -> T2 C_Int C_Int

c_divmodNat_case_11 :: C_Nat -> C_Nat -> C_Int -> C_Int -> State -> T2 C_Int C_Int

c_divmodNat_case_10 :: C_Nat -> C_Nat -> C_Nat -> C_Int -> State -> T2 C_Int C_Int

c_divmodNat_case_9 :: BaseCurry t3 => t -> t1 -> C_Nat -> t2 -> T2 C_Int t3 -> State -> T2 C_Int t3

c_divmodNat_case_8 :: BaseCurry t1 => C_Nat -> t1 -> C_Int -> State -> T2 C_Int t1

c_'45'94_case_15 :: C_Nat -> C_Nat -> State -> C_Int

c_'45'94_case_16 :: C_Nat -> C_Nat -> State -> C_Int

c_dec_case_17 :: C_Nat -> State -> C_Int

c_inc_case_18 :: C_Nat -> State -> C_Int

c_pred_case_19 :: C_Nat -> State -> C_Nat

c_cmpNatGT_case_20 :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNatGT_case_21 :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNatLT_case_22 :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNatLT_case_23 :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNat_case_24 :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNat_case_25 :: C_Nat -> C_Nat -> State -> C_Ordering

c_cmpNat_case_26 :: C_Nat -> State -> C_Ordering

c_'43'94_case_27 :: C_Nat -> C_Nat -> State -> C_Nat

c_'43'94_case_28 :: C_Nat -> C_Nat -> State -> C_Nat

c_enumFromThenTo'46p'46364_case_29 :: C_Int -> t -> t1 -> C_Int -> C_Bool -> State -> C_Bool

c_enumFromTo_case_30 :: C_Int -> C_Int -> C_Bool -> State -> List C_Int

c_lookup_case_32 :: (Curry t1, Curry t0) => t1 -> List (T2 t1 t0) -> T2 t1 t0 -> State -> C_Maybe t0

c_lookup_case_31 :: (Curry t0, Curry t1) => t1 -> List (T2 t1 t0) -> t -> t0 -> C_Bool -> State -> C_Maybe t0

c_unwords_case_33 :: List (List C_Char) -> C_Bool -> State -> List C_Char

c_words_case_34 :: List C_Char -> C_Bool -> State -> List (List C_Char)

c_lines'46splitline'46314_case_35 :: C_Char -> List C_Char -> C_Bool -> State -> T2 (List C_Char) (List C_Char)

c_span_case_36 :: Curry t627 => Prim (t627 -> State -> C_Bool) -> t627 -> List t627 -> C_Bool -> State -> T2 (List t627) (List t627)

c_dropWhile_case_37 :: Curry t0 => Prim (t0 -> State -> C_Bool) -> t0 -> List t0 -> C_Bool -> State -> List t0

c_takeWhile_case_38 :: Curry t0 => Prim (t0 -> State -> C_Bool) -> t0 -> List t0 -> C_Bool -> State -> List t0

c_splitAt_case_39 :: Curry t0 => C_Int -> List t0 -> C_Bool -> State -> T2 (List t0) (List t0)

c_drop_case_40 :: Curry t0 => C_Int -> List t0 -> C_Bool -> State -> List t0

c_take_case_41 :: Curry t0 => C_Nat -> List t0 -> State -> List t0

c_unzip3_case_42 :: (Curry t0, Curry t494, Curry t493) => List (T3 t493 t494 t0) -> T3 t493 t494 t0 -> State -> T3 (List t493) (List t494) (List t0)

c_unzip_case_43 :: (Curry t0, Curry t476) => List (T2 t476 t0) -> T2 t476 t0 -> State -> T2 (List t476) (List t0)

c_zipWith3_case_45 :: (Curry t3, Curry t0, Curry t2, Curry t1) => Prim (t1 -> State -> Prim (t2 -> State -> Prim (t3 -> State -> t0))) -> List t3 -> t1 -> List t1 -> List t2 -> State -> List t0

c_zipWith3_case_44 :: (Curry t1, Curry t2, Curry t0, Curry t3) => Prim (t1 -> State -> Prim (t2 -> State -> Prim (t3 -> State -> t0))) -> t1 -> List t1 -> t2 -> List t2 -> List t3 -> State -> List t0

c_zipWith_case_46 :: (Curry t1, Curry t0, Curry t2) => Prim (t1 -> State -> Prim (t2 -> State -> t0)) -> t1 -> List t1 -> List t2 -> State -> List t0

c_zip3_case_48 :: (Curry t0, Curry t1, Curry t2) => List t2 -> t0 -> List t0 -> List t1 -> State -> List (T3 t0 t1 t2)

c_zip3_case_47 :: (Curry t2, Curry t1, Curry t0) => t0 -> List t0 -> t1 -> List t1 -> List t2 -> State -> List (T3 t0 t1 t2)

c_zip_case_49 :: (Curry t1, Curry t0) => t0 -> List t0 -> List t1 -> State -> List (T2 t0 t1)

c_filter_case_50 :: Curry t0 => Prim (t0 -> State -> C_Bool) -> t0 -> List t0 -> C_Bool -> State -> List t0

c_foldr1_case_51 :: Curry t0 => Prim (t0 -> State -> Prim (t0 -> State -> t0)) -> t0 -> List t0 -> State -> t0

c_'33'33_case_53 :: Curry t0 => C_Int -> t0 -> List t0 -> C_Bool -> State -> t0

c_'33'33_case_52 :: Curry t0 => C_Int -> List t0 -> C_Bool -> State -> t0

c_min_case_54 :: BaseCurry b => b -> b -> C_Ordering -> State -> b

c_max_case_55 :: BaseCurry b => b -> b -> C_Ordering -> State -> b

c_compare_case_56 :: C_Nat -> C_Int -> State -> C_Ordering

c_compare_case_57 :: C_Nat -> C_Int -> State -> C_Ordering

c_compare_case_58 :: C_Int -> State -> C_Ordering

c_until_case_59 :: Curry t0 => Prim (t0 -> State -> C_Bool) -> Prim (t0 -> State -> t0) -> t0 -> C_Bool -> State -> t0

op_36_33 :: (Curry t0, Curry t1) => Prim (t0 -> State -> t1) -> t0 -> State -> t1

op_36_33_33 :: (Curry t0, Curry t1) => Prim (t0 -> State -> t1) -> t0 -> State -> t1

op_36_35 :: (Curry t0, Curry t1) => Prim (t0 -> State -> t1) -> t0 -> State -> t1

op_36_35_35 :: (Curry t0, Curry t1) => Prim (t0 -> State -> t1) -> t0 -> State -> t1

c_prim_error :: Curry t0 => List C_Char -> State -> t0

c_failed :: Curry t0 => State -> t0

op_61_61 :: Curry t0 => t0 -> t0 -> State -> C_Bool

c_prim_ord :: C_Char -> State -> C_Int

c_prim_chr :: C_Int -> State -> C_Char

c_prim_negateFloat :: C_Float -> State -> C_Float

op_61_61_61 :: Curry t0 => t0 -> t0 -> State -> C_Bool

op_38 :: C_Success -> C_Success -> State -> C_Success

op_62_62_61 :: (Curry t0, Curry t1) => C_IO t0 -> Prim (t0 -> State -> C_IO t1) -> State -> C_IO t1

c_return :: Curry t0 => t0 -> State -> C_IO t0

c_prim_putChar :: C_Char -> State -> C_IO T0

c_getChar :: State -> C_IO C_Char

c_prim_readFile :: List C_Char -> State -> C_IO (List C_Char)

c_prim_writeFile :: List C_Char -> List C_Char -> State -> C_IO T0

c_prim_appendFile :: List C_Char -> List C_Char -> State -> C_IO T0

c_catchFail :: Curry t0 => C_IO t0 -> C_IO t0 -> State -> C_IO t0

c_prim_show :: Curry t0 => t0 -> State -> List C_Char

c_getSearchTree :: Curry t0 => t0 -> State -> C_IO (C_SearchTree t0)

c_apply :: (Curry t0, Curry t1) => Prim (t0 -> State -> t1) -> t0 -> State -> t1

c_cond :: Curry t0 => C_Success -> t0 -> State -> t0

op_61_58_60_61 :: Curry t0 => t0 -> t0 -> State -> C_Success