fay 0.24.0.1 → 0.24.0.2
raw patch · 4 files changed
+26/−7 lines, 4 filesnew-uploaderPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
API changes (from Hackage documentation)
- Fay.Types: instance Data.Semigroup.Semigroup Fay.Types.CompileWriter
+ Fay.Compiler.Prelude: (!!) :: () => [a] -> Int -> a
+ Fay.Compiler.Prelude: ($!) :: () => a -> b -> a -> b
+ Fay.Compiler.Prelude: ($) :: () => a -> b -> a -> b
+ Fay.Compiler.Prelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ Fay.Compiler.Prelude: (&&) :: Bool -> Bool -> Bool
+ Fay.Compiler.Prelude: (*) :: Num a => a -> a -> a
+ Fay.Compiler.Prelude: (**) :: Floating a => a -> a -> a
+ Fay.Compiler.Prelude: (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
+ Fay.Compiler.Prelude: (*>) :: Applicative f => f a -> f b -> f b
+ Fay.Compiler.Prelude: (+) :: Num a => a -> a -> a
+ Fay.Compiler.Prelude: (++) :: () => [a] -> [a] -> [a]
+ Fay.Compiler.Prelude: (+++) :: ArrowChoice a => a b c -> a b' c' -> a Either b b' Either c c'
+ Fay.Compiler.Prelude: (-) :: Num a => a -> a -> a
+ Fay.Compiler.Prelude: (.) :: () => b -> c -> a -> b -> a -> c
+ Fay.Compiler.Prelude: (/) :: Fractional a => a -> a -> a
+ Fay.Compiler.Prelude: (/=) :: Eq a => a -> a -> Bool
+ Fay.Compiler.Prelude: (<$!>) :: Monad m => a -> b -> m a -> m b
+ Fay.Compiler.Prelude: (<$) :: Functor f => a -> f b -> f a
+ Fay.Compiler.Prelude: (<$>) :: Functor f => a -> b -> f a -> f b
+ Fay.Compiler.Prelude: (<) :: Ord a => a -> a -> Bool
+ Fay.Compiler.Prelude: (<*) :: Applicative f => f a -> f b -> f a
+ Fay.Compiler.Prelude: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Fay.Compiler.Prelude: (<=) :: Ord a => a -> a -> Bool
+ Fay.Compiler.Prelude: (<=<) :: Monad m => b -> m c -> a -> m b -> a -> m c
+ Fay.Compiler.Prelude: (<>) :: Semigroup a => a -> a -> a
+ Fay.Compiler.Prelude: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Fay.Compiler.Prelude: (==) :: Eq a => a -> a -> Bool
+ Fay.Compiler.Prelude: (>) :: Ord a => a -> a -> Bool
+ Fay.Compiler.Prelude: (>=) :: Ord a => a -> a -> Bool
+ Fay.Compiler.Prelude: (>=>) :: Monad m => a -> m b -> b -> m c -> a -> m c
+ Fay.Compiler.Prelude: (>>) :: Monad m => m a -> m b -> m b
+ Fay.Compiler.Prelude: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Fay.Compiler.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ Fay.Compiler.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Fay.Compiler.Prelude: (||) :: Bool -> Bool -> Bool
+ Fay.Compiler.Prelude: (|||) :: ArrowChoice a => a b d -> a c d -> a Either b c d
+ Fay.Compiler.Prelude: EQ :: Ordering
+ Fay.Compiler.Prelude: False :: Bool
+ Fay.Compiler.Prelude: GT :: Ordering
+ Fay.Compiler.Prelude: Just :: a -> Maybe a
+ Fay.Compiler.Prelude: LT :: Ordering
+ Fay.Compiler.Prelude: Left :: a -> Either a b
+ Fay.Compiler.Prelude: Nothing :: Maybe a
+ Fay.Compiler.Prelude: Right :: b -> Either a b
+ Fay.Compiler.Prelude: True :: Bool
+ Fay.Compiler.Prelude: abs :: Num a => a -> a
+ Fay.Compiler.Prelude: acos :: Floating a => a -> a
+ Fay.Compiler.Prelude: acosh :: Floating a => a -> a
+ Fay.Compiler.Prelude: all :: Foldable t => a -> Bool -> t a -> Bool
+ Fay.Compiler.Prelude: and :: Foldable t => t Bool -> Bool
+ Fay.Compiler.Prelude: any :: Foldable t => a -> Bool -> t a -> Bool
+ Fay.Compiler.Prelude: ap :: Monad m => m a -> b -> m a -> m b
+ Fay.Compiler.Prelude: appendFile :: FilePath -> String -> IO ()
+ Fay.Compiler.Prelude: asTypeOf :: () => a -> a -> a
+ Fay.Compiler.Prelude: asin :: Floating a => a -> a
+ Fay.Compiler.Prelude: asinh :: Floating a => a -> a
+ Fay.Compiler.Prelude: atan :: Floating a => a -> a
+ Fay.Compiler.Prelude: atan2 :: RealFloat a => a -> a -> a
+ Fay.Compiler.Prelude: atanh :: Floating a => a -> a
+ Fay.Compiler.Prelude: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Fay.Compiler.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Fay.Compiler.Prelude: chr :: Int -> Char
+ Fay.Compiler.Prelude: class Functor f => Applicative (f :: * -> *)
+ Fay.Compiler.Prelude: class Bounded a
+ Fay.Compiler.Prelude: class Typeable a => Data a
+ Fay.Compiler.Prelude: class Enum a
+ Fay.Compiler.Prelude: class Eq a
+ Fay.Compiler.Prelude: class Fractional a => Floating a
+ Fay.Compiler.Prelude: class Foldable (t :: * -> *)
+ Fay.Compiler.Prelude: class Num a => Fractional a
+ Fay.Compiler.Prelude: class Functor (f :: * -> *)
+ Fay.Compiler.Prelude: class (Real a, Enum a) => Integral a
+ Fay.Compiler.Prelude: class Applicative m => Monad (m :: * -> *)
+ Fay.Compiler.Prelude: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)
+ Fay.Compiler.Prelude: class Semigroup a => Monoid a
+ Fay.Compiler.Prelude: class Num a
+ Fay.Compiler.Prelude: class Eq a => Ord a
+ Fay.Compiler.Prelude: class Read a
+ Fay.Compiler.Prelude: class (Num a, Ord a) => Real a
+ Fay.Compiler.Prelude: class (RealFrac a, Floating a) => RealFloat a
+ Fay.Compiler.Prelude: class (Real a, Fractional a) => RealFrac a
+ Fay.Compiler.Prelude: class Semigroup a
+ Fay.Compiler.Prelude: class Show a
+ Fay.Compiler.Prelude: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Fay.Compiler.Prelude: class Typeable (a :: k)
+ Fay.Compiler.Prelude: compare :: Ord a => a -> a -> Ordering
+ Fay.Compiler.Prelude: concat :: Foldable t => t [a] -> [a]
+ Fay.Compiler.Prelude: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Fay.Compiler.Prelude: const :: () => a -> b -> a
+ Fay.Compiler.Prelude: cos :: Floating a => a -> a
+ Fay.Compiler.Prelude: cosh :: Floating a => a -> a
+ Fay.Compiler.Prelude: curry :: () => (a, b) -> c -> a -> b -> c
+ Fay.Compiler.Prelude: cycle :: () => [a] -> [a]
+ Fay.Compiler.Prelude: data Bool
+ Fay.Compiler.Prelude: data Char
+ Fay.Compiler.Prelude: data Double
+ Fay.Compiler.Prelude: data Either a b
+ Fay.Compiler.Prelude: data Float
+ Fay.Compiler.Prelude: data IO a
+ Fay.Compiler.Prelude: data Int
+ Fay.Compiler.Prelude: data Integer
+ Fay.Compiler.Prelude: data Maybe a
+ Fay.Compiler.Prelude: data Ordering
+ Fay.Compiler.Prelude: data Word
+ Fay.Compiler.Prelude: dataCast1 :: (Data a, Typeable t) => forall d. Data d => c t d -> Maybe c a
+ Fay.Compiler.Prelude: dataCast2 :: (Data a, Typeable t) => forall d e. (Data d, Data e) => c t d e -> Maybe c a
+ Fay.Compiler.Prelude: dataTypeOf :: Data a => a -> DataType
+ Fay.Compiler.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Fay.Compiler.Prelude: digitToInt :: Char -> Int
+ Fay.Compiler.Prelude: div :: Integral a => a -> a -> a
+ Fay.Compiler.Prelude: divMod :: Integral a => a -> a -> (a, a)
+ Fay.Compiler.Prelude: drop :: () => Int -> [a] -> [a]
+ Fay.Compiler.Prelude: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Fay.Compiler.Prelude: either :: () => a -> c -> b -> c -> Either a b -> c
+ Fay.Compiler.Prelude: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Fay.Compiler.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Fay.Compiler.Prelude: enumFrom :: Enum a => a -> [a]
+ Fay.Compiler.Prelude: enumFromThen :: Enum a => a -> a -> [a]
+ Fay.Compiler.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Fay.Compiler.Prelude: enumFromTo :: Enum a => a -> a -> [a]
+ Fay.Compiler.Prelude: error :: HasCallStack => [Char] -> a
+ Fay.Compiler.Prelude: errorWithoutStackTrace :: () => [Char] -> a
+ Fay.Compiler.Prelude: even :: Integral a => a -> Bool
+ Fay.Compiler.Prelude: exponent :: RealFloat a => a -> Int
+ Fay.Compiler.Prelude: fail :: Monad m => String -> m a
+ Fay.Compiler.Prelude: filter :: () => a -> Bool -> [a] -> [a]
+ Fay.Compiler.Prelude: filterM :: Applicative m => a -> m Bool -> [a] -> m [a]
+ Fay.Compiler.Prelude: first :: Arrow a => a b c -> a (b, d) (c, d)
+ Fay.Compiler.Prelude: flip :: () => a -> b -> c -> b -> a -> c
+ Fay.Compiler.Prelude: floatDigits :: RealFloat a => a -> Int
+ Fay.Compiler.Prelude: floatRadix :: RealFloat a => a -> Integer
+ Fay.Compiler.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
+ Fay.Compiler.Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ Fay.Compiler.Prelude: fmap :: Functor f => a -> b -> f a -> f b
+ Fay.Compiler.Prelude: foldM :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m b
+ Fay.Compiler.Prelude: foldM_ :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m ()
+ Fay.Compiler.Prelude: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Fay.Compiler.Prelude: foldl :: Foldable t => b -> a -> b -> b -> t a -> b
+ Fay.Compiler.Prelude: foldl1 :: Foldable t => a -> a -> a -> t a -> a
+ Fay.Compiler.Prelude: foldr :: Foldable t => a -> b -> b -> b -> t a -> b
+ Fay.Compiler.Prelude: foldr1 :: Foldable t => a -> a -> a -> t a -> a
+ Fay.Compiler.Prelude: forM :: (Traversable t, Monad m) => t a -> a -> m b -> m t b
+ Fay.Compiler.Prelude: forM_ :: (Foldable t, Monad m) => t a -> a -> m b -> m ()
+ Fay.Compiler.Prelude: forever :: Applicative f => f a -> f b
+ Fay.Compiler.Prelude: fromEnum :: Enum a => a -> Int
+ Fay.Compiler.Prelude: fromInteger :: Num a => Integer -> a
+ Fay.Compiler.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ Fay.Compiler.Prelude: fromRational :: Fractional a => Rational -> a
+ Fay.Compiler.Prelude: fst :: () => (a, b) -> a
+ Fay.Compiler.Prelude: gcd :: Integral a => a -> a -> a
+ Fay.Compiler.Prelude: generalCategory :: Char -> GeneralCategory
+ Fay.Compiler.Prelude: getChar :: IO Char
+ Fay.Compiler.Prelude: getContents :: IO String
+ Fay.Compiler.Prelude: getLine :: IO String
+ Fay.Compiler.Prelude: gfoldl :: Data a => forall d b. Data d => c d -> b -> d -> c b -> forall g. () => g -> c g -> a -> c a
+ Fay.Compiler.Prelude: gmapM :: (Data a, Monad m) => forall d. Data d => d -> m d -> a -> m a
+ Fay.Compiler.Prelude: gmapMo :: (Data a, MonadPlus m) => forall d. Data d => d -> m d -> a -> m a
+ Fay.Compiler.Prelude: gmapMp :: (Data a, MonadPlus m) => forall d. Data d => d -> m d -> a -> m a
+ Fay.Compiler.Prelude: gmapQ :: Data a => forall d. Data d => d -> u -> a -> [u]
+ Fay.Compiler.Prelude: gmapQi :: Data a => Int -> forall d. Data d => d -> u -> a -> u
+ Fay.Compiler.Prelude: gmapQl :: Data a => r -> r' -> r -> r -> forall d. Data d => d -> r' -> a -> r
+ Fay.Compiler.Prelude: gmapQr :: Data a => r' -> r -> r -> r -> forall d. Data d => d -> r' -> a -> r
+ Fay.Compiler.Prelude: gmapT :: Data a => forall b. Data b => b -> b -> a -> a
+ Fay.Compiler.Prelude: gunfold :: Data a => forall b r. Data b => c b -> r -> c r -> forall r. () => r -> c r -> Constr -> c a
+ Fay.Compiler.Prelude: head :: () => [a] -> a
+ Fay.Compiler.Prelude: id :: () => a -> a
+ Fay.Compiler.Prelude: infix 4 `notElem`
+ Fay.Compiler.Prelude: infixl 0 `on`
+ Fay.Compiler.Prelude: infixl 4 <$!>
+ Fay.Compiler.Prelude: infixl 9 !!
+ Fay.Compiler.Prelude: infixr 0 $
+ Fay.Compiler.Prelude: infixr 1 =<<
+ Fay.Compiler.Prelude: infixr 2 +++
+ Fay.Compiler.Prelude: infixr 3 &&&
+ Fay.Compiler.Prelude: infixr 5 ++
+ Fay.Compiler.Prelude: infixr 8 ^
+ Fay.Compiler.Prelude: infixr 9 .
+ Fay.Compiler.Prelude: init :: () => [a] -> [a]
+ Fay.Compiler.Prelude: intToDigit :: Int -> Char
+ Fay.Compiler.Prelude: interact :: String -> String -> IO ()
+ Fay.Compiler.Prelude: ioError :: () => IOError -> IO a
+ Fay.Compiler.Prelude: isAlpha :: Char -> Bool
+ Fay.Compiler.Prelude: isAlphaNum :: Char -> Bool
+ Fay.Compiler.Prelude: isAscii :: Char -> Bool
+ Fay.Compiler.Prelude: isAsciiLower :: Char -> Bool
+ Fay.Compiler.Prelude: isAsciiUpper :: Char -> Bool
+ Fay.Compiler.Prelude: isControl :: Char -> Bool
+ Fay.Compiler.Prelude: isDenormalized :: RealFloat a => a -> Bool
+ Fay.Compiler.Prelude: isDigit :: Char -> Bool
+ Fay.Compiler.Prelude: isHexDigit :: Char -> Bool
+ Fay.Compiler.Prelude: isIEEE :: RealFloat a => a -> Bool
+ Fay.Compiler.Prelude: isInfinite :: RealFloat a => a -> Bool
+ Fay.Compiler.Prelude: isLatin1 :: Char -> Bool
+ Fay.Compiler.Prelude: isLetter :: Char -> Bool
+ Fay.Compiler.Prelude: isLower :: Char -> Bool
+ Fay.Compiler.Prelude: isMark :: Char -> Bool
+ Fay.Compiler.Prelude: isNaN :: RealFloat a => a -> Bool
+ Fay.Compiler.Prelude: isNegativeZero :: RealFloat a => a -> Bool
+ Fay.Compiler.Prelude: isNumber :: Char -> Bool
+ Fay.Compiler.Prelude: isOctDigit :: Char -> Bool
+ Fay.Compiler.Prelude: isPrint :: Char -> Bool
+ Fay.Compiler.Prelude: isPunctuation :: Char -> Bool
+ Fay.Compiler.Prelude: isSeparator :: Char -> Bool
+ Fay.Compiler.Prelude: isSpace :: Char -> Bool
+ Fay.Compiler.Prelude: isSymbol :: Char -> Bool
+ Fay.Compiler.Prelude: isUpper :: Char -> Bool
+ Fay.Compiler.Prelude: iterate :: () => a -> a -> a -> [a]
+ Fay.Compiler.Prelude: join :: Monad m => m m a -> m a
+ Fay.Compiler.Prelude: last :: () => [a] -> a
+ Fay.Compiler.Prelude: lcm :: Integral a => a -> a -> a
+ Fay.Compiler.Prelude: length :: Foldable t => t a -> Int
+ Fay.Compiler.Prelude: lex :: ReadS String
+ Fay.Compiler.Prelude: lexLitChar :: ReadS String
+ Fay.Compiler.Prelude: liftM :: Monad m => a1 -> r -> m a1 -> m r
+ Fay.Compiler.Prelude: liftM2 :: Monad m => a1 -> a2 -> r -> m a1 -> m a2 -> m r
+ Fay.Compiler.Prelude: liftM3 :: Monad m => a1 -> a2 -> a3 -> r -> m a1 -> m a2 -> m a3 -> m r
+ Fay.Compiler.Prelude: liftM4 :: Monad m => a1 -> a2 -> a3 -> a4 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m r
+ Fay.Compiler.Prelude: liftM5 :: Monad m => a1 -> a2 -> a3 -> a4 -> a5 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
+ Fay.Compiler.Prelude: lines :: String -> [String]
+ Fay.Compiler.Prelude: log :: Floating a => a -> a
+ Fay.Compiler.Prelude: logBase :: Floating a => a -> a -> a
+ Fay.Compiler.Prelude: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Fay.Compiler.Prelude: map :: () => a -> b -> [a] -> [b]
+ Fay.Compiler.Prelude: mapAndUnzipM :: Applicative m => a -> m (b, c) -> [a] -> m ([b], [c])
+ Fay.Compiler.Prelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Fay.Compiler.Prelude: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Fay.Compiler.Prelude: mappend :: Monoid a => a -> a -> a
+ Fay.Compiler.Prelude: max :: Ord a => a -> a -> a
+ Fay.Compiler.Prelude: maxBound :: Bounded a => a
+ Fay.Compiler.Prelude: maximum :: (Foldable t, Ord a) => t a -> a
+ Fay.Compiler.Prelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ Fay.Compiler.Prelude: mconcat :: Monoid a => [a] -> a
+ Fay.Compiler.Prelude: mempty :: Monoid a => a
+ Fay.Compiler.Prelude: mfilter :: MonadPlus m => a -> Bool -> m a -> m a
+ Fay.Compiler.Prelude: min :: Ord a => a -> a -> a
+ Fay.Compiler.Prelude: minBound :: Bounded a => a
+ Fay.Compiler.Prelude: minimum :: (Foldable t, Ord a) => t a -> a
+ Fay.Compiler.Prelude: mplus :: MonadPlus m => m a -> m a -> m a
+ Fay.Compiler.Prelude: msum :: (Foldable t, MonadPlus m) => t m a -> m a
+ Fay.Compiler.Prelude: mzero :: MonadPlus m => m a
+ Fay.Compiler.Prelude: negate :: Num a => a -> a
+ Fay.Compiler.Prelude: not :: Bool -> Bool
+ Fay.Compiler.Prelude: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Fay.Compiler.Prelude: null :: Foldable t => t a -> Bool
+ Fay.Compiler.Prelude: odd :: Integral a => a -> Bool
+ Fay.Compiler.Prelude: on :: () => b -> b -> c -> a -> b -> a -> a -> c
+ Fay.Compiler.Prelude: or :: Foldable t => t Bool -> Bool
+ Fay.Compiler.Prelude: ord :: Char -> Int
+ Fay.Compiler.Prelude: otherwise :: Bool
+ Fay.Compiler.Prelude: pi :: Floating a => a
+ Fay.Compiler.Prelude: pred :: Enum a => a -> a
+ Fay.Compiler.Prelude: print :: Show a => a -> IO ()
+ Fay.Compiler.Prelude: product :: (Foldable t, Num a) => t a -> a
+ Fay.Compiler.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Fay.Compiler.Prelude: pure :: Applicative f => a -> f a
+ Fay.Compiler.Prelude: putChar :: Char -> IO ()
+ Fay.Compiler.Prelude: putStr :: String -> IO ()
+ Fay.Compiler.Prelude: putStrLn :: String -> IO ()
+ Fay.Compiler.Prelude: quot :: Integral a => a -> a -> a
+ Fay.Compiler.Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ Fay.Compiler.Prelude: read :: Read a => String -> a
+ Fay.Compiler.Prelude: readFile :: FilePath -> IO String
+ Fay.Compiler.Prelude: readIO :: Read a => String -> IO a
+ Fay.Compiler.Prelude: readList :: Read a => ReadS [a]
+ Fay.Compiler.Prelude: readLitChar :: ReadS Char
+ Fay.Compiler.Prelude: readLn :: Read a => IO a
+ Fay.Compiler.Prelude: readParen :: () => Bool -> ReadS a -> ReadS a
+ Fay.Compiler.Prelude: reads :: Read a => ReadS a
+ Fay.Compiler.Prelude: readsPrec :: Read a => Int -> ReadS a
+ Fay.Compiler.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
+ Fay.Compiler.Prelude: recip :: Fractional a => a -> a
+ Fay.Compiler.Prelude: rem :: Integral a => a -> a -> a
+ Fay.Compiler.Prelude: repeat :: () => a -> [a]
+ Fay.Compiler.Prelude: replicate :: () => Int -> a -> [a]
+ Fay.Compiler.Prelude: replicateM :: Applicative m => Int -> m a -> m [a]
+ Fay.Compiler.Prelude: replicateM_ :: Applicative m => Int -> m a -> m ()
+ Fay.Compiler.Prelude: return :: Monad m => a -> m a
+ Fay.Compiler.Prelude: reverse :: () => [a] -> [a]
+ Fay.Compiler.Prelude: round :: (RealFrac a, Integral b) => a -> b
+ Fay.Compiler.Prelude: scaleFloat :: RealFloat a => Int -> a -> a
+ Fay.Compiler.Prelude: scanl :: () => b -> a -> b -> b -> [a] -> [b]
+ Fay.Compiler.Prelude: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Fay.Compiler.Prelude: scanr :: () => a -> b -> b -> b -> [a] -> [b]
+ Fay.Compiler.Prelude: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Fay.Compiler.Prelude: second :: Arrow a => a b c -> a (d, b) (d, c)
+ Fay.Compiler.Prelude: seq :: () => a -> b -> b
+ Fay.Compiler.Prelude: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Fay.Compiler.Prelude: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Fay.Compiler.Prelude: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Fay.Compiler.Prelude: show :: Show a => a -> String
+ Fay.Compiler.Prelude: showChar :: Char -> ShowS
+ Fay.Compiler.Prelude: showList :: Show a => [a] -> ShowS
+ Fay.Compiler.Prelude: showLitChar :: Char -> ShowS
+ Fay.Compiler.Prelude: showParen :: Bool -> ShowS -> ShowS
+ Fay.Compiler.Prelude: showString :: String -> ShowS
+ Fay.Compiler.Prelude: shows :: Show a => a -> ShowS
+ Fay.Compiler.Prelude: showsPrec :: Show a => Int -> a -> ShowS
+ Fay.Compiler.Prelude: significand :: RealFloat a => a -> a
+ Fay.Compiler.Prelude: signum :: Num a => a -> a
+ Fay.Compiler.Prelude: sin :: Floating a => a -> a
+ Fay.Compiler.Prelude: sinh :: Floating a => a -> a
+ Fay.Compiler.Prelude: snd :: () => (a, b) -> b
+ Fay.Compiler.Prelude: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Fay.Compiler.Prelude: splitAt :: () => Int -> [a] -> ([a], [a])
+ Fay.Compiler.Prelude: sqrt :: Floating a => a -> a
+ Fay.Compiler.Prelude: subtract :: Num a => a -> a -> a
+ Fay.Compiler.Prelude: succ :: Enum a => a -> a
+ Fay.Compiler.Prelude: sum :: (Foldable t, Num a) => t a -> a
+ Fay.Compiler.Prelude: tail :: () => [a] -> [a]
+ Fay.Compiler.Prelude: take :: () => Int -> [a] -> [a]
+ Fay.Compiler.Prelude: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Fay.Compiler.Prelude: tan :: Floating a => a -> a
+ Fay.Compiler.Prelude: tanh :: Floating a => a -> a
+ Fay.Compiler.Prelude: toConstr :: Data a => a -> Constr
+ Fay.Compiler.Prelude: toEnum :: Enum a => Int -> a
+ Fay.Compiler.Prelude: toInteger :: Integral a => a -> Integer
+ Fay.Compiler.Prelude: toLower :: Char -> Char
+ Fay.Compiler.Prelude: toRational :: Real a => a -> Rational
+ Fay.Compiler.Prelude: toTitle :: Char -> Char
+ Fay.Compiler.Prelude: toUpper :: Char -> Char
+ Fay.Compiler.Prelude: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Fay.Compiler.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ Fay.Compiler.Prelude: type FilePath = String
+ Fay.Compiler.Prelude: type IOError = IOException
+ Fay.Compiler.Prelude: type Rational = Ratio Integer
+ Fay.Compiler.Prelude: type ReadS a = String -> [(a, String)]
+ Fay.Compiler.Prelude: type ShowS = String -> String
+ Fay.Compiler.Prelude: type String = [Char]
+ Fay.Compiler.Prelude: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Fay.Compiler.Prelude: undefined :: HasCallStack => a
+ Fay.Compiler.Prelude: unless :: Applicative f => Bool -> f () -> f ()
+ Fay.Compiler.Prelude: unlines :: [String] -> String
+ Fay.Compiler.Prelude: until :: () => a -> Bool -> a -> a -> a -> a
+ Fay.Compiler.Prelude: unwords :: [String] -> String
+ Fay.Compiler.Prelude: unzip :: () => [(a, b)] -> ([a], [b])
+ Fay.Compiler.Prelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ Fay.Compiler.Prelude: userError :: String -> IOError
+ Fay.Compiler.Prelude: void :: Functor f => f a -> f ()
+ Fay.Compiler.Prelude: when :: Applicative f => Bool -> f () -> f ()
+ Fay.Compiler.Prelude: words :: String -> [String]
+ Fay.Compiler.Prelude: writeFile :: FilePath -> String -> IO ()
+ Fay.Compiler.Prelude: zip :: () => [a] -> [b] -> [(a, b)]
+ Fay.Compiler.Prelude: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ Fay.Compiler.Prelude: zipWith :: () => a -> b -> c -> [a] -> [b] -> [c]
+ Fay.Compiler.Prelude: zipWith3 :: () => a -> b -> c -> d -> [a] -> [b] -> [c] -> [d]
+ Fay.Compiler.Prelude: zipWithM :: Applicative m => a -> b -> m c -> [a] -> [b] -> m [c]
+ Fay.Compiler.Prelude: zipWithM_ :: Applicative m => a -> b -> m c -> [a] -> [b] -> m ()
+ Fay.Types: instance GHC.Base.Semigroup Fay.Types.CompileWriter
- Fay.Types: CompileReader :: Config -> (Sign -> Literal -> Compile JsExp) -> (Bool -> [Decl] -> Compile [JsStmt]) -> CompileReader
+ Fay.Types: CompileReader :: Config -> Sign -> Literal -> Compile JsExp -> Bool -> [Decl] -> Compile [JsStmt] -> CompileReader
Files
- CHANGELOG.md +4/−0
- fay.cabal +1/−1
- src/Fay/Compiler/Packages.hs +11/−3
- src/Fay/Compiler/Typecheck.hs +10/−3
CHANGELOG.md view
@@ -2,6 +2,10 @@ See full history at: <https://github.com/faylang/fay/commits> +#### 0.24.0.2++* Fix dependent compilation fail when building project with stack (#457).+ #### 0.24.0.1 * Dependency updates incl GHC 8.4 support
fay.cabal view
@@ -1,5 +1,5 @@ name: fay-version: 0.24.0.1+version: 0.24.0.2 synopsis: A compiler for Fay, a Haskell subset that compiles to JavaScript. description: Fay is a proper subset of Haskell which is type-checked with GHC, and compiled to JavaScript. It is lazy, pure, has a Fay monad,
src/Fay/Compiler/Packages.hs view
@@ -55,12 +55,20 @@ describePackage :: Maybe FilePath -> String -> IO String describePackage db name = do exists <- doesFileExist ghc_pkg- result <- readAllFromProcess (if exists then ghc_pkg else "ghc-pkg") args ""+ let command = if exists+ then if (isInfixOf ".stack" ghc_pkg)+ then "stack"+ else ghc_pkg+ else "ghc-pkg"+ extraArgs = case command of+ "stack" -> ["exec","--","ghc-pkg"]+ _ -> []+ args = extraArgs ++ ["describe",name] ++ ["--expand-env-vars", "-v2"]+ ++ ["--package-db=" ++ db' | Just db' <- [db]]+ result <- readAllFromProcess command args "" case result of Left (err,out) -> error $ "ghc-pkg describe error:\n" ++ err ++ "\n" ++ out Right (_err,out) -> return out-- where args = ["describe",name] ++ ["-f" ++ db' | Just db' <- [db]] -- | Get the package version from the package description. packageVersion :: String -> Maybe String
src/Fay/Compiler/Typecheck.hs view
@@ -40,10 +40,17 @@ , "-i" ++ intercalate ":" includeDirs , fp ] ++ ghcPackageDbArgs ++ wallF ++ map ("-package " ++) packages exists <- doesFileExist GHCPaths.ghc- let ghcPath = if exists then GHCPaths.ghc else "ghc"+ let ghcPath = if exists+ then if (isInfixOf ".stack" GHCPaths.ghc)+ then "stack"+ else GHCPaths.ghc+ else "ghc"+ extraFlags = case ghcPath of+ "stack" -> ["exec","--","ghc"]+ _ -> [] when (configShowGhcCalls cfg) $- putStrLn . unwords $ ghcPath : flags- res <- readAllFromProcess ghcPath flags ""+ putStrLn . unwords $ ghcPath : (extraFlags ++ flags)+ res <- readAllFromProcess ghcPath (extraFlags ++ flags) "" either (return . Left . GHCError . fst) (return . Right . fst) res where wallF | configWall cfg = ["-Wall"]