diff --git a/MagicHaskeller.cabal b/MagicHaskeller.cabal --- a/MagicHaskeller.cabal +++ b/MagicHaskeller.cabal @@ -1,5 +1,5 @@ Name: MagicHaskeller -Version: 0.9.6.5 +Version: 0.9.6.6 Cabal-Version: >= 1.8 License: BSD3 License-file: LICENSE @@ -15,10 +15,9 @@ and the MagicHaskeller.cgi executable that is a CGI frontend for providing the Web interface. Build-Type: Simple Category: Language -data-files: ExperimIOP.hs MagicHaskeller/predicates MagicHaskeller/predicatesAug2014 MagicHaskeller.conf MagicHaskeller/predicatesServed +data-files: ExperimIOP.hs MagicHaskeller/predicates MagicHaskeller/predicatesAug2014 MagicHaskeller.conf MagicHaskeller/predicatesServed primitives.txt Extra-source-files: xlmap changelog.txt --- Tested-with: GHC == 6.12.1 -Tested-with: GHC == 7.4.1, GHC == 7.6.3, GHC == 7.8.4 +Tested-with: GHC == 7.6.3, GHC == 7.10.3 Flag TFRANDOM Description: Use the tf-random package instead of the random package @@ -47,7 +46,7 @@ Library Build-depends: time, template-haskell, base >= 4 && < 5, syb, containers, array, random, directory, bytestring, mtl, html, pretty, hashable Exposed-modules: MagicHaskeller, Control.Monad.Search.Combinatorial, Control.Monad.Search.Best, MagicHaskeller.ProgGen, MagicHaskeller.ProgGenSF, - MagicHaskeller.ProgGenSFIORef, MagicHaskeller.Expression, MagicHaskeller.LibTH, MagicHaskeller.Analytical, MagicHaskeller.Options, MagicHaskeller.Classification, MagicHaskeller.GetTime, MagicHaskeller.Minimal, MagicHaskeller.IOGenerator, MagicHaskeller.FastRatio, MagicHaskeller.LibExcel + MagicHaskeller.ProgGenSFIORef, MagicHaskeller.Expression, MagicHaskeller.LibTH, MagicHaskeller.Analytical, MagicHaskeller.Options, MagicHaskeller.Classification, MagicHaskeller.GetTime, MagicHaskeller.Minimal, MagicHaskeller.IOGenerator, MagicHaskeller.FastRatio, MagicHaskeller.LibExcel, MagicHaskeller.Individual Other-modules: MagicHaskeller.MemoToFiles, MagicHaskeller.ShortString, MagicHaskeller.Types, MagicHaskeller.PriorSubsts, Data.Memo, MagicHaskeller.ClassifyTr, MagicHaskeller.CoreLang, MagicHaskeller.DebMT, MagicHaskeller.TyConLib, @@ -88,7 +87,6 @@ Build-depends: MagicHaskeller, time, template-haskell, base >= 4 && < 5, syb, containers, array, random, directory, bytestring, mtl, html, pretty, hashable, process, monad-par, transformers, abstract-par, ghc-paths, ghc Other-modules: MagicHaskeller.SimpleServer GHC-options: -threaded -feager-blackholing -rtsopts - -- In my experience we should never use -O2 here --- it causes memory leak when compiled with GHC 7.6.3. Extensions: CPP, TemplateHaskell cpp-options: -DCHTO -DCABAL diff --git a/MagicHaskeller/CGI.lhs b/MagicHaskeller/CGI.lhs --- a/MagicHaskeller/CGI.lhs +++ b/MagicHaskeller/CGI.lhs @@ -99,7 +99,7 @@ " " ++ " " ++ "

" ++ configToTitle config ++ "

" ++ - "
(CGI frontend version " ++ verInfo ++ ")
" ++ + "
(CGI frontend version " ++ verInfo ++ ") (Identify the backend version)
" ++ " Specify a function f by writing a predicate as a boolean-valued expression. You will get functions generalizing the specification.
" ++ predicateBox (myPath config) "90" showAbsents predicate ++ (case computerLanguage config of diff --git a/MagicHaskeller/Individual.hs b/MagicHaskeller/Individual.hs new file mode 100644 --- /dev/null +++ b/MagicHaskeller/Individual.hs @@ -0,0 +1,101 @@ +-- +-- (c) Susumu Katayama +-- +{-# OPTIONS -XTemplateHaskell #-} +module MagicHaskeller.Individual(availableNames, prioritizedNamesToPg) where +import Language.Haskell.TH as TH +import qualified Data.Map as M +import qualified Data.IntMap as I +import Data.Char(isDigit) +import Data.List(findIndex, findIndices, mapAccumL, mapAccumR) +import Data.Generics +import MagicHaskeller.LibTH +import MagicHaskeller.Types(size) +import MagicHaskeller.ProgGenSF(mkTrieOptSFIO) +import Prelude hiding (tail) + +-- | 'totals' is the set of available values (except partial functions) that can be included/excluded individually. +totals :: [Primitive] +totals = concat withDoubleRatio +-- You can add functions you like here, e.g. +-- totals = concat withDoubleRatio ++ $(p [| nat_para :: (->) Int (a -> (Int -> a -> a) -> a) |] ) + +-- | 'partials' is the set of available partial functions that can be included/excluded individually. +partials :: [(Primitive,Primitive)] +partials = concat tupartialssNormal -- ++ .... + +-- | 'aliases' is the set of aliases that can be used instead of the exact names appearing in 'totals' in order to increase readability of primitive library files. Also, aliases can be used to group a set of primitives and enable at once. +aliases :: [(String, [Primitive])] +aliases = [ ("total init", $(p [| reverse . drop 1 . reverse :: [a] -> [a] |])), + ("total head", $(p [| foldr const :: a -> (->) [a] a |])), + ("total last", $(p [| last' :: a -> [a] -> a |])), + ("drop 1", $(p [| tail :: (->) [a] [a] |] )), + ("foldl", $(p [| flip . flip foldl :: a -> (->) [b] ((a -> b -> a) -> a) |])), + ("foldr", $(p [| flip . flip foldr :: a -> (->) [b] ((b -> a -> a) -> a) |])), + ("maybe", $(p [| flip . maybe :: a -> (->) (Maybe b) ((b -> a) -> a) |])), + ("map", $(p [| flip map :: (->) ([a]) ((a -> b) -> [b]) |])), + ("concatMap", $(p [| flip concatMap :: (->) ([a]) ((a -> [b]) -> [b]) |])), + ("any", $(p [| flip any :: (->) ([a]) ((a -> Bool) -> Bool) |])), + ("all", $(p [| flip all :: (->) ([a]) ((a -> Bool) -> Bool) |])), + ("zipWith", $(p [| flip . flip zipWith :: (->) ([a]) ((->) ([b]) ((a -> b -> c) -> [c])) |])), + ("either", $(p [| flip (flip . either) :: (->) (Either a b) ((a -> c) -> (b -> c) -> c) |])), + ("uncurry", $(p [| flip uncurry :: (->) ((a, b)) ((a -> b -> c) -> c) |])), + ("findIndex", $(p [| flip findIndex :: (->) ([a]) ((a -> Bool) -> Maybe Int) |])), + ("findIndices",$(p [| flip findIndices :: (->) ([a]) ((a -> Bool) -> [Int]) |])), + ("mapAccumL", $(p [| flip . flip mapAccumL :: acc -> (->) ([x]) ((acc -> x -> (acc, y)) -> (acc, [y])) |])), + ("mapAccumR", $(p [| flip . flip mapAccumR :: acc -> (->) ([x]) ((acc -> x -> (acc, y)) -> (acc, [y])) |])), + ("\\n x f -> iterate f x !! (n::Int)", $(p [| nat_cata :: (->) Int (a -> (a -> a) -> a) |])), + ("\\n x f -> iterate f x !! (n::Integer)", $(p [| nat_cata :: (->) Integer (a -> (a -> a) -> a) |])) + ] + +-- `normalizeSpaces' removes redundant spaces. +normalizeSpaces = unwords . words + +mapAvailables :: M.Map String (Either [Primitive] (Primitive,Primitive)) +mapAvailables = M.fromList assocAvailables +-- When dumping the available names, 'assocAvailables' is used instead of mapAvailables because I guess they should not be sorted +assocAvailables = [ (normalizeSpaces s, Left prims) | (s, prims) <- aliases ] ++ [ (pprintPrim prim, Left [prim]) | prim <- totals ] ++ [ (pprintPrim prim, Right tup) | tup@(_,prim) <- partials ] + +availableNames :: [String] +availableNames = map fst assocAvailables + +-- postprocess¤ò»È¤¤¤¿¤¯¤Ê¤ë¤±¤É¡¤·ë²ÌƱ¤¸É½¸½¤Ë¤Ê¤Ã¤Á¤ã¤¦¤È¤Þ¤º¤¤¡¥ +pprintPrim :: Primitive -> String +pprintPrim (_, e@(VarE name), t) = + case nameBase name of + ('b':'y':d:'_':name) | isDigit d -> name -- Note that the type is omitted, because the class information is lost. + ('-':'-':'#':name) -> '(':dropWhile (=='#') name ++")" -- Note that the type is omitted, because the class information is lost. + _ -> normalizeSpaces $ pprint $ TH.SigE (simplify e) t -- normalizeSpaces is inserted just in case. +pprintPrim (_, e, t) = normalizeSpaces $ pprint $ TH.SigE (simplify e) t -- normalizeSpaces is inserted just in case. + +simplify :: TH.Exp -> TH.Exp +simplify = everywhere (mkT simp) +simp (ConE name) = ConE $ mkName $ nameBase name +simp (VarE name) = VarE $ mkName $ nameBase name +-- We should be careful about removing flips, because that will change the type. +-- simp (AppE (ConE name) e) | nameBase name == "flip" = e +-- simp (AppE (AppE (ConE name1) (ConE name2)) e) | (nameBase name1, nameBase name2) == ("flip",".") = e +simp e = e + +namesToPrimitives :: [String] -> ([Primitive], [(Primitive,Primitive)]) +namesToPrimitives xss = let ets = map ((mapAvailables !!!) . normalizeSpaces) xss + in ([ prim | Left prims <- ets, prim <- prims], [ tup | Right tup <- ets]) + + +-- a !!! b = M.! +a !!! b = case M.lookup b a of Nothing -> error $ "!!! "++b + Just x -> x + + +namessToPrimitives :: [[String]] -> ([[Primitive]], [[(Primitive,Primitive)]]) +namessToPrimitives nss = unzip $ map namesToPrimitives nss +prioritizedNamesToNamess :: [(Int,String)] -> [[String]] +prioritizedNamesToNamess ts = let mapPriorName = I.fromListWith (++) [(i,[s]) | (i,s) <- ts] + in map (\i -> maybe [] id $ I.lookup i mapPriorName) [fst $ I.findMin mapPriorName .. fst $ I.findMax mapPriorName] + +prioritizedNamesToPg :: Maybe Int -> [(Int,String)] -> IO ProgGenSF +prioritizedNamesToPg Nothing ts = pNTP options ts +prioritizedNamesToPg (Just sz) ts = pNTP options{memoCondPure = \t d -> size t < sz && 0 IO ProgGenSF -mkPgExcels sz = mkPGXOpts mkTrieOptSFIO options{memoCondPure = \t d -> size t < sz && 0 size t < sz && 0) = (/=) diff --git a/MagicHaskeller/LibTH.hs b/MagicHaskeller/LibTH.hs --- a/MagicHaskeller/LibTH.hs +++ b/MagicHaskeller/LibTH.hs @@ -1,10 +1,6 @@ -- -- (c) Susumu Katayama -- --- This file is supposed to be used with Version 0.8.5 of MagicHaskeller. --- For previous versions, try: --- darcs get http://nautilus.cs.miyazaki-u.ac.jp/~skata/ somedirectoryname --- and retrieve an older version via some darcs command. {-# OPTIONS -XTemplateHaskell -XNoMonomorphismRestriction -cpp #-} module MagicHaskeller.LibTH(module MagicHaskeller.LibTH, module MagicHaskeller) where @@ -195,6 +191,10 @@ _ -> AppE v ppe "fromIntegral" -> case ppe of LitE i -> LitE i _ -> AppE v ppe + "exponent" -> case ppe of + LitE (IntegerL i) -> LitE $ IntegerL $ toInteger $ exponent $ fromIntegral i + LitE (RationalL r) -> LitE $ IntegerL $ toInteger $ exponent $ fromRational r + _ -> AppE v ppe "succ" -> case ppe of LitE (IntegerL i) -> LitE $ IntegerL $ succ i LitE (RationalL r) -> LitE $ RationalL $ succ r diff --git a/MagicHaskeller/SimpleServer.hs b/MagicHaskeller/SimpleServer.hs --- a/MagicHaskeller/SimpleServer.hs +++ b/MagicHaskeller/SimpleServer.hs @@ -4,6 +4,7 @@ import MagicHaskeller.LibTH import MagicHaskeller.LibExcel +import MagicHaskeller.Individual(availableNames, prioritizedNamesToPg) import GHC hiding (language) import HscTypes(HscEnv(hsc_IC), InteractiveContext(..)) @@ -77,7 +78,7 @@ data Flag = Port PortNumber | Socket FilePath | Interactive | RunPSCommand | JustTraining | Depth Int - | WithDoubleRatio | WithRatio | RatioOnly | WithDouble + | WithDoubleRatio | WithRatio | RatioOnly | WithDouble | Individual FilePath | WithAbsents | Default (Maybe String) | MemoSize (Maybe Int) @@ -85,6 +86,7 @@ | NoTraining | SequentialTraining FilePath | ParallelTraining FilePath | PostProcessor String | Excel + | DumpPrimitives cmdOpts :: [OptDescr Flag] cmdOpts = [ Option ['p'] ["port-number"] (ReqArg (Port . toEnum . readOrErr msgp) "PORT_NUMBER") "use port number PORT_NUMBER (default, using -p 55443)" @@ -96,10 +98,12 @@ "search depth (" ++ shows (depth defaultQO) "by default)" , Option ['q'] ["query-limit"] (OptArg (MemoSize . fmap (readOrErr msgd)) "QUERY_TYPE_SIZE_LIMIT") $ "only look up the memo entries when types with size less than this value are queried. Values for other types are recomputed every time. If no value is given (default), this means there is not limit and all entry types are looked up when queried. Setting this value does not affect the time for looking up already substantiated entries. However, setting it to about 8 dramatically reduces the heap space usage, while increasing the time for training." - , Option ['b'] ["with-double-ratio"] (NoArg WithDoubleRatio) "use the library with Double-related and (Ratio Int)-related functions. This requires more memory, but fractional numbers become available" - , Option ['w'] ["with-ratio"] (NoArg WithRatio) "use the library with (Ratio Int)-related functions. This requires more memory, but fractional numbers become available" - , Option [] ["ratio-only"] (NoArg RatioOnly) "use the library only including (Ratio Int)-related functions. This is introduced for debugging, but there may be other uses." - , Option ['2'] ["with-double"] (NoArg WithDouble) "use the library with Double-related functions. This requires more memory, but fractional numbers become available" + , Option ['b'] ["with-double-ratio"] (NoArg WithDoubleRatio) "use the library with Double-related and (Ratio Int)-related functions. This requires more memory, but fractional numbers become available. This overrides --individual, -w, --ratio-only, and -2." + , Option ['w'] ["with-ratio"] (NoArg WithRatio) "use the library with (Ratio Int)-related functions. This requires more memory, but fractional numbers become available. This overrides -b, --individual, --ratio-only, and -2." + , Option [] ["ratio-only"] (NoArg RatioOnly) "use the library only including (Ratio Int)-related functions. This is introduced for debugging, but there may be other uses. This overrides -b, -w, --individual, and -2." + , Option ['2'] ["with-double"] (NoArg WithDouble) "use the library with Double-related functions. This requires more memory, but fractional numbers become available. This overrides -b, -w, --ratio-only, and --individual." + , Option [] ["individual"] (ReqArg Individual "FILEPATH") "itemize library functions and their priorities in FILEPATH. This overrides -b, -w, --ratio-only, and -2. Note that only functions (and non-functions) appearing in the bundled primitives.txt can be used unless you hack the source." + , Option [] ["dump-primitives"] (NoArg DumpPrimitives) "dump a sample primitive file (to be used with --dump-primitives=...) to stdout and exit. The bundled primitives.txt is more user-friendly, but this option is useful if you hack the source and add some primitives." , Option ['a'] ["absents"] (NoArg WithAbsents) "generate functions with unused arguments in addition to other useful ones" #if __GLASGOW_HASKELL__ >= 706 , Option [] ["default"] (OptArg Default "DEFAULT_TYPES") "default declaration for type defaulting (--default='(Int,Integer,Double, Ratio Int, Char,(),String)' by default). The outermost parens can be omitted." @@ -133,9 +137,9 @@ data HowToServe = Network PortID | STDIO | PS | NoService data Format = DefaultFormat | ForceHTML | ForcePlain deriving Eq -data FunctionSet = PGFull | PGWithDoubleRatio | PGWithRatio | PGRatio | PGWithDouble | PGExcel -data ServerOptions = SO {howToServe :: HowToServe, queryOptions :: QueryOptions, functionSet :: FunctionSet, memoSize :: Maybe Int, defaultTypes :: Maybe String, format :: Format, sequentialTraining :: Maybe FilePath, parallelTraining :: Maybe FilePath, postprocessor :: String, language :: Language} -defaultSO = SO {howToServe = Network portID, queryOptions = defaultQO, functionSet = PGFull, memoSize = Nothing, defaultTypes = Just defaultDefault, format = DefaultFormat, sequentialTraining = Nothing, parallelTraining = Just trainers, postprocessor = "postprocess", language = LHaskell} +data FunctionSet = PGFull | PGWithDoubleRatio | PGWithRatio | PGRatio | PGWithDouble | PGExcel | PGIndividual FilePath +data ServerOptions = SO {howToServe :: HowToServe, queryOptions :: QueryOptions, functionSet :: FunctionSet, memoSize :: Maybe Int, defaultTypes :: Maybe String, format :: Format, sequentialTraining :: Maybe FilePath, parallelTraining :: Maybe FilePath, postprocessor :: String, language :: Language, dumpPrimitives :: Bool} +defaultSO = SO {howToServe = Network portID, queryOptions = defaultQO, functionSet = PGFull, memoSize = Nothing, defaultTypes = Just defaultDefault, format = DefaultFormat, sequentialTraining = Nothing, parallelTraining = Just trainers, postprocessor = "postprocess", language = LHaskell, dumpPrimitives = False} procFlags :: [Flag] -> ServerOptions procFlags = foldl procFlag defaultSO @@ -153,6 +157,7 @@ procFlag st WithRatio = st{functionSet = PGWithRatio} procFlag st RatioOnly = st{functionSet = PGRatio} procFlag st WithDouble = st{functionSet = PGWithDouble} +procFlag st (Individual file) = st{functionSet = PGIndividual file} procFlag st WithAbsents = st{queryOptions = (queryOptions st){absents = True}} #if __GLASGOW_HASKELL__ >= 706 procFlag st (Default ms) = st{defaultTypes = ms} @@ -167,11 +172,17 @@ procFlag st (SequentialTraining fp) = st{sequentialTraining = Just fp} procFlag st (ParallelTraining fp) = st{parallelTraining = Just fp} procFlag st (PostProcessor pp) = st{postprocessor = pp} +procFlag st DumpPrimitives = st{dumpPrimitives = True} main' :: String -> IO () main' versionString = do - (flags,args) <- readOpts + (flags, _args) <- readOpts let so = procFlags flags + if dumpPrimitives so then dump else main'' versionString so + +dump = putStrLn $ unlines $ "## Lines starting with # will be ignored, so you can exclude individual functions by commenting them out. The number at the beginning of each line represents the priority, where 0 means the most prioritized." : map ("0 "++) availableNames + +main'' versionString so = do hPutStrLn stderr versionString qhandle <- openFile queryOut AppendMode beginCT <- getCurrentTime @@ -190,6 +201,8 @@ (PGWithDouble, Just sz) -> return $ pgWithDoubles !! sz (PGExcel, Nothing) -> liftIO mkPgExcel (PGExcel, Just sz) -> liftIO $ mkPgExcels sz + (PGIndividual file, mb) -> do cs <- readFile file + prioritizedNamesToPg mb $ map parsePrioritizedName $ filter ((/='#').head) $ filter (not.null) $ lines cs hscEnv <- prepareGHCAPI ["MagicHaskeller.Minimal","MagicHaskeller.FastRatio"] -- (Fast)Ratio must be here if Ratio is referred by the default declaration. #if __GLASGOW_HASKELL__ >= 706 @@ -220,6 +233,10 @@ system $ "ps u -C "++pgn return () -- stopGlobalPool NoService -> return () -- stopGlobalPool + +parsePrioritizedName :: String -> (Int,String) +parsePrioritizedName str = case reads str of [] -> error "error while parsing the primitives file." + [(i,s)] -> (i, dropWhile isSpace s) #if __GLASGOW_HASKELL__ >= 706 declareDefaults hscEnv str diff --git a/changelog.txt b/changelog.txt --- a/changelog.txt +++ b/changelog.txt @@ -1,3 +1,6 @@ +0.9.6.6: + * enable selecting functions individually + 0.9.6.5: * Fix some bugs in CGI. Now you do not need to use GHC 7.4 even for building the CGI. diff --git a/primitives.txt b/primitives.txt new file mode 100644 --- /dev/null +++ b/primitives.txt @@ -0,0 +1,205 @@ +## Lines starting with # will be ignored, so you can exclude individual functions by commenting them out. The number at the beginning of each line represents the priority, where 0 means the most prioritized. +0 1 :: Ratio Int +0 10 :: Ratio Int +0 100 :: Ratio Int +0 1000 :: Ratio Int +0 succ :: Ratio Int -> Ratio Int +0 negate :: Ratio Int -> Ratio Int +0 abs :: Ratio Int -> Ratio Int +0 sum :: (->) ([Ratio Int]) (Ratio Int) +0 product :: (->) ([Ratio Int]) (Ratio Int) +0 (+) :: Ratio Int -> Ratio Int -> Ratio Int +0 (-) :: Ratio Int -> Ratio Int -> Ratio Int +0 (*) :: Ratio Int -> Ratio Int -> Ratio Int +0 (/) :: Ratio Int -> Ratio Int -> Ratio Int +0 fromIntegral :: Int -> Ratio Int +0 properFraction :: (->) (Ratio Int) ((Int, Ratio Int)) +0 round :: (->) (Ratio Int) Int +0 floor :: (->) (Ratio Int) Int +0 ceiling :: (->) (Ratio Int) Int +0 (^^) :: Ratio Int -> Int -> Ratio Int +0 (%) :: Int -> Int -> Ratio Int +0 numerator :: (->) (Ratio Int) Int +0 denominator :: (->) (Ratio Int) Int +0 [] :: forall a . [a] +0 (:) :: forall a . a -> [a] -> [a] +0 foldr +0 drop 1 +0 0 :: Int +0 (1 +) :: Int -> Int +0 \n x f -> iterate f x !! (n::Int) +0 Nothing :: forall a . Maybe a +0 Just :: forall a . a -> Maybe a +0 maybe +0 True :: Bool +0 False :: Bool +0 iF :: forall a . (->) Bool (a -> a -> a) +0 (+) :: (->) Int ((->) Int Int) +0 (&&) :: (->) Bool ((->) Bool Bool) +0 (||) :: (->) Bool ((->) Bool Bool) +0 not :: (->) Bool Bool +0 (-) :: Int -> Int -> Int +0 (*) :: Int -> Int -> Int +0 map +0 (++) :: forall a . (->) ([a]) ([a] -> [a]) +0 filter :: forall a . (a -> Bool) -> [a] -> [a] +0 concat :: forall a . (->) ([[a]]) ([a]) +0 concatMap +0 length :: forall a . (->) ([a]) Int +0 replicate :: forall a . Int -> a -> [a] +0 take :: forall a . Int -> [a] -> [a] +0 drop :: forall a . Int -> [a] -> [a] +0 takeWhile :: forall a . (a -> Bool) -> [a] -> [a] +0 dropWhile :: forall a . (a -> Bool) -> [a] -> [a] +0 reverse :: forall a . [a] -> [a] +0 and :: (->) ([Bool]) Bool +0 or :: (->) ([Bool]) Bool +0 any +0 all +0 zipWith +0 null :: forall a . (->) ([a]) Bool +0 abs :: (->) Int Int +0 foldl +0 total head +0 total last +0 total init +0 enumFromTo :: Int -> Int -> [Int] +0 enumFromTo :: Char -> Char -> [Char] +0 fmap :: forall a b . (a -> b) -> (->) (Maybe a) (Maybe b) +0 either +0 gcd :: Int -> Int -> Int +0 lcm :: Int -> Int -> Int +0 sum :: (->) ([Int]) Int +0 product :: (->) ([Int]) Int +0 (==) +0 (/=) +0 compare +0 (<=) +0 (<) +0 max +0 min +0 sortBy :: forall a . (a -> a -> Ordering) -> [a] -> [a] +0 nubBy :: forall a . (a -> a -> Bool) -> [a] -> [a] +0 deleteBy :: forall a . (a -> a -> Bool) -> a -> [a] -> [a] +0 dropWhileEnd :: forall a . (a -> Bool) -> [a] -> [a] +0 transpose :: forall a . [[a]] -> [[a]] +0 toUpper :: (->) Char Char +0 toLower :: (->) Char Char +0 ord :: Char -> Int +0 isControl :: (->) Char Bool +0 isSpace :: (->) Char Bool +0 isLower :: (->) Char Bool +0 isUpper :: (->) Char Bool +0 isAlpha :: (->) Char Bool +0 isAlphaNum :: (->) Char Bool +0 isDigit :: (->) Char Bool +0 isSymbol :: (->) Char Bool +0 isPunctuation :: (->) Char Bool +0 isPrint :: (->) Char Bool +0 1 :: Int +0 2 :: Int +0 3 :: Int +0 ' ' :: Char +0 1 :: Double +0 10 :: Double +0 100 :: Double +0 1000 :: Double +0 succ :: Double -> Double +0 negate :: Double -> Double +0 abs :: Double -> Double +0 signum :: Double -> Double +0 recip :: Double -> Double +0 sum :: (->) ([Double]) Double +0 product :: (->) ([Double]) Double +0 (+) :: Double -> Double -> Double +0 (-) :: Double -> Double -> Double +0 (*) :: Double -> Double -> Double +0 (/) :: Double -> Double -> Double +0 fromIntegral :: Int -> Double +0 properFraction :: (->) Double ((Int, Double)) +0 round :: (->) Double Int +0 floor :: (->) Double Int +0 ceiling :: (->) Double Int +0 truncate :: (->) Double Int +0 (^^) :: Double -> Int -> Double +0 pi :: Double +1 lines :: [Char] -> [[Char]] +1 words :: [Char] -> [[Char]] +1 unlines :: [[Char]] -> [Char] +1 unwords :: [[Char]] -> [Char] +1 scanl :: forall a b . (a -> b -> a) -> a -> [b] -> [a] +1 scanr :: forall a b . (a -> b -> b) -> b -> [a] -> [b] +1 scanl1 :: forall a . (a -> a -> a) -> [a] -> [a] +1 scanr1 :: forall a . (a -> a -> a) -> [a] -> [a] +1 show :: Int -> [Char] +1 (,) :: forall a b . a -> b -> (a, b) +1 uncurry +1 elem +1 group +1 nub +1 find :: forall a . (a -> Bool) -> [a] -> Maybe a +1 findIndex +1 findIndices +1 deleteFirstsBy :: forall a . (a -> a -> Bool) -> [a] -> [a] -> [a] +1 unionBy :: forall a . (a -> a -> Bool) -> (->) ([a]) ([a] -> [a]) +1 intersectBy :: forall a . (a -> a -> Bool) -> (->) ([a]) ([a] -> [a]) +1 groupBy :: forall a . (a -> a -> Bool) -> [a] -> [[a]] +1 insertBy :: forall a . (a -> a -> Ordering) -> a -> [a] -> [a] +1 isOctDigit :: (->) Char Bool +1 isHexDigit :: (->) Char Bool +1 catMaybes :: forall a . [Maybe a] -> [a] +1 listToMaybe :: forall a . (->) ([a]) (Maybe a) +1 maybeToList :: forall a . (->) (Maybe a) ([a]) +1 exp :: Double -> Double +1 log :: Double -> Double +1 sqrt :: Double -> Double +1 (**) :: Double -> Double -> Double +1 logBase :: Double -> Double -> Double +1 sin :: Double -> Double +1 cos :: Double -> Double +1 tan :: Double -> Double +1 asin :: Double -> Double +1 acos :: Double -> Double +1 atan :: Double -> Double +1 sinh :: Double -> Double +1 cosh :: Double -> Double +1 tanh :: Double -> Double +1 asinh :: Double -> Double +1 acosh :: Double -> Double +1 atanh :: Double -> Double +1 floatDigits :: Double -> Int +1 exponent :: Double -> Int +1 significand :: Double -> Double +1 scaleFloat :: Int -> Double -> Double +1 atan2 :: Double -> Double -> Double +2 (,,) :: forall a b c . a -> b -> c -> (a, b, c) +2 Left :: forall a b . a -> Either a b +2 Right :: forall b a . b -> Either a b +2 zip :: forall a b . (->) ([a]) ((->) ([b]) ([(a, b)])) +2 zip3 :: forall a b c . (->) ([a]) ((->) ([b]) ((->) ([c]) ([(a, b, c)]))) +2 unzip :: forall a b . (->) ([(a, b)]) (([a], [b])) +2 unzip3 :: forall a b c . (->) ([(a, b, c)]) (([a], [b], [c])) +2 odd :: Int -> Bool +2 even :: Int -> Bool +2 isPrefixOf +2 isSuffixOf +2 isInfixOf +2 stripPrefix +2 lookup +2 sort +2 intersperse :: forall a . a -> [a] -> [a] +2 subsequences :: forall a . [a] -> [[a]] +2 permutations :: forall a . [a] -> [[a]] +2 inits :: forall a . [a] -> [[a]] +2 tails :: forall a . [a] -> [[a]] +2 mapAccumL +2 mapAccumR +### partial functions +1 chr . abs :: Int -> Char +1 succ :: Char -> Char +2 div :: Int -> Int -> Int +2 mod :: Int -> Int -> Int +2 (^) :: Int -> Int -> Int +2 enumFromThenTo :: Int -> Int -> Int -> [Int] +2 enumFromThenTo :: Char -> Char -> Char -> [Char] +2 pred :: Char -> Char