mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-29 17:50:22 +00:00
Grammar update
This commit is contained in:
Arfon Smith
222
vendor/grammars/haskell.tmbundle/Support/bin/haskelltype
vendored
Executable file
222
vendor/grammars/haskell.tmbundle/Support/bin/haskelltype
vendored
Executable file
@@ -0,0 +1,222 @@
|
||||
#!/usr/bin/env ruby18 -w
|
||||
|
||||
word = ARGV.first
|
||||
|
||||
prelude = '
|
||||
(!!) :: [a] -> Int -> a ||||| [0,1,2] !! 1 = 1
|
||||
($) :: (a -> b) -> a -> b ||||| f x $ g y = f x (g y)
|
||||
($!) :: (a -> b) -> (a -> b) |||||
|
||||
(&&) :: Bool -> Bool -> Bool ||||| Boolean \'and\'
|
||||
(||) :: Bool -> Bool -> Bool ||||| Boolean \'or\'
|
||||
(*) :: Num a => a -> a -> a ||||| Multiplication
|
||||
(**) :: Floating a => a -> a -> a ||||| Exponentiation
|
||||
(+) :: Num a => a -> a -> a ||||| Addition
|
||||
(++) :: [a] -> [a] -> [a] ||||| Concatonation: "abc" ++ "def" = "abcdef"
|
||||
(-) :: Num a => a -> a -> a ||||| Subtraction
|
||||
(.) :: (b -> c) -> (a -> b) -> a -> c ||||| Function composition
|
||||
(/) :: Fractional a => a -> a -> a ||||| Division
|
||||
(/=) :: Eq a => a -> a -> Bool ||||| not equal
|
||||
(<) :: Ord a => a -> a -> Bool ||||| Less Than
|
||||
(<=) :: Ord a => a -> a -> Bool ||||| Less Than or Equal To
|
||||
(==) :: Eq a => a -> a -> Bool ||||| Equality
|
||||
(=<<) :: Monad a => (a -> m b) -> m a -> m b ||||| Monadic binding
|
||||
(>) :: Ord a => a -> a -> Bool ||||| Greater Than
|
||||
(>=) :: Ord a => a -> a -> Bool ||||| Greater Than or Equal To
|
||||
(>>) :: Monad m => m a -> m b -> m b ||||| Monadic binding
|
||||
(>>=) :: Monad m => m a -> (a -> m b) -> m b ||||| Monadic binding
|
||||
(^) :: (Num a, Integral b) => a -> b -> a ||||| Exponentiation
|
||||
(^^) :: (Fractional a, Integral b) => a -> b -> a ||||| negative exponent allowed
|
||||
abs :: Num a => a -> a ||||| Absolute Value
|
||||
acos :: Floating a => a -> a ||||| Arccosine
|
||||
acosh :: Floating a => a -> a ||||| Hyperbolic Arccosine
|
||||
all :: (a -> Bool) -> [a] -> Bool ||||| all (/= \'a\') "cba" = False
|
||||
and :: [Bool] -> Bool ||||| and [True, True, True] = True
|
||||
any :: (a -> Bool) -> [a] -> Bool ||||| any (== \'c\') "abc" = True
|
||||
appendFile :: FilePath -> String -> IO () ||||| Appends String to FilePath
|
||||
applyM :: Monad m => (a -> m b) -> m a -> m b |||||
|
||||
asTypeOf :: a -> a -> a ||||| Sort of a type cast
|
||||
asin :: Floating a => a -> a ||||| Arcsine
|
||||
asinh :: Floating a => a -> a ||||| Hyperbolic Arcsine
|
||||
atan :: Floating a => a -> a ||||| Arctangent
|
||||
atan2 :: RealFrac a => a -> a ||||| ArcTangent
|
||||
atanh :: Floating a => a -> a ||||| Hyperbolic Arctangent
|
||||
break :: (a -> Bool) -> [a] -> ([a], [a]) ||||| break (<2) [1,2,3] = ([1],[2,3])
|
||||
catch :: IO a -> (IOError -> IO a) -> IO a |||||
|
||||
ceiling :: (RealFrac a, Integral b) => a -> b |||||
|
||||
compare :: Ord a => a -> a -> Ordering |||||
|
||||
concat :: MonadPlus m => [m a] -> m a ||||| concat ["a","bc","d"] = "abcd"
|
||||
concatMap :: (a -> [b]) -> [a] -> [b] |||||
|
||||
const :: a -> b -> a |||||
|
||||
cos :: Floating a => a -> a |||||
|
||||
cosh :: Floating a => a -> a |||||
|
||||
curry :: ((a, b) -> c) -> a -> b -> c |||||
|
||||
cycle :: [a] -> [a] ||||| cycle "abc" = "abcabcabc...
|
||||
decodeFloat :: RealFloat a => a -> (Integer, Int) |||||
|
||||
div :: Integral a => a -> a -> a |||||
|
||||
divMod :: Integral a => a -> a -> (a, a) |||||
|
||||
drop :: Int -> [a] -> [a] ||||| drop 2 "abcd" = "cd"
|
||||
dropWhile :: (a -> Bool) -> [a] -> [a] ||||| dropWhile (>3) [5,3,5] = [3,5]
|
||||
elem :: Eq a => a -> [a] -> Bool ||||| \'a\' \'elem\' "abc" = True
|
||||
encodeFloat :: RealFloat a => Integer -> Int -> a |||||
|
||||
enumFrom :: Enum a => a -> [a] ||||| [n..]
|
||||
enumFromThen :: Enum a => a -> a -> [a] ||||| [m,n..]
|
||||
enumFromThenTo :: Enum a => a -> a -> a -> [a] ||||| [m,n..o]
|
||||
enumFromTo :: Enum a => a -> a -> [a] ||||| [m..n]
|
||||
error :: String -> a |||||
|
||||
even :: Integral a => a -> Bool |||||
|
||||
exp :: Floating a => a -> a |||||
|
||||
exponent :: RealFloat a => a -> Int |||||
|
||||
fail :: Monad m => String -> m a |||||
|
||||
filter :: (a -> Bool) -> [a] -> [a] |||||
|
||||
flip :: (a -> b -> c) -> (b -> a -> c) |||||
|
||||
floatDigits :: RealFloat a => a -> Int |||||
|
||||
floatRadix :: RealFloat a => a -> Integer |||||
|
||||
floatRange :: RealFloat a => a -> (Int, Int) |||||
|
||||
floor :: (RealFrac a, Integral b) => a -> b |||||
|
||||
fmap :: Functor f => (a -> b) -> f a -> f b |||||
|
||||
foldl :: (a -> b -> a) -> a -> [b] -> a ||||| foldl (+) 0 [a,b,c] = ((0+a)+b)+c
|
||||
foldl1 :: (a -> a -> a) -> [a] -> a ||||| foldl1 (+) [a,b,c] = (a+b)+c
|
||||
foldr :: (a -> b -> b) -> b -> [a] -> b ||||| foldr (+) 0 [a,b,c] = a+(b+(c+0))
|
||||
foldr1 :: (a -> a -> a) -> [a] -> a ||||| foldr1 (+) [a,b,c] = a+(b+c)
|
||||
fromEnum :: Enum a => a -> Int |||||
|
||||
fromInteger :: Num a => Integer -> a |||||
|
||||
fromIntegral :: (Integral a, Num b) => a -> b |||||
|
||||
fromRational :: Fractional a => Rational -> a |||||
|
||||
fst :: (a, b) -> a |||||
|
||||
gcd :: (Integral a) => a -> a -> a |||||
|
||||
getChar :: IO Char ||||| eof generates an IOError
|
||||
getContents :: IO String |||||
|
||||
getLine :: IO String ||||| eof generates an IOError
|
||||
head :: [a] -> a |||||
|
||||
id :: a -> a |||||
|
||||
init :: [a] -> [a] ||||| init "abcd" = "abc"
|
||||
interact :: (String -> String) -> IO () |||||
|
||||
ioError :: IOError -> IO a |||||
|
||||
isDenormalized :: RealFloat a => a -> Bool |||||
|
||||
isIEEE :: RealFloat a => a -> Bool |||||
|
||||
isInfinite :: RealFloat a => a -> Bool |||||
|
||||
isNaN :: RealFloat a => a -> Bool |||||
|
||||
isNegativeZero :: RealFloat a => a -> Bool |||||
|
||||
iterate :: (a -> a) -> a -> [a] ||||| iterate (++ " ") "" = ["", " ", " ",...]
|
||||
last :: [a] -> a ||||| last "abcde" = "e"
|
||||
lcm :: Integral a => a -> a -> a |||||
|
||||
length :: [a] -> Int ||||| length "Abc" = 3
|
||||
lex :: ReadS String ||||| lex "abc def" = [("abc"," def")]
|
||||
lines :: String -> [String] |||||
|
||||
log :: Floating a => a -> a |||||
|
||||
logBase :: Floating a => a -> a -> a |||||
|
||||
lookup :: Eq a => a -> [(a, b)] -> Maybe b |||||
|
||||
map :: (a -> b) -> [a] -> [b] |||||
|
||||
mapM :: Monad m => (a -> m b) -> [a] -> m [b] |||||
|
||||
mapM_ :: Monad m => (a -> m b) -> [a] -> m () |||||
|
||||
max :: Ord a => a -> a -> a |||||
|
||||
maxBound :: Bounded a => a |||||
|
||||
maximum :: Ord a => [a] -> a |||||
|
||||
maybe :: b -> (a -> b) -> Maybe a -> b ||||| maybe 0 (+1) (Just 1) = 2
|
||||
min :: Ord a => a -> a -> a |||||
|
||||
minBound :: Bounded a => a |||||
|
||||
minimum :: Ord a => [a] -> a |||||
|
||||
mod :: Integral a => a -> a -> a |||||
|
||||
negate :: Num a => a -> a |||||
|
||||
not :: Bool -> Bool |||||
|
||||
notElem :: Eq a => a -> [a] -> Bool |||||
|
||||
null :: [a] -> Bool |||||
|
||||
odd :: Integral a => a -> Bool |||||
|
||||
or :: [Bool] -> Bool |||||
|
||||
otherwise :: Bool |||||
|
||||
pi :: Floating a => a |||||
|
||||
pred :: Enum a => a -> a ||||| pred True = False
|
||||
print :: Show a => IO () ||||| adds a newline
|
||||
product :: Num a => [a] -> a |||||
|
||||
properFraction :: (RealFrac a, Integral b) => a -> (b, a) |||||
|
||||
putChar :: Char -> IO () |||||
|
||||
putStr :: String -> IO () |||||
|
||||
putStrLn :: String -> IO () ||||| adds a newline
|
||||
quot :: Integral a => a -> a -> a |||||
|
||||
quotRem :: Integral a => a -> a -> (a, a) |||||
|
||||
read :: Read a => String -> a |||||
|
||||
readFile :: FilePath -> IO String |||||
|
||||
readIO :: Read a => String -> IO a ||||| fails with IOError
|
||||
readList :: Read a => ReadS [a] |||||
|
||||
readLn :: Read a => IO a |||||
|
||||
readParen :: Bool -> ReadS a -> ReadS a |||||
|
||||
reads :: Read a => ReadS a ||||| reads "1 2" :: [(Int,String)] = [(1," 2")]
|
||||
readsPrec :: Read a => Int -> ReadS a |||||
|
||||
realToFrac :: (Real a, Fractional b) => a -> b |||||
|
||||
recip :: Fractional a => a -> a |||||
|
||||
rem :: Integral a => a -> a -> a |||||
|
||||
repeat :: a -> [a] ||||| repeat \'a\' = "aaaaaaaaa..."
|
||||
replicate :: Int -> a -> [a] ||||| replicate 4 \'a\' = "aaaa"
|
||||
return :: Monad m => a -> m a |||||
|
||||
reverse :: [a] -> [a] ||||| reverse "abc" = "cba"
|
||||
round :: (RealFrac a, Integral b) => a -> b |||||
|
||||
scaleFloat :: RealFloat a => Int -> a -> a |||||
|
||||
scanl :: (a -> b -> a) -> a -> [b] -> [a] ||||| scanl (+) 0 [1,2,3] = [0,1,3,6]
|
||||
scanl1 :: (a -> a -> a) -> [a] -> [a] ||||| scanl1 (+) [1,2,3] = [1,3,6]
|
||||
scanr :: (a -> b -> b) -> b -> [a] -> [b] ||||| scanr (+) 0 [1,2,3] = [6,5,3,0]
|
||||
scanr1 :: (a -> a -> a) -> [a] -> [a] ||||| scanr1 (+) [1,2,3] = [6,5,3]
|
||||
seq :: a -> b -> b |||||
|
||||
sequence :: Monad m => [m a] -> m [a] |||||
|
||||
sequence_ :: Monad m => [m a] -> m () ||||| do operations in sequence
|
||||
show :: Show a => a -> String |||||
|
||||
showChar :: Char -> ShowS |||||
|
||||
showList :: Show a => [a] -> ShowS |||||
|
||||
showParen :: Bool -> ShowS -> ShowS |||||
|
||||
showString :: String -> ShowS |||||
|
||||
shows :: Show a => a -> ShowS |||||
|
||||
showsPrec :: Show a => Int -> a -> ShowS |||||
|
||||
significand :: RealFloat a => a -> a |||||
|
||||
signum :: Num a => a -> a |||||
|
||||
sin :: Floating a => a -> a |||||
|
||||
sinh :: Floating a => a -> a |||||
|
||||
snd :: (a, b) -> b |||||
|
||||
span :: (a -> Bool) -> [a] -> ([a], [a]) ||||| span isAlpha "ab cd" = ("ab"," cd")
|
||||
splitAt :: Int -> [a] -> ([a], [a]) ||||| splitAt 2 "abcdef" = ("ab","cdef")
|
||||
sqrt :: Floating a => a -> a |||||
|
||||
subtract :: Num a => a -> a -> a |||||
|
||||
succ :: Enum a => a -> a ||||| succ False = True
|
||||
sum :: Num a => [a] -> a ||||| sum [1,2,3] = 6
|
||||
tail :: [a] -> [a] ||||| tail "abc" = "bc"
|
||||
take :: Int -> [a] -> [a] ||||| take 3 "abcde" = "abc"
|
||||
takeWhile :: (a -> Bool) -> [a] -> [a] ||||| takeWhile (> 2) [3,2,1] = [3]
|
||||
tan :: Floating a => a -> a |||||
|
||||
tanh :: Floating a => a -> a |||||
|
||||
toEnum :: Enum a => Int -> a ||||| toEnum 0 :: Bool = False
|
||||
toInteger :: Integral a => a -> Integer |||||
|
||||
toRational :: Real a => a -> Rational |||||
|
||||
truncate :: (RealFrac a, Integral b) => a -> b |||||
|
||||
uncurry :: (a -> b -> c) -> ((a, b) -> c) |||||
|
||||
undefined :: a |||||
|
||||
unlines :: [String] -> String |||||
|
||||
until :: (a -> Bool) -> (a -> a) -> a -> a ||||| until (> 3) (+ 2) 0 = 4
|
||||
unwords :: [String] -> String |||||
|
||||
unzip :: [(a, b)] -> ([a], [b]) ||||| unzip [(\'a\',\'b\'),(\'c\',\'d\')] = ("ac",bd")
|
||||
unzip3 :: [(a, b, c)] -> ([a], [b], [c]) |||||
|
||||
userError :: String -> IOError |||||
|
||||
words :: String -> [String] ||||| words "ab d as+3" = ["ab","d","as+3"]
|
||||
writeFile :: FilePath -> String -> IO () |||||
|
||||
zip :: [a] -> [b] -> [(a, b)] ||||| zip "abc" "de" = [(\'a\',\'d\'), (\'b\',e\')]
|
||||
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] |||||
|
||||
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] ||||| zipWith (+) [1,2] [3,4] = [4,6]
|
||||
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] |||||'
|
||||
|
||||
lookup = prelude.strip.split("\n").inject(Hash.new) { |h,l|
|
||||
name, desc = l.split("::")
|
||||
h[name.strip] = desc.split("|||||").map {|a| a.strip}
|
||||
h
|
||||
}
|
||||
|
||||
if lookup[word]
|
||||
puts lookup[word]
|
||||
else
|
||||
STDIN.each do |line|
|
||||
name, desc = line.strip.split("::")
|
||||
if name and desc
|
||||
if name.split(",").map{|s| s.strip}.include?(word)
|
||||
puts desc.strip
|
||||
exit
|
||||
end
|
||||
end
|
||||
end
|
||||
puts "☿ It is a mystery ☿"
|
||||
end
|
||||
Reference in New Issue
Block a user