allFunctionNames.txt

Endo :: (a -> a) -> Endo a
Just :: a -> Maybe a
Left :: a -> Either a b
Node :: a -> [Tree a] -> Tree a
Nothing :: Maybe a
Ratio :: Integral a => a -> a -> Ratio a
Right :: b -> Either a b
Tuple (,) :: a -> b -> (a, b)
Tuple3 (,,) :: a -> b -> c -> (a, b, c)
TupleN :: a -> b ...  -> (a, b ... )
ZipList :: a -> {getZipList :: [a]}
abs :: Num -> Num
add (+) :: Num a => a -> a -> a
adjust :: (a -> a) -> Key -> Dict Key a -> Dict Key a
alert :: String => String -> IO String
all :: (a -> Bool) -> [a] -> Bool
allSame :: [a] -> Bool
allTree :: (a -> Bool) -> Tree a -> Bool
and :: [Bool] -> Bool
any :: (a -> Bool) -> [a] -> Bool
anyTree :: (a -> Bool) -> Tree a -> Bool
ap (<*>) :: Monad m => m (a -> b) -> m a -> m b
apFn :: (a -> b -> c) -> (a -> b) -> (a -> c)
apLR (<*>) :: Either e (a -> b) -> Either e a -> Either e b
apList (<*>) :: [(a -> b)] -> [a] -> [b]
apMay (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b
apTree (<*>) :: Tree (a -> b) -> Tree a -> Tree b
apTuple (<*>) :: Monoid m => (m, (a -> b)) -> (m, a) -> (m, b)
apZL (<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b
apZip :: [(a -> b)] -> [a] -> [b]
appEndo :: Endo a -> (a -> a)
append (<>) :: [a] -> [a] -> [a]
appendFile :: FilePath -> String -> IO Bool
appendFileMay :: FilePath -> String -> Maybe IO FilePath
appendGen (++) :: Gen [a] -> Gen [a] -> Gen [a]
apply ($) :: (a -> b) -> a -> b
applyN :: Int -> (a -> a) -> a -> a
approxRatio :: Real -> Real -> Ratio
argvLength :: Function -> Int
assocs :: Map k a -> [(k, a)]
base64decode :: String -> String
base64encode :: String -> String
biList :: (a, a) -> [a]
bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d)
bimapLR :: (a -> b) -> (c -> d) -> ֵEither ֵֵa c -> Either b d
bimapN :: (a -> b) -> (c -> d) -> TupleN -> TupleN
bind (>>=) :: Monad m => m a -> (a -> m b) -> m b
bindFn (>>=) :: (a -> b) -> (b -> a -> c) -> a -> c
bindLR (>>=) :: Either a -> (a -> Either b) -> Either b
bindList (>>=) :: [a] -> (a -> [b]) -> [b]
bindMay (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
bindTuple (>>=) :: Monoid a => (a, a) -> (a -> (a, b)) -> (a, b)
bool :: a -> a -> Bool -> a
both :: (a -> b) -> (a, a) -> (b, b)
breakOn :: Eq a => [a] -> [a] -> ([a], [a])
breakOnAll :: String -> String -> [(String, String)]
breakOnMay :: String -> String -> Maybe (String, String)
break_ :: (a -> Bool) -> [a] -> ([a], [a])
bulleted :: String -> String -> String
cartesianProduct :: [a] -> [b] -> [[a, b]]
caseOf :: [(a -> Bool, b)] -> b -> a ->  b
catMaybes :: [Maybe a] -> [a]
ceiling :: Num -> Int
center :: Int -> Char -> String -> String
chars :: String -> [Char]
chop :: ([a] -> (b, [a])) -> [a] -> [b]
chr :: Int -> Char
chunksOf :: Int -> [a] -> [[a]]
combinations :: Int -> [a] -> [[a]]
combine (</>) :: FilePath -> FilePath -> FilePath
compare :: a -> a -> Ordering
compareList :: [a] -> [a] -> Ordering
comparing :: Ord a => (b -> a) -> b -> b -> Ordering
compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
composeList :: [(a -> a)] -> (a -> a)
composeListR :: [(a -> a)] -> (a -> a)
composeR (>>>) :: (a -> b) -> (b -> c) -> a -> c
concat :: [[a]] -> [a]
concatGen :: Gen [[a]] -> Gen [a]
concatMap :: (a -> [b]) -> [a] -> [b]
concats :: [String] -> String
cons :: a -> [a] -> [a]
constant :: a -> b -> a
copyFileLR :: FilePath -> FilePath -> Either String IO ()
createDirectoryIfMissingLR :: Bool -> FilePath -> Either String FilePath
curry :: ((a, b) -> c) -> a -> b -> c
curryN :: Curry a b => a -> b
cycle :: [a] -> Generator [a]
decodedPath :: Percent Encoded String -> FilePath
degrees :: Float x => Radians x -> Degrees x
delete :: Eq a => a -> [a] -> [a]
deleteAt :: Int -> [a] -> [a]
deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
deleteFirst :: a -> [a] -> [a]
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
deleteKey :: String -> Dict -> Dict
dictFromList :: [(k, v)] -> Dict
difference :: Eq a => [a] -> [a] -> [a]
differenceGen :: Gen [a] -> Gen [a] -> Gen [a]
digitToInt :: Char -> Int
div :: Int -> Int -> Int
divMod :: Int -> Int -> (Int, Int)
doesDirectoryExist :: FilePath -> IO Bool
doesFileExist :: FilePath -> IO Bool
doesPathExist :: FilePath -> IO Bool
dot (.) :: (b -> c) -> (a -> b) -> a -> c
draw :: Tree String -> [String]
drawForest :: [Tree String] -> String
drawTree :: Tree String -> String
drawTree2 :: Bool -> Bool -> Tree String -> String
drop :: Int -> [a] -> [a]
dropAround :: (a -> Bool) -> [a] -> [a]
dropFileName :: FilePath -> FilePath
dropLength :: [a] -> [b] -> [b]
dropLengthMaybe :: [a] -> [b] -> Maybe [b]
dropWhile :: (a -> Bool) -> [a] -> [a]
dropWhileEnd :: (a -> Bool) -> [a] -> [a]
dropWhileGen :: (a -> Bool) -> Gen [a] -> [a]
either :: (a -> c) -> (b -> c) -> Either a b -> c
elem :: Eq a => a -> [a] -> Bool
elemAtMay :: Int -> Dict -> Maybe (String, a)
elemIndex :: Eq a => a -> [a] -> Maybe Int
elemIndices :: Eq a => a -> [a] -> [Int]
elemTree :: a -> Tree a -> Bool
elems :: Map k a -> [a]
encodedPath :: FilePath -> Percent Encoded String
enumFrom :: Enum a => a -> [a]
enumFromPairs :: String -> [(String, Int)] -> Dict
enumFromThen :: Int -> Int -> Gen [Int]
enumFromThenTo :: Int -> Int -> Int -> [Int]
enumFromThenToChar :: Char -> Char -> Char -> [Char]
enumFromTo :: Int -> Int -> [Int]
enumFromToChar :: Char -> Char -> [Char]
enumFromTo_ :: Enum a => a -> a -> [a]
eq (==) :: Eq a => a -> a -> Bool
eqDate :: Date -> Date -> Bool
eqDateTime :: Int -> Date -> Date -> Bool
eqSet :: Set a -> Set a -> Bool
evalJSLR :: String -> Either String a
evalJSMay :: String -> Maybe a
even :: Int -> Bool
exp :: Float -> Float
fTable :: String -> (a -> String) -> (b -> String) -> (a -> b) -> [a] -> String
fType :: (a -> f b) -> f
fanArrow (&&&) :: (a -> b) -> (a -> c) -> (a -> (b, c))
filePath :: String -> FilePath
filePathTree :: filePath -> [Tree String] -> Tree FilePath
fileSize :: FilePath -> Either String Int
fileStatus :: FilePath -> Either String Dict
fileUTI :: FilePath -> Either String String
filesCopiedLR :: FilePath -> [FilePath] -> FilePath -> IO Either String [FilePath]
filter :: (a -> Bool) -> [a] -> [a]
filterGen :: (a -> Bool) -> Gen [a] -> Gen [a]
filterTree (a -> Bool) -> Tree a -> [a]
filteredSubTrees :: (Tree a -> Bool) -> Tree a -> [Tree a]
filteredTree (a -> Bool) -> Tree a -> Tree a
find :: (a -> Bool) -> [a] -> Maybe a
findGen :: (a -> Bool) -> Gen [a] -> Maybe a
findIndex :: (a -> Bool) -> [a] -> Maybe Int
findIndexR :: (a -> Bool) -> [a] -> Maybe Int
findIndices :: (a -> Bool) -> [a] -> [Int]
findTree :: (a -> Bool) -> Tree a -> Maybe a
first :: (a -> b) -> ((a, c) -> (b, c))
flatten :: NestedList a -> [a]
flattenTree :: Tree a -> [a]
flip :: (a -> b -> c) -> b -> a -> c
floor :: Num -> Int
fmap (<$>) :: Functor f => (a -> b) -> f a -> f b
fmapDict :: (a -> b) -> {String :: a} -> {String :: b}
fmapGen <$> :: (a -> b) -> Gen [a] -> Gen [b]
fmapLR (<$>) :: (b -> c) -> Either a b -> Either a c
fmapMay (<$>) :: (a -> b) -> Maybe a -> Maybe b
fmapTree :: (a -> b) -> Tree a -> Tree b
fmapTuple (<$>) :: (a -> b) -> (a, a) -> (a, b)
fmapZL (<$>) :: (a -> b) -> ZipList a -> ZipList b
foldList :: Monoid m => [m] -> m
foldMap :: Monoid m => (a -> m) -> t a -> m
foldMapGen :: (a -> [b]) -> [a] -> Gen [b]
foldMapList :: Monoid m => (a -> m) -> t a -> m
foldMapTree :: Monoid m => (a -> m) -> Tree a -> m
foldTree :: (a -> [b] -> b) -> Tree a -> b
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl1 :: (a -> a -> a) -> [a] -> a
foldl1May :: (a -> a -> a) -> [a] -> Maybe a
foldlTree :: (b -> a -> b) -> b -> Tree a -> b
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr1 :: (a -> a -> a) -> [a] -> a
foldr1May :: (a -> a -> a) -> [a] -> Maybe a
foldrTree :: (a -> b -> b) -> b -> Tree a -> b
foldrTree2 :: (a -> b -> b) -> b -> t a -> b
foldr_ :: (a -> b -> b) -> b -> t a -> b
forestFromJSONLR :: JSON String -> Either String Forest a
fromEnum :: Enum a => a -> Int
fromLeft :: a -> Either a b -> a
fromMaybe :: a -> Maybe a -> a
fromRight :: b -> Either a b -> b
fst :: (a, b) -> a
ft :: Int -> Int -> [Int]
gcd :: Integral a => a -> a -> a
gcdApprox :: Real -> (Real, Real) -> Real
genericIndexMay :: [a] -> Int -> Maybe a
getCurrentDirectory :: IO FilePath
getDirectoryContentsLR :: FilePath ->
getHomeDirectory :: IO FilePath
getTemporaryDirectory :: IO FilePath
group :: [a] -> [[a]]
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
groupOn :: (a -> b) -> [a] -> [[a]]
groupOnKey :: Eq k => (a -> k) -> [a] -> [(k, [a])]
groupSortBy :: (a -> a -> Ordering) -> [a] -> [[a]]
groupSortOn :: Ord b => (a -> b) -> [a] -> [[a]]
gt :: Ord a => a -> a -> Bool
head :: [a] -> a
headDef :: a -> [a] -> a
headMay :: [a] -> Maybe a
identity :: a -> a
if_ :: Bool -> a -> a -> a
indented :: String -> String -> String
index (!!) :: [a] -> Int -> Maybe a
indexForest :: [Tree (a,  { nodeSum :: Int })] -> Int -> Maybe Tree (a, { nodeSum :: Int })
indexOf :: Eq a => [a] -> [a] -> Maybe Int
indexTree :: Tree (a,  { nodeSum :: Int }) -> Int -> Maybe Tree (a,  { nodeSum :: Int })
indexedTree :: Int -> Tree a -> Tree (a, Int)
init :: [a] -> [a]
initMay :: [a] -> Maybe [a]
inits :: [a] -> [[a]]
insert :: Ord a => a -> [a] -> [a]
insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
insertDict :: String -> a -> Dict -> Dict
insertWith :: Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
intToDigit :: Int -> Char
intercalate :: [a] -> [[a]] -> [a]
intercalateS :: String -> [String] -> String
intersect :: (Eq a) => [a] -> [a] -> [a]
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
intersectListsBy :: (a -> a -> Bool) -> [[a]] -> [a]
intersectSet :: Set -> Set -> Set
intersection :: Ord a => Set a -> Set a -> Set a
intersperse :: a -> [a] -> [a]
isAlpha :: Char -> Bool
isAlphaNum :: Char -> Bool
isBigInt :: Num -> Bool
isChar :: a -> Bool
isDigit :: Char -> Bool
isInfixOf :: (Eq a) => [a] -> [a] -> Bool
isLeft :: Either a b -> Bool
isLower :: Char -> Bool
isMaybe :: a -> Bool
isNull :: [a] -> Bool
isPrefixOf :: [a] -> [a] -> Bool
isRight :: Either a b -> Bool
isSortedBy :: (a -> a -> Bool) -> [a] -> Bool
isSpace :: Char -> Bool
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
isSubsetOf :: Ord a => Set a -> Set a -> Bool
isSuffixOf :: Eq a => [a] -> [a] -> Bool
isUpper :: Char -> Bool
iso8601Local :: Date -> String
iterate :: (a -> a) -> a -> Gen [a]
iterateUntil :: (a -> Bool) -> (a -> a) -> a -> [a]
iterateUntilGen :: (a -> Bool) -> (a -> a) -> a -> Generator [a]
join :: Monad m => m (m a) -> m a
jsonFromTree :: Tree a -> String
jsonLog :: a -> IO ()
jsonParseLR :: String -> Either String a
justifyLeft :: Int -> Char -> String -> String
justifyRight :: Int -> Char -> String -> String
kCompose (>=>) :: Monad m => [(a -> m a)] -> (a -> m a)
keys :: Dict -> [String]
kleisliCompose (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
last :: [a] -> a
lastMay :: [a] -> Maybe a
lazyList :: [a] -> Gen [a]
lcm :: Int -> Int -> Int
le :: Ord a => a -> a -> a
lefts :: [Either a b] -> [a]
length :: [a] -> Int
lengthTree :: Tree a -> Int
levelNodes :: Tree a -> [[Tree a]]
levels :: Tree a -> [[a]]
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
liftA2Fn :: (a0 -> b -> c) -> (a -> a0) -> (a -> b) -> a -> c
liftA2LR :: (a -> b -> c) -> Either d a -> Either d b -> Either d c
liftA2List :: (a -> b -> c) -> [a] -> [b] -> [c]
liftA2May :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
liftA2Tree :: (a -> b -> c) -> Tree a -> Tree b -> Tree c
liftA2Tuple :: Monoid m => (a -> b -> c) -> (m, a) -> (m, b) -> (m, c)
liftA2ZL :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c
lines :: String -> [String]
list :: StringOrArrayLike b => b -> [a]
listDirectory :: FilePath -> [FilePath]
listFromMaybe :: Maybe a -> [a]
listFromTree :: Tree a -> [a]
listToMaybe :: [a] -> Maybe a
log :: Float -> Float
lookup :: Eq a => a -> Container -> Maybe b
lookupDict :: a -> Dict -> Maybe b
lookupTuples :: Eq a => a -> [(a, b)] -> Maybe b
lt (<) :: Ord a => a -> a -> Bool
mReturn :: First-class m => (a -> b) -> m (a -> b)
map :: (a -> b) -> [a] -> [b]
mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
mapAccumLTree :: (s -> a -> (s, b)) -> s -> Tree a -> (s, Tree b)
mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
mapFromList :: [(String, a)] -> Dict
mapKeys :: (Key -> Key) -> IntMap a -> IntMap a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
mapMaybeGen :: (a -> Maybe b) -> Gen [a] -> Gen [b]
mappEndo (<>) :: Endo a -> Endo a -> Endo a
mappend (<>) :: Monoid a => a -> a -> a
mappendComparing (<>) :: (a -> a -> Bool) (a -> a -> Bool) -> (a -> a -> Bool)
mappendFn (<>) :: Monoid b => (a -> b) -> (a -> b) -> (a -> b)
mappendMaybe (<>) :: Maybe a -> Maybe a -> Maybe a
mappendOrd (<>) :: Ordering -> Ordering -> Ordering
mappendTuple (<>) :: (a, b) -> (a, b) -> (a, b)
mappendTupleN (<>) :: (a, b, ...) -> (a, b, ...) -> (a, b, ...)
matching :: [a] -> (a -> Int -> [a] -> Bool)
matrix Int -> Int -> (Int -> Int -> a) -> [[a]]
max :: Ord a => a -> a -> a
maxBound :: a -> a
maximum :: Ord a => [a] -> a
maximumBy :: (a -> a -> Ordering) -> [a] -> a
maximumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
maximumMay :: Ord a => [a] -> Maybe a
maximumOn :: (Ord b) => (a -> b) -> [a] -> a
maybe :: b -> (a -> b) -> Maybe a -> b
mconcatOrd :: [Ordering] -> Ordering
mean :: [Num] -> Num
measuredTree :: Tree a -> Tree (a, {leafSum::Int, layerSum::Int, nodeSum::Int, index::Int})
member :: Key -> Dict -> Bool
mempty :: a -> a
merge :: Ord a => [a] -> [a] -> [a]
mergeBy :: (a -> a -> Ordering) -> [a] -> [a] -> [a]
min :: Ord a => a -> a -> a
minBound :: a -> a
minimum :: Ord a => [a] -> a
minimumBy :: (a -> a -> Ordering) -> [a] -> a
minimumByMay :: (a -> a -> Ordering) -> [a] -> Maybe a
minimumMay :: [a] -> Maybe a
minimumOn :: (Ord b) => (a -> b) -> [a] -> a
mod :: Int -> Int -> Int
modificationTime :: FilePath -> Either String Date
mul (*) :: Num a => a -> a -> a
ne :: a -> a -> Bool
negate :: Num -> Num
nest :: Tree a -> [a]
newUUID :: () -> IO UUID String
not :: Bool -> Bool
notElem :: Eq a => a -> [a] -> Bool
nub :: Eq a => [a] -> [a]
nubBy :: (a -> a -> Bool) -> [a] -> [a]
odd :: Int -> Bool
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
or :: [Bool] -> Bool
ord :: Char -> Int
outdented :: String -> String
parentIndexedTree :: Tree (a, {...index :: Int}) -> Tree (a, {...index :: Int, parent :: Maybe Int})
partition :: (a -> Bool) -> [a] -> ([a], [a])
partitionEithers :: [Either a b] -> ([a],[b])
partitionTree :: (a -> Bool) -> Tree a -> ([Tree a], [Tree a])
pathAccessor :: String -> Dict -> a
permutations :: [a] -> [[a]]
pi :: Float
plural :: Int -> String -> String
plus :: Num -> Num -> Num
postorder :: Tree a -> [a]
pred :: Enum a => a -> a
predMay :: Enum a => a -> Maybe a
prependToAll :: a -> [a] -> [a]
product :: [Num] -> Num
properFracRatio :: Ratio -> (Int, Ratio)
properFraction :: Real -> (Int, Real)
prunedForest (a -> Bool) -> Forest a -> Forest a
pureLR :: a -> Either e a
pureList :: a -> [a]
pureMay :: a -> Maybe a
pureT :: String -> (a -> f a)
pureTree :: a -> Tree a
pureTuple :: a -> (a, a)
pureZL :: a -> ZipList a
quickSort :: (Ord a) => [a] -> [a]
quickSortBy :: (a -> a -> Ordering) -> [a] -> [a]
quot :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)
quoted :: Char -> String -> String
radians :: Float x => Degrees x -> Radians x
raise :: Num -> Int -> Num
randomRInt :: Int -> Int -> (() -> IO Int)
range :: Ix a => (a, a) -> [a]
ratioDiv :: Rational -> Rational -> Rational
ratioMinus :: Rational -> Rational -> Rational
ratioMult :: Rational -> Rational -> Rational
ratioPlus :: Rational -> Rational -> Rational
rational :: Num a => a -> Rational
read :: Read a => String -> a
readFile :: FilePath -> IO String
readFileLR :: FilePath -> Either String IO String
readHex :: String -> Int
readLR :: Read a => String -> Either String a
readPlistFileLR :: FilePath -> Either String Dict
recip :: Num -> Num
recipMay :: Num -> Maybe Num
regexIndexedMatches :: Regex -> String -> [(Int, String)]
regexMatches :: Regex String -> String -> [[String]]
rem :: Integral a => a -> a -> a
remQuot :: Integral a => a -> a -> (a, a)
removeFileLR :: FilePath -> Either String String
renamedFile :: FilePath -> FilePath ->
repeat :: a -> Generator [a]
replace :: String -> String -> String -> String
replicate :: Int -> a -> [a]
replicateM :: Int -> [a] -> [[a]]
replicateString :: Int -> String -> String
importedFrom :: FilePath -> IO Dict
reverse :: [a] -> [a]
rights :: [Either a b] -> [b]
root :: Tree a -> a
rotate :: Int -> [a] -> [a]
round :: a -> Int
roundTo :: Int -> Float -> Float
runAction :: Action a -> a
safeMay :: (a -> Bool) -> (a -> b) -> Maybe b
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanlGen :: (b -> a -> b) -> b -> Gen [a] -> [b]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
second :: (a -> b) -> ((c, a) -> (c, b))
sequenceA :: (Applicative f, Traversable t) => t (f a) -> f (t a)
setCurrentDirectory :: FilePath -> IO ()
setFromList :: Ord a => [a] -> Set a
setInsert :: Ord a => a -> Set a -> Set a
setMember :: Ord a => a -> Set a -> Bool
setSize :: Set a -> Int
shift :: Int -> [a] -> [a]
show :: a -> String
showBinary :: Int -> String
showDate :: Date -> String
showDict :: Dict -> String
showFn :: (a -> b) -> String
showForest :: [Tree a] -> String
showHex :: Int -> String
showIntAtBase :: Int -> (Int -> Char) -> Int -> String -> String
showJSON :: a -> String
showLR :: Either a b -> String
showList :: [a] -> String
showLog :: a -> IO ()
showMatrix :: (a -> String) -> [[a]] -> String
showMaybe :: Maybe a -> String
showMenuLR :: Bool -> String -> String -> [String] -> String -> Either String [String]
showOrdering :: Ordering -> String
showOutline :: Tree String -> String
showPrecision :: Int -> Float -> String
showRatio :: Ratio -> String
showSet :: Set a -> String
showTree :: Tree a -> String
showTuple :: Tuple -> String
showUndefined :: () -> String
signum :: Num -> Num
sj :: a -> String
snd :: (a, b) -> b
snoc :: [a] -> a -> [a]
sort :: Ord a => [a] -> [a]
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
sortOn :: Ord b => (a -> b) -> [a] -> [a]
span :: (a -> Bool) -> [a] -> ([a], [a])
splitArrow (***) :: (a -> b) -> (c -> d) -> ((a, c) -> (b, d))
splitAt :: Int -> [a] -> ([a], [a])
splitBy :: (a -> a -> Bool) -> [a] -> [[a]]
splitExtension :: FilePath -> (String, String)
splitFileName :: FilePath -> (String, String)
splitOn :: [a] -> [a] -> [[a]]
splitRegex :: Regex -> String -> [String]
sqrt :: Num -> Num
sqrtLR :: Num -> Either String Num
sqrtMay :: Num -> Maybe Num
str :: a -> String
strip :: String -> String
stripEnd :: String -> String
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
stripStart :: String -> String
subTreeAtPath :: Tree String -> [String] -> Maybe Tree String
subsequences :: [a] -> [[a]]
subsets :: [a] -> [[a]]
subtract :: Num -> Num -> Num
succ :: Enum a => a -> a
succMay :: Enum a => a -> Maybe a
sum :: [Num] -> Num
swap :: (a, b) -> (b, a)
tail :: [a] -> [a]
tailMay :: [a] -> Maybe [a]
tails :: [a] -> [[a]]
take :: Int -> [a] -> [a]
takeAround :: (a -> Bool) -> [a] -> [a]
takeBaseName :: FilePath -> String
takeCycle :: Int -> [a] -> [a]
takeDirectory :: FilePath -> FilePath
takeDropCycle :: Int -> [a] -> [a]
takeExtension :: FilePath -> String
takeFileName :: FilePath -> FilePath
takeFromThenTo :: Int -> Int -> Int -> [a] -> [a]
takeIterate :: Int -> (a -> a) -> a -> [a]
takeWhile :: (a -> Bool) -> [a] -> [a]
takeWhileEnd :: (a -> Bool) [a] -> [a]
takeWhileGen :: (a -> Bool) -> Gen [a] -> [a]
takeWhileR :: (a -> Bool) -> [a] -> [a]
taskPaperDateString :: Date -> String
taskPaperDayString :: Date -> String
tempFilePath :: String -> IO FilePath
toEnum :: a -> Int -> a
toLower :: String -> String
toRatio :: Real -> Ratio
toSentence :: String -> String
toTitle :: String -> String
toUpper :: String -> String
transpose :: [[a]] -> [[a]]
transpose_ :: [[a]] -> [[a]]
traverse :: (Applicative f, Traversable t) -> (a -> f b) -> t a -> f (t b)
traverseLR :: Applicative f => (t -> f b) -> Either a t -> f (Either a b)
traverseList :: (Applicative f) => (a -> f b) -> [a] -> f [b]
traverseListLR (a -> Either b c) -> [a] -> Either b [c]
traverseMay :: Applicative f => (t -> f a) -> Maybe t -> f (Maybe a)
traverseTree :: Applicative f => (a -> f b) -> Tree a -> f (Tree b)
traverseTuple :: Functor f => (t -> f b) -> (a, t) -> f (a, b)
treeFromDict :: String -> Dict -> Tree String
treeFromJSON :: JSON String -> Tree a
treeFromNestedDict -> Dict -> Either String Tree Dict
treeLeaves :: Tree -> [Tree]
treeMatch :: (a -> Bool) -> Tree a -> [Tree a]
treeMatches :: (a -> Bool) -> Tree a -> [Tree a]
treeMenu :: Tree String -> IO [String]
treeMenuBy :: (a -> String) Tree a -> IO [a]
truncate :: Num -> Int
tupleFromList :: [a] -> (a, a ...)
typeName :: a -> String
unDigits :: [Int] -> Int
unQuoted :: String -> String
uncons :: [a] -> Maybe (a, [a])
uncurry :: (a -> b -> c) -> ((a, b) -> c)
uncurryN :: (a -> b ... -> e) -> (a, b ...) -> e
unfoldForest :: (b -> (a, [b])) -> [b] -> [Tree]
unfoldTree :: (b -> (a, [b])) -> b -> Tree a
unfoldl :: (b -> Maybe (b, a)) -> b -> [a]
unfoldr :: (b -> Maybe (a, b)) -> b -> Gen [a]
union :: [a] -> [a] -> [a]
unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
unionSet :: Ord a => Set a -> Set a -> Set a
unlines :: [String] -> String
unsnoc :: [a] -> Maybe ([a], a)
until :: (a -> Bool) -> (a -> a) -> a -> a
unwords :: [String] -> String
unwrap :: NSObject -> a
unzip :: [(a,b)] -> ([a],[b])
unzip3 :: [(a,b,c)] -> ([a],[b],[c])
unzip4 :: [(a,b,c,d)] -> ([a],[b],[c],[d])
unzipN :: [(a,b,...)] -> ([a],[b],...)
variance :: [Num] -> Num
words :: String -> [String]
wrap :: a -> NSObject
writeFile :: FilePath -> String -> IO ()
writeFileLR :: FilePath -> String -> Either String IO FilePath
writeTempFile :: String -> String -> IO FilePath
zeroPadded :: Int -> Int -> String
zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
zipGen :: (a -> b -> c) -> Gen [a] -> Gen [b] -> Gen [c]
zipList :: [a] -> [b] -> [(a, b)]
zipN :: [a] -> [b] -> ... -> [(a, b ...)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipWithGen :: (a -> b -> c) -> Gen [a] -> Gen [b] -> Gen [c]
zipWithList :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWithList_ :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWithLong :: (a -> a -> a) -> [a] -> [a] -> [a]
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithN :: (a -> b -> ... -> d) -> [a], [b] ... -> [d]
zipWithN_ :: ((a, b ...) -> d) -> [a], [b] ... -> [d]
zipWith_ :: (a -> a -> b) -> [a] -> [b]