allFunctionNames.txt

Just :: a -> Maybe a
Left :: a -> Either a b
Node :: a -> [Tree a] -> Tree a
Nothing :: Maybe a
Right :: b -> Either a b
Tuple (,) :: a -> b -> (a, b)
Tuple3 (,,) :: a -> b -> c -> (a, b, c)
TupleN :: a -> b ...  -> (a, b ... )
abs :: Num -> Num
add (+) :: Num a => a -> a -> a
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)
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 :: Float -> Float -> Ratio
argvLength :: Function -> Int
assocs :: Map k a -> [(k, a)]
base64decode :: String -> String
base64encode :: String -> String
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
break :: (a -> Bool) -> [a] -> ([a], [a])
breakOn :: String -> String -> (String, String)
breakOnAll :: String -> String -> [(String, String)]
breakOnMay :: String -> String -> Maybe (String, String)
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]]
combine (</>) :: FilePath -> FilePath -> FilePath
compare :: a -> a -> Ordering
comparing :: (a -> b) -> (a -> a -> 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]
concatMap :: (a -> [b]) -> [a] -> [b]
cons :: a -> [a] -> [a]
constant :: a -> b -> a
createDirectoryIfMissingLR :: Bool -> FilePath -> Either String FilePath
curry :: ((a, b) -> c) -> a -> b -> c
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
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]
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
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
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
filter :: (a -> Bool) -> [a] -> [a]
filterGen :: (a -> Bool) -> Gen [a] -> Gen [a]
filterTree (a -> Bool) -> Tree a -> [a]
filteredTree (a -> Bool) -> Tree a -> Tree a
find :: (a -> Bool) -> [a] -> (missing value | 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 Tree 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
fmapGen <$> :: (a -> b) -> Gen [a] -> Gen [b]
fmapLR (<$>) :: (a -> b) -> Either a a -> Either a b
fmapMay (<$>) :: (a -> b) -> Maybe a -> Maybe b
fmapTree :: (a -> b) -> Tree a -> Tree b
fmapTuple (<$>) :: (a -> b) -> (a, a) -> (a, b)
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
forestFromJSON :: String -> [Tree 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 :: Int -> Int -> Int
genericIndexMay :: [a] -> Int -> Maybe a
getCurrentDirectory :: IO FilePath
getDirectoryContents :: FilePath -> IO [FilePath]
getDirectoryContentsLR :: FilePath -> Either String IO [FilePath]
getFinderDirectory :: IO FilePath
getHomeDirectory :: IO FilePath
getTemporaryDirectory :: IO FilePath
group :: Eq a => [a] -> [[a]]
groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
groupSortOn :: Ord b => (a -> b) -> [a] -> [[a]]
gt :: Ord a => a -> a -> Bool
head :: [a] -> a
headMay :: [a] -> Maybe a
identity :: a -> a
if_ :: Bool -> a -> a -> a
indented :: String -> String -> String
index (!!) :: [a] -> Int -> Maybe a
indexOf :: Eq a => [a] -> [a] -> Maybe 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
insertSet :: Ord a => a -> Set a -> Set 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]
intersection :: Ord a => Set a -> Set a -> Set a
intersperse :: a -> [a] -> [a]
isAlpha :: Char -> 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]
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
keys :: Dict -> [String]
kleisliCompose (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
last :: [a] -> a
lastMay :: [a] -> Maybe a
lcm :: Int -> Int -> Int
lefts :: [Either a b] -> [a]
length :: [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)
lines :: String -> [String]
list :: Gen [a] -> [a]
listDirectory :: FilePath -> [FilePath]
listFromMaybe :: Maybe a -> [a]
listFromTree :: Tree a -> [a]
listFromTuple :: (a, 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])
mapAccumL_Tree :: (acc -> x -> (acc, y)) -> acc -> Tree -> (acc, Tree)
mapAccumR :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
mapKeys :: (Key -> Key) -> IntMap a -> IntMap a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
mapMaybeGen :: (a -> Maybe b) -> Gen [a] -> Gen [b]
mappend (<>) :: Monoid a => a -> a -> a
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)
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
maybe :: b -> (a -> b) -> Maybe a -> b
mean :: [Num] -> Num
memberDict :: Key -> Dict -> Bool
memberSet :: a -> Set a -> Bool
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
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 :: [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
orderedUnion :: [a] -> [a] -> [a]
ordering :: () -> Ordering
outdented :: String -> String
partition :: (a -> Bool) -> [a] -> ([a], [a])
partitionEithers :: [Either a b] -> ([a],[b])
permutations :: [a] -> [[a]]
permutationsWithRepetition :: Int -> [a] -> [[a]]
pi :: Float
plus :: Num -> Num -> Num
postorder :: Tree a -> [a]
pred :: Enum a => a -> a
predMay :: Enum a => a -> Maybe a
print :: a -> IO ()
product :: [Num] -> Num
properFracRatio :: Ratio -> (Int, Ratio)
properFraction :: Real -> (Int, Real)
pureLR :: a -> Either e a
pureList :: a -> [a]
pureMay :: a -> Maybe a
pureT :: String -> f a -> (a -> f a)
pureTree :: a -> Tree a
pureTuple :: a -> (a, a)
quickSort :: (Ord a) => [a] -> [a]
quickSortBy :: (a -> a -> Ordering) -> [a] -> [a]
quot :: Int -> Int -> Int
quotRem :: Int -> Int -> (Int, Int)
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]
ratio :: Int -> Int -> Ratio Int
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
readBinary :: String -> Int
readFile :: FilePath -> IO String
readFileLR :: FilePath -> Either String IO String
readHex :: String -> Int
readLR :: Read a => String -> Either String a
recip :: Num -> Num
recipMay :: Num -> Maybe Num
regexMatches :: Regex String -> String -> [[String]]
rem :: Int -> Int -> Int
removeFile :: FilePath -> Either String String
renamedFile :: FilePath -> FilePath ->
repeat :: a -> Generator [a]
replace :: String -> String -> String -> String
replicate :: Int -> String -> String

replicateString :: Int -> String -> String
reverse :: [a] -> [a]
rights :: [Either a b] -> [b]
root :: Tree a -> a
rotate :: Int -> [a] -> [a]
rotated :: 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]
scanr :: (b -> a -> 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 :: String -> 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
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 :: [[Maybe a]] -> String
showMaybe :: Maybe a -> 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]]
splitFileName :: FilePath -> (String, String)
splitOn :: [a] -> [a] -> [[a]]
splitRegex :: Regex -> String -> [String]
sqrt :: Num -> (missing value | 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)
table :: Int -> [String] -> String
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]
takeWhileGen :: (a -> Bool) -> Gen [a] -> [a]
takeWhileR :: (a -> Bool) -> [a] -> [a]
taskPaperDateString :: 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]
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
treeFromNestedList :: NestedList a -> Tree a
treeLeaves :: Tree -> [Tree]
treeMatches :: (a -> Bool) -> Tree a -> [Tree a]
treeMenu :: Tree String -> IO [String]
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)
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 -> [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 :: NSValue -> 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 -> Either String IO FilePath

zip :: [a] -> [b] -> [(a, b)]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
zipGen :: Gen [a] -> Gen [b] -> Gen [(a, b)]
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]
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithN :: (a -> b -> ... -> c) -> ([a], [b] ...) -> [c]