How to find out in Haskell functions of built-in functions?

Question

I am looking for a way to get all the Haskell prelude built-in namespaces.

something equivalent to what we can have in Python:

>>> 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. >>> 

This is not a question of “how to get information from the contents of the library,” as they say here: Is there a way to see a list of functions in a module in GHCI?

This is about the built-in, so about the language when you did not import libray.

I need to get a list of functions in pro program.hs not in the Prelude help system or in the Prelude termination system.

Answer 1

In GHCi, you can enter :browse Prelude to display everything exported by the Prelude module.

Exit the local 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) -> fa -> fb (=<<) :: Monad m => (a -> mb) -> ma -> mb class Functor f => Applicative (f :: * -> *) where pure :: a -> fa (<*>) :: f (a -> b) -> fa -> fb (*>) :: fa -> fb -> fb (<*) :: fa -> fb -> fa {-# 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 ab = 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 => tm -> m foldMap :: Monoid m => (a -> m) -> ta -> m foldr :: (a -> b -> b) -> b -> ta -> b Data.Foldable.foldr' :: (a -> b -> b) -> b -> ta -> b foldl :: (b -> a -> b) -> b -> ta -> b Data.Foldable.foldl' :: (b -> a -> b) -> b -> ta -> b foldr1 :: (a -> a -> a) -> ta -> a foldl1 :: (a -> a -> a) -> ta -> a Data.Foldable.toList :: ta -> [a] null :: ta -> Bool length :: ta -> Int elem :: Eq a => a -> ta -> Bool maximum :: Ord a => ta -> a minimum :: Ord a => ta -> a sum :: Num a => ta -> a product :: Num a => ta -> 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) -> fa -> fb (<$) :: a -> fb -> fa {-# 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 (>>=) :: ma -> (a -> mb) -> mb (>>) :: ma -> mb -> mb return :: a -> ma fail :: String -> ma {-# 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 -> fb) -> ta -> f (tb) sequenceA :: Applicative f => t (fa) -> f (ta) mapM :: Monad m => (a -> mb) -> ta -> m (tb) sequence :: Monad m => t (ma) -> m (ta) {-# 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) -> ta -> Bool and :: Foldable t => t Bool -> Bool any :: Foldable t => (a -> Bool) -> ta -> 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]) -> ta -> [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 ab -> 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 -> mb) -> ta -> m () maybe :: b -> (a -> b) -> Maybe a -> b not :: Bool -> Bool notElem :: (Foldable t, Eq a) => a -> ta -> 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 (ma) -> 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

As I will show in my answer to your question How do I find out what is the complete list of availlable functions in import? you can use ghc-mod.

Replace the line in the above answer

out <- run "ghc-mod" ["browse", "-d", "Data.List"]

from

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