wie in Haskell die eingebauten Funktionen zu wissen?

Question

Ich suche nach einem Weg, um alle eingebauten Namespace von Präludium Haskell zu bekommen.

etwas Gleichwertiges zu dem, was wir in Python tut dies ::

>>> print([func for func in dir(__builtins__) if func[0].islower()]) 
['abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 
'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 
'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 
'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip'] 
>>> print(len.__doc__) 
Return the number of items in a container. 
>>> 

Dies ist keine Frage „wie man Informationen aus einer Bibliothek Inhalt“, wie sie hier reden können: Is there a way to see the list of functions in a module, in GHCI?

Es geht um eingebaute, also um die Sprache, wenn Sie keine Bibliothek importieren.

Ich brauche die Liste der Funktionen in einem Pro program.hs nicht in Prelude Hilfesystem oder in Prelude Komplettierung System.

Answer 1

In GHCi können Sie eingeben, um alles aufzulisten, das vom Modul Prelude exportiert wurde.

Ausgabe von meinem lokalen Installation:

Prelude> :browse Prelude 
(!!) :: [a] -> Int -> a 
($) :: 
    forall (r :: GHC.Types.RuntimeRep) a (b :: TYPE r). 
    (a -> b) -> a -> b 
($!) :: (a -> b) -> a -> b 
(&&) :: Bool -> Bool -> Bool 
(++) :: [a] -> [a] -> [a] 
(.) :: (b -> c) -> (a -> b) -> a -> c 
(<$>) :: Functor f => (a -> b) -> f a -> f b 
(=<<) :: Monad m => (a -> m b) -> m a -> m b 
class Functor f => Applicative (f :: * -> *) where 
    pure :: a -> f a 
    (<*>) :: f (a -> b) -> f a -> f b 
    (*>) :: f a -> f b -> f b 
    (<*) :: f a -> f b -> f a 
    {-# MINIMAL pure, (<*>) #-} 
data Bool = False | True 
class Bounded a where 
    minBound :: a 
    maxBound :: a 
    {-# MINIMAL minBound, maxBound #-} 
data Char = GHC.Types.C# GHC.Prim.Char# 
data Double = GHC.Types.D# GHC.Prim.Double# 
data Either a b = Left a | Right b 
class Enum a where 
    succ :: a -> a 
    pred :: a -> a 
    toEnum :: Int -> a 
    fromEnum :: a -> Int 
    enumFrom :: a -> [a] 
    enumFromThen :: a -> a -> [a] 
    enumFromTo :: a -> a -> [a] 
    enumFromThenTo :: a -> a -> a -> [a] 
    {-# MINIMAL toEnum, fromEnum #-} 
class Eq a where 
    (==) :: a -> a -> Bool 
    (/=) :: a -> a -> Bool 
    {-# MINIMAL (==) | (/=) #-} 
type FilePath = String 
data Float = GHC.Types.F# GHC.Prim.Float# 
class Fractional a => Floating a where 
    pi :: a 
    exp :: a -> a 
    log :: a -> a 
    sqrt :: a -> a 
    (**) :: a -> a -> a 
    logBase :: a -> a -> a 
    sin :: a -> a 
    cos :: a -> a 
    tan :: a -> a 
    asin :: a -> a 
    acos :: a -> a 
    atan :: a -> a 
    sinh :: a -> a 
    cosh :: a -> a 
    tanh :: a -> a 
    asinh :: a -> a 
    acosh :: a -> a 
    atanh :: a -> a 
    GHC.Float.log1p :: a -> a 
    GHC.Float.expm1 :: a -> a 
    GHC.Float.log1pexp :: a -> a 
    GHC.Float.log1mexp :: a -> a 
    {-# MINIMAL pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, 
       asinh, acosh, atanh #-} 
class Foldable (t :: * -> *) where 
    Data.Foldable.fold :: Monoid m => t m -> m 
    foldMap :: Monoid m => (a -> m) -> t a -> m 
    foldr :: (a -> b -> b) -> b -> t a -> b 
    Data.Foldable.foldr' :: (a -> b -> b) -> b -> t a -> b 
    foldl :: (b -> a -> b) -> b -> t a -> b 
    Data.Foldable.foldl' :: (b -> a -> b) -> b -> t a -> b 
    foldr1 :: (a -> a -> a) -> t a -> a 
    foldl1 :: (a -> a -> a) -> t a -> a 
    Data.Foldable.toList :: t a -> [a] 
    null :: t a -> Bool 
    length :: t a -> Int 
    elem :: Eq a => a -> t a -> Bool 
    maximum :: Ord a => t a -> a 
    minimum :: Ord a => t a -> a 
    sum :: Num a => t a -> a 
    product :: Num a => t a -> a 
    {-# MINIMAL foldMap | foldr #-} 
class Num a => Fractional a where 
    (/) :: a -> a -> a 
    recip :: a -> a 
    fromRational :: Rational -> a 
    {-# MINIMAL fromRational, (recip | (/)) #-} 
class Functor (f :: * -> *) where 
    fmap :: (a -> b) -> f a -> f b 
    (<$) :: a -> f b -> f a 
    {-# MINIMAL fmap #-} 
newtype IO a 
    = GHC.Types.IO (GHC.Prim.State# GHC.Prim.RealWorld 
        -> (# GHC.Prim.State# GHC.Prim.RealWorld, a #)) 
type IOError = GHC.IO.Exception.IOException 
data Int = GHC.Types.I# GHC.Prim.Int# 
data Integer 
    = integer-gmp-1.0.0.1:GHC.Integer.Type.S# !GHC.Prim.Int# 
    | integer-gmp-1.0.0.1:GHC.Integer.Type.Jp# {-# UNPACK #-}integer-gmp-1.0.0.1:GHC.Integer.Type.BigNat 
    | integer-gmp-1.0.0.1:GHC.Integer.Type.Jn# {-# UNPACK #-}integer-gmp-1.0.0.1:GHC.Integer.Type.BigNat 
class (Real a, Enum a) => Integral a where 
    quot :: a -> a -> a 
    rem :: a -> a -> a 
    div :: a -> a -> a 
    mod :: a -> a -> a 
    quotRem :: a -> a -> (a, a) 
    divMod :: a -> a -> (a, a) 
    toInteger :: a -> Integer 
    {-# MINIMAL quotRem, toInteger #-} 
data Maybe a = Nothing | Just a 
class Applicative m => Monad (m :: * -> *) where 
    (>>=) :: m a -> (a -> m b) -> m b 
    (>>) :: m a -> m b -> m b 
    return :: a -> m a 
    fail :: String -> m a 
    {-# MINIMAL (>>=) #-} 
class Monoid a where 
    mempty :: a 
    mappend :: a -> a -> a 
    mconcat :: [a] -> a 
    {-# MINIMAL mempty, mappend #-} 
class Num a where 
    (+) :: a -> a -> a 
    (-) :: a -> a -> a 
    (*) :: a -> a -> a 
    negate :: a -> a 
    abs :: a -> a 
    signum :: a -> a 
    fromInteger :: Integer -> a 
    {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-} 
class Eq a => Ord a where 
    compare :: a -> a -> Ordering 
    (<) :: a -> a -> Bool 
    (<=) :: a -> a -> Bool 
    (>) :: a -> a -> Bool 
    (>=) :: a -> a -> Bool 
    max :: a -> a -> a 
    min :: a -> a -> a 
    {-# MINIMAL compare | (<=) #-} 
data Ordering = LT | EQ | GT 
type Rational = GHC.Real.Ratio Integer 
class Read a where 
    readsPrec :: Int -> ReadS a 
    readList :: ReadS [a] 
    GHC.Read.readPrec :: Text.ParserCombinators.ReadPrec.ReadPrec a 
    GHC.Read.readListPrec :: Text.ParserCombinators.ReadPrec.ReadPrec 
          [a] 
    {-# MINIMAL readsPrec | readPreC#-} 
type ReadS a = String -> [(a, String)] 
class (Num a, Ord a) => Real a where 
    toRational :: a -> Rational 
    {-# MINIMAL toRational #-} 
class (RealFrac a, Floating a) => RealFloat a where 
    floatRadix :: a -> Integer 
    floatDigits :: a -> Int 
    floatRange :: a -> (Int, Int) 
    decodeFloat :: a -> (Integer, Int) 
    encodeFloat :: Integer -> Int -> a 
    exponent :: a -> Int 
    significand :: a -> a 
    scaleFloat :: Int -> a -> a 
    isNaN :: a -> Bool 
    isInfinite :: a -> Bool 
    isDenormalized :: a -> Bool 
    isNegativeZero :: a -> Bool 
    isIEEE :: a -> Bool 
    atan2 :: a -> a -> a 
    {-# MINIMAL floatRadix, floatDigits, floatRange, decodeFloat, 
       encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, 
       isIEEE #-} 
class (Real a, Fractional a) => RealFrac a where 
    properFraction :: Integral b => a -> (b, a) 
    truncate :: Integral b => a -> b 
    round :: Integral b => a -> b 
    ceiling :: Integral b => a -> b 
    floor :: Integral b => a -> b 
    {-# MINIMAL properFraction #-} 
class Show a where 
    showsPrec :: Int -> a -> ShowS 
    show :: a -> String 
    showList :: [a] -> ShowS 
    {-# MINIMAL showsPrec | show #-} 
type ShowS = String -> String 
type String = [Char] 
class (Functor t, Foldable t) => Traversable (t :: * -> *) where 
    traverse :: Applicative f => (a -> f b) -> t a -> f (t b) 
    sequenceA :: Applicative f => t (f a) -> f (t a) 
    mapM :: Monad m => (a -> m b) -> t a -> m (t b) 
    sequence :: Monad m => t (m a) -> m (t a) 
    {-# MINIMAL traverse | sequenceA #-} 
data Word = GHC.Types.W# GHC.Prim.Word# 
(^) :: (Num a, Integral b) => a -> b -> a 
(^^) :: (Fractional a, Integral b) => a -> b -> a 
all :: Foldable t => (a -> Bool) -> t a -> Bool 
and :: Foldable t => t Bool -> Bool 
any :: Foldable t => (a -> Bool) -> t a -> Bool 
appendFile :: FilePath -> String -> IO() 
asTypeOf :: a -> a -> a 
break :: (a -> Bool) -> [a] -> ([a], [a]) 
concat :: Foldable t => t [a] -> [a] 
concatMap :: Foldable t => (a -> [b]) -> t a -> [b] 
const :: a -> b -> a 
curry :: ((a, b) -> c) -> a -> b -> c 
cycle :: [a] -> [a] 
drop :: Int -> [a] -> [a] 
dropWhile :: (a -> Bool) -> [a] -> [a] 
either :: (a -> c) -> (b -> c) -> Either a b -> c 
error :: 
    forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). 
    GHC.Stack.Types.HasCallStack => 
    [Char] -> a 
errorWithoutStackTrace :: 
    forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). [Char] -> a 
even :: Integral a => a -> Bool 
filter :: (a -> Bool) -> [a] -> [a] 
flip :: (a -> b -> c) -> b -> a -> c 
fromIntegral :: (Integral a, Num b) => a -> b 
fst :: (a, b) -> a 
gcd :: Integral a => a -> a -> a 
getChar :: IO Char 
getContents :: IO String 
getLine :: IO String 
head :: [a] -> a 
id :: a -> a 
init :: [a] -> [a] 
interact :: (String -> String) -> IO() 
ioError :: IOError -> IO a 
iterate :: (a -> a) -> a -> [a] 
last :: [a] -> a 
lcm :: Integral a => a -> a -> a 
lex :: ReadS String 
lines :: String -> [String] 
lookup :: Eq a => a -> [(a, b)] -> Maybe b 
map :: (a -> b) -> [a] -> [b] 
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m() 
maybe :: b -> (a -> b) -> Maybe a -> b 
not :: Bool -> Bool 
notElem :: (Foldable t, Eq a) => a -> t a -> Bool 
odd :: Integral a => a -> Bool 
or :: Foldable t => t Bool -> Bool 
otherwise :: Bool 
print :: Show a => a -> IO() 
putChar :: Char -> IO() 
putStr :: String -> IO() 
putStrLn :: String -> IO() 
read :: Read a => String -> a 
readFile :: FilePath -> IO String 
readIO :: Read a => String -> IO a 
readLn :: Read a => IO a 
readParen :: Bool -> ReadS a -> ReadS a 
reads :: Read a => ReadS a 
realToFrac :: (Real a, Fractional b) => a -> b 
repeat :: a -> [a] 
replicate :: Int -> a -> [a] 
reverse :: [a] -> [a] 
scanl :: (b -> a -> b) -> b -> [a] -> [b] 
scanl1 :: (a -> a -> a) -> [a] -> [a] 
scanr :: (a -> b -> b) -> b -> [a] -> [b] 
scanr1 :: (a -> a -> a) -> [a] -> [a] 
seq :: a -> b -> b 
sequence_ :: (Foldable t, Monad m) => t (m a) -> m() 
showChar :: Char -> ShowS 
showParen :: Bool -> ShowS -> ShowS 
showString :: String -> ShowS 
shows :: Show a => a -> ShowS 
snd :: (a, b) -> b 
span :: (a -> Bool) -> [a] -> ([a], [a]) 
splitAt :: Int -> [a] -> ([a], [a]) 
subtract :: Num a => a -> a -> a 
tail :: [a] -> [a] 
take :: Int -> [a] -> [a] 
takeWhile :: (a -> Bool) -> [a] -> [a] 
uncurry :: (a -> b -> c) -> (a, b) -> c 
undefined :: 
    forall (r :: GHC.Types.RuntimeRep) (a :: TYPE r). 
    GHC.Stack.Types.HasCallStack => 
    a 
unlines :: [String] -> String 
until :: (a -> Bool) -> (a -> a) -> a -> a 
unwords :: [String] -> String 
unzip :: [(a, b)] -> ([a], [b]) 
unzip3 :: [(a, b, c)] -> ([a], [b], [c]) 
userError :: String -> IOError 
words :: String -> [String] 
writeFile :: FilePath -> String -> IO() 
zip :: [a] -> [b] -> [(a, b)] 
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] 
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] 
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] 
(||) :: Bool -> Bool -> Bool 

Answer 2

Wie ich in meiner Antwort auf Ihre Frage zeigen How to know what are the full list of function availlable in an import? Sie ghc-mod verwenden können.

in der oben genannten Antwort Ersetzen Sie die Zeile

aus < - run "ghc-mod" [ "Durchsuchen", "-d", "Data.List"]

mit

out <- run "ghc-mod" ["browse", "-d", "Prelude"]