ihaskell 0.12.0.0 → 0.13.0.0
raw patch · 4 files changed
+18/−9 lines, 4 filesdep ~ghcdep ~ipython-kernelPVP ok
version bump matches the API change (PVP)
Dependency ranges changed: ghc, ipython-kernel
API changes (from Hackage documentation)
- IHaskellPrelude: (%) :: Integral a => a -> a -> Ratio a
- IHaskellPrelude: (*) :: Num a => a -> a -> a
- IHaskellPrelude: (+) :: Num a => a -> a -> a
- IHaskellPrelude: (-) :: Num a => a -> a -> a
- IHaskellPrelude: (/) :: Fractional a => a -> a -> a
- IHaskellPrelude: (:%) :: !a -> !a -> Ratio a
- IHaskellPrelude: (<$!>) :: Monad m => (a -> b) -> m a -> m b
- IHaskellPrelude: (<$) :: Functor f => a -> f b -> f a
- IHaskellPrelude: (<) :: Ord a => a -> a -> Bool
- IHaskellPrelude: (<=) :: Ord a => a -> a -> Bool
- IHaskellPrelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- IHaskellPrelude: (<>) :: Semigroup a => a -> a -> a
- IHaskellPrelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- IHaskellPrelude: (>) :: Ord a => a -> a -> Bool
- IHaskellPrelude: (>=) :: Ord a => a -> a -> Bool
- IHaskellPrelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- IHaskellPrelude: (>>) :: Monad m => m a -> m b -> m b
- IHaskellPrelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- IHaskellPrelude: (^%^) :: Integral a => Rational -> a -> Rational
- IHaskellPrelude: (^) :: (Num a, Integral b) => a -> b -> a
- IHaskellPrelude: (^^%^^) :: Integral a => Rational -> a -> Rational
- IHaskellPrelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
- IHaskellPrelude: All :: Bool -> All
- IHaskellPrelude: Any :: Bool -> Any
- IHaskellPrelude: Arg :: a -> b -> Arg a b
- IHaskellPrelude: Base10 :: FractionalExponentBase
- IHaskellPrelude: Base2 :: FractionalExponentBase
- IHaskellPrelude: Down :: a -> Down a
- IHaskellPrelude: Dual :: a -> Dual a
- IHaskellPrelude: EQ :: Ordering
- IHaskellPrelude: Endo :: (a -> a) -> Endo a
- IHaskellPrelude: First :: a -> First a
- IHaskellPrelude: GT :: Ordering
- IHaskellPrelude: IN :: ByteArray# -> Integer
- IHaskellPrelude: IP :: ByteArray# -> Integer
- IHaskellPrelude: IS :: Int# -> Integer
- IHaskellPrelude: Just :: a -> Maybe a
- IHaskellPrelude: LT :: Ordering
- IHaskellPrelude: Last :: a -> Last a
- IHaskellPrelude: Left :: a -> Either a b
- IHaskellPrelude: Max :: a -> Max a
- IHaskellPrelude: Min :: a -> Min a
- IHaskellPrelude: NB :: ByteArray# -> Natural
- IHaskellPrelude: NS :: Word# -> Natural
- IHaskellPrelude: Nothing :: Maybe a
- IHaskellPrelude: Product :: a -> Product a
- IHaskellPrelude: Right :: b -> Either a b
- IHaskellPrelude: Sum :: a -> Sum a
- IHaskellPrelude: WrapMonoid :: m -> WrappedMonoid m
- IHaskellPrelude: [appEndo] :: Endo a -> a -> a
- IHaskellPrelude: [getAll] :: All -> Bool
- IHaskellPrelude: [getAny] :: Any -> Bool
- IHaskellPrelude: [getDown] :: Down a -> a
- IHaskellPrelude: [getDual] :: Dual a -> a
- IHaskellPrelude: [getFirst] :: First a -> a
- IHaskellPrelude: [getLast] :: Last a -> a
- IHaskellPrelude: [getMax] :: Max a -> a
- IHaskellPrelude: [getMin] :: Min a -> a
- IHaskellPrelude: [getProduct] :: Product a -> a
- IHaskellPrelude: [getSum] :: Sum a -> a
- IHaskellPrelude: [unwrapMonoid] :: WrappedMonoid m -> m
- IHaskellPrelude: abs :: Num a => a -> a
- IHaskellPrelude: absentErr :: a
- IHaskellPrelude: ap :: Monad m => m (a -> b) -> m a -> m b
- IHaskellPrelude: appPrec :: Int
- IHaskellPrelude: appPrec1 :: Int
- IHaskellPrelude: asciiTab :: [String]
- IHaskellPrelude: boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
- IHaskellPrelude: boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
- IHaskellPrelude: catMaybes :: [Maybe a] -> [a]
- IHaskellPrelude: ceiling :: (RealFrac a, Integral b) => a -> b
- IHaskellPrelude: clamp :: Ord a => (a, a) -> a -> a
- IHaskellPrelude: class () => Bounded a
- IHaskellPrelude: class () => Enum a
- IHaskellPrelude: class Num a => Fractional a
- IHaskellPrelude: class () => Functor (f :: Type -> Type)
- IHaskellPrelude: class (Real a, Enum a) => Integral a
- IHaskellPrelude: class Applicative m => Monad (m :: Type -> Type)
- IHaskellPrelude: class Monad m => MonadFail (m :: Type -> Type)
- IHaskellPrelude: class Monad m => MonadIO (m :: Type -> Type)
- IHaskellPrelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
- IHaskellPrelude: class () => Num a
- IHaskellPrelude: class Eq a => Ord a
- IHaskellPrelude: class (Num a, Ord a) => Real a
- IHaskellPrelude: class (Real a, Fractional a) => RealFrac a
- IHaskellPrelude: class () => Semigroup a
- IHaskellPrelude: class () => Show a
- IHaskellPrelude: compare :: Ord a => a -> a -> Ordering
- IHaskellPrelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- IHaskellPrelude: cycle1 :: Semigroup m => m -> m
- IHaskellPrelude: data () => Arg a b
- IHaskellPrelude: data () => Either a b
- IHaskellPrelude: data () => FractionalExponentBase
- IHaskellPrelude: data () => Integer
- IHaskellPrelude: data () => Maybe a
- IHaskellPrelude: data () => Natural
- IHaskellPrelude: data () => Ordering
- IHaskellPrelude: data () => Ratio a
- IHaskellPrelude: denominator :: Ratio a -> a
- IHaskellPrelude: diff :: Semigroup m => m -> Endo m
- IHaskellPrelude: div :: Integral a => a -> a -> a
- IHaskellPrelude: divMod :: Integral a => a -> a -> (a, a)
- IHaskellPrelude: divZeroError :: a
- IHaskellPrelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- IHaskellPrelude: enumFrom :: Enum a => a -> [a]
- IHaskellPrelude: enumFromThen :: Enum a => a -> a -> [a]
- IHaskellPrelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
- IHaskellPrelude: enumFromTo :: Enum a => a -> a -> [a]
- IHaskellPrelude: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- IHaskellPrelude: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
- IHaskellPrelude: even :: Integral a => a -> Bool
- IHaskellPrelude: fail :: MonadFail m => String -> m a
- IHaskellPrelude: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- IHaskellPrelude: floor :: (RealFrac a, Integral b) => a -> b
- IHaskellPrelude: fmap :: Functor f => (a -> b) -> f a -> f b
- IHaskellPrelude: foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- IHaskellPrelude: foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- IHaskellPrelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- IHaskellPrelude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- IHaskellPrelude: forever :: Applicative f => f a -> f b
- IHaskellPrelude: fromEnum :: Enum a => a -> Int
- IHaskellPrelude: fromEnumError :: Show a => String -> a -> b
- IHaskellPrelude: fromInteger :: Num a => Integer -> a
- IHaskellPrelude: fromIntegral :: (Integral a, Num b) => a -> b
- IHaskellPrelude: fromJust :: HasCallStack => Maybe a -> a
- IHaskellPrelude: fromLeft :: a -> Either a b -> a
- IHaskellPrelude: fromMaybe :: a -> Maybe a -> a
- IHaskellPrelude: fromRational :: Fractional a => Rational -> a
- IHaskellPrelude: fromRight :: b -> Either a b -> b
- IHaskellPrelude: gcd :: Integral a => a -> a -> a
- IHaskellPrelude: guard :: Alternative f => Bool -> f ()
- IHaskellPrelude: infinity :: Rational
- IHaskellPrelude: infixl 1 >>
- IHaskellPrelude: infixr 1 <=<
- IHaskellPrelude: infixr 6 <>
- IHaskellPrelude: infixr 8 ^^
- IHaskellPrelude: intToDigit :: Int -> Char
- IHaskellPrelude: integerAbs :: Integer -> Integer
- IHaskellPrelude: integerAdd :: Integer -> Integer -> Integer
- IHaskellPrelude: integerAnd :: Integer -> Integer -> Integer
- IHaskellPrelude: integerBit :: Word -> Integer
- IHaskellPrelude: integerBit# :: Word# -> Integer
- IHaskellPrelude: integerCheck :: Integer -> Bool
- IHaskellPrelude: integerCheck# :: Integer -> Bool#
- IHaskellPrelude: integerCompare :: Integer -> Integer -> Ordering
- IHaskellPrelude: integerComplement :: Integer -> Integer
- IHaskellPrelude: integerDecodeDouble# :: Double# -> (# Integer, Int# #)
- IHaskellPrelude: integerDiv :: Integer -> Integer -> Integer
- IHaskellPrelude: integerDivMod :: Integer -> Integer -> (Integer, Integer)
- IHaskellPrelude: integerDivMod# :: Integer -> Integer -> (# Integer, Integer #)
- IHaskellPrelude: integerEncodeDouble :: Integer -> Int -> Double
- IHaskellPrelude: integerEncodeDouble# :: Integer -> Int# -> Double#
- IHaskellPrelude: integerEncodeFloat# :: Integer -> Int# -> Float#
- IHaskellPrelude: integerEq :: Integer -> Integer -> Bool
- IHaskellPrelude: integerEq# :: Integer -> Integer -> Bool#
- IHaskellPrelude: integerFromAddr :: Word# -> Addr# -> Bool# -> IO Integer
- IHaskellPrelude: integerFromAddr# :: Word# -> Addr# -> Bool# -> State# s -> (# State# s, Integer #)
- IHaskellPrelude: integerFromBigNat# :: BigNat# -> Integer
- IHaskellPrelude: integerFromBigNatNeg# :: BigNat# -> Integer
- IHaskellPrelude: integerFromBigNatSign# :: Int# -> BigNat# -> Integer
- IHaskellPrelude: integerFromByteArray :: Word# -> ByteArray# -> Word# -> Bool# -> Integer
- IHaskellPrelude: integerFromByteArray# :: Word# -> ByteArray# -> Word# -> Bool# -> State# s -> (# State# s, Integer #)
- IHaskellPrelude: integerFromInt :: Int -> Integer
- IHaskellPrelude: integerFromInt# :: Int# -> Integer
- IHaskellPrelude: integerFromInt64# :: Int64# -> Integer
- IHaskellPrelude: integerFromNatural :: Natural -> Integer
- IHaskellPrelude: integerFromWord :: Word -> Integer
- IHaskellPrelude: integerFromWord# :: Word# -> Integer
- IHaskellPrelude: integerFromWord64# :: Word64# -> Integer
- IHaskellPrelude: integerFromWordList :: Bool -> [Word] -> Integer
- IHaskellPrelude: integerFromWordNeg# :: Word# -> Integer
- IHaskellPrelude: integerFromWordSign# :: Int# -> Word# -> Integer
- IHaskellPrelude: integerGcd :: Integer -> Integer -> Integer
- IHaskellPrelude: integerGcde :: Integer -> Integer -> (Integer, Integer, Integer)
- IHaskellPrelude: integerGcde# :: Integer -> Integer -> (# Integer, Integer, Integer #)
- IHaskellPrelude: integerGe :: Integer -> Integer -> Bool
- IHaskellPrelude: integerGe# :: Integer -> Integer -> Bool#
- IHaskellPrelude: integerGt :: Integer -> Integer -> Bool
- IHaskellPrelude: integerGt# :: Integer -> Integer -> Bool#
- IHaskellPrelude: integerIsNegative :: Integer -> Bool
- IHaskellPrelude: integerIsNegative# :: Integer -> Bool#
- IHaskellPrelude: integerIsOne :: Integer -> Bool
- IHaskellPrelude: integerIsPowerOf2# :: Integer -> (# (# #) | Word# #)
- IHaskellPrelude: integerIsZero :: Integer -> Bool
- IHaskellPrelude: integerLcm :: Integer -> Integer -> Integer
- IHaskellPrelude: integerLe :: Integer -> Integer -> Bool
- IHaskellPrelude: integerLe# :: Integer -> Integer -> Bool#
- IHaskellPrelude: integerLog2 :: Integer -> Word
- IHaskellPrelude: integerLog2# :: Integer -> Word#
- IHaskellPrelude: integerLogBase :: Integer -> Integer -> Word
- IHaskellPrelude: integerLogBase# :: Integer -> Integer -> Word#
- IHaskellPrelude: integerLogBaseWord :: Word -> Integer -> Word
- IHaskellPrelude: integerLogBaseWord# :: Word# -> Integer -> Word#
- IHaskellPrelude: integerLt :: Integer -> Integer -> Bool
- IHaskellPrelude: integerLt# :: Integer -> Integer -> Bool#
- IHaskellPrelude: integerMod :: Integer -> Integer -> Integer
- IHaskellPrelude: integerMul :: Integer -> Integer -> Integer
- IHaskellPrelude: integerNe :: Integer -> Integer -> Bool
- IHaskellPrelude: integerNe# :: Integer -> Integer -> Bool#
- IHaskellPrelude: integerNegate :: Integer -> Integer
- IHaskellPrelude: integerOne :: Integer
- IHaskellPrelude: integerOr :: Integer -> Integer -> Integer
- IHaskellPrelude: integerPopCount# :: Integer -> Int#
- IHaskellPrelude: integerPowMod# :: Integer -> Integer -> Natural -> (# Natural | () #)
- IHaskellPrelude: integerQuot :: Integer -> Integer -> Integer
- IHaskellPrelude: integerQuotRem :: Integer -> Integer -> (Integer, Integer)
- IHaskellPrelude: integerQuotRem# :: Integer -> Integer -> (# Integer, Integer #)
- IHaskellPrelude: integerRecipMod# :: Integer -> Natural -> (# Natural | () #)
- IHaskellPrelude: integerRem :: Integer -> Integer -> Integer
- IHaskellPrelude: integerShiftL :: Integer -> Word -> Integer
- IHaskellPrelude: integerShiftL# :: Integer -> Word# -> Integer
- IHaskellPrelude: integerShiftR :: Integer -> Word -> Integer
- IHaskellPrelude: integerShiftR# :: Integer -> Word# -> Integer
- IHaskellPrelude: integerSignum :: Integer -> Integer
- IHaskellPrelude: integerSignum# :: Integer -> Int#
- IHaskellPrelude: integerSizeInBase# :: Word# -> Integer -> Word#
- IHaskellPrelude: integerSqr :: Integer -> Integer
- IHaskellPrelude: integerSub :: Integer -> Integer -> Integer
- IHaskellPrelude: integerTestBit :: Integer -> Word -> Bool
- IHaskellPrelude: integerTestBit# :: Integer -> Word# -> Bool#
- IHaskellPrelude: integerToAddr :: Integer -> Addr# -> Bool# -> IO Word
- IHaskellPrelude: integerToAddr# :: Integer -> Addr# -> Bool# -> State# s -> (# State# s, Word# #)
- IHaskellPrelude: integerToBigNatClamp# :: Integer -> BigNat#
- IHaskellPrelude: integerToBigNatSign# :: Integer -> (# Int#, BigNat# #)
- IHaskellPrelude: integerToInt :: Integer -> Int
- IHaskellPrelude: integerToInt# :: Integer -> Int#
- IHaskellPrelude: integerToInt64# :: Integer -> Int64#
- IHaskellPrelude: integerToMutableByteArray :: Integer -> MutableByteArray# RealWorld -> Word# -> Bool# -> IO Word
- IHaskellPrelude: integerToMutableByteArray# :: Integer -> MutableByteArray# s -> Word# -> Bool# -> State# s -> (# State# s, Word# #)
- IHaskellPrelude: integerToNatural :: Integer -> Natural
- IHaskellPrelude: integerToNaturalClamp :: Integer -> Natural
- IHaskellPrelude: integerToNaturalThrow :: Integer -> Natural
- IHaskellPrelude: integerToWord :: Integer -> Word
- IHaskellPrelude: integerToWord# :: Integer -> Word#
- IHaskellPrelude: integerToWord64# :: Integer -> Word64#
- IHaskellPrelude: integerXor :: Integer -> Integer -> Integer
- IHaskellPrelude: integerZero :: Integer
- IHaskellPrelude: integralEnumFrom :: (Integral a, Bounded a) => a -> [a]
- IHaskellPrelude: integralEnumFromThen :: (Integral a, Bounded a) => a -> a -> [a]
- IHaskellPrelude: integralEnumFromThenTo :: Integral a => a -> a -> a -> [a]
- IHaskellPrelude: integralEnumFromTo :: Integral a => a -> a -> [a]
- IHaskellPrelude: isJust :: Maybe a -> Bool
- IHaskellPrelude: isLeft :: Either a b -> Bool
- IHaskellPrelude: isNothing :: Maybe a -> Bool
- IHaskellPrelude: isRight :: Either a b -> Bool
- IHaskellPrelude: join :: Monad m => m (m a) -> m a
- IHaskellPrelude: lcm :: Integral a => a -> a -> a
- IHaskellPrelude: lefts :: [Either a b] -> [a]
- IHaskellPrelude: liftIO :: MonadIO m => IO a -> m a
- IHaskellPrelude: liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- IHaskellPrelude: liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- IHaskellPrelude: liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- IHaskellPrelude: liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- IHaskellPrelude: liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- IHaskellPrelude: listToMaybe :: [a] -> Maybe a
- IHaskellPrelude: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- IHaskellPrelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- IHaskellPrelude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- IHaskellPrelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- IHaskellPrelude: max :: Ord a => a -> a -> a
- IHaskellPrelude: maxBound :: Bounded a => a
- IHaskellPrelude: maybe :: b -> (a -> b) -> Maybe a -> b
- IHaskellPrelude: maybeToList :: Maybe a -> [a]
- IHaskellPrelude: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- IHaskellPrelude: min :: Ord a => a -> a -> a
- IHaskellPrelude: minBound :: Bounded a => a
- IHaskellPrelude: mkRationalBase10 :: Rational -> Integer -> Rational
- IHaskellPrelude: mkRationalBase2 :: Rational -> Integer -> Rational
- IHaskellPrelude: mkRationalWithExponentBase :: Rational -> Integer -> FractionalExponentBase -> Rational
- IHaskellPrelude: mod :: Integral a => a -> a -> a
- IHaskellPrelude: mplus :: MonadPlus m => m a -> m a -> m a
- IHaskellPrelude: msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- IHaskellPrelude: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
- IHaskellPrelude: mzero :: MonadPlus m => m a
- IHaskellPrelude: naturalAdd :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalAnd :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalAndNot :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalBit :: Word -> Natural
- IHaskellPrelude: naturalBit# :: Word# -> Natural
- IHaskellPrelude: naturalCheck :: Natural -> Bool
- IHaskellPrelude: naturalCheck# :: Natural -> Bool#
- IHaskellPrelude: naturalClearBit :: Natural -> Word -> Natural
- IHaskellPrelude: naturalClearBit# :: Natural -> Word# -> Natural
- IHaskellPrelude: naturalCompare :: Natural -> Natural -> Ordering
- IHaskellPrelude: naturalComplementBit :: Natural -> Word -> Natural
- IHaskellPrelude: naturalComplementBit# :: Natural -> Word# -> Natural
- IHaskellPrelude: naturalEncodeDouble# :: Natural -> Int# -> Double#
- IHaskellPrelude: naturalEncodeFloat# :: Natural -> Int# -> Float#
- IHaskellPrelude: naturalEq :: Natural -> Natural -> Bool
- IHaskellPrelude: naturalEq# :: Natural -> Natural -> Bool#
- IHaskellPrelude: naturalFromAddr :: Word# -> Addr# -> Bool# -> IO Natural
- IHaskellPrelude: naturalFromAddr# :: Word# -> Addr# -> Bool# -> State# s -> (# State# s, Natural #)
- IHaskellPrelude: naturalFromBigNat# :: BigNat# -> Natural
- IHaskellPrelude: naturalFromByteArray# :: Word# -> ByteArray# -> Word# -> Bool# -> State# s -> (# State# s, Natural #)
- IHaskellPrelude: naturalFromWord :: Word -> Natural
- IHaskellPrelude: naturalFromWord# :: Word# -> Natural
- IHaskellPrelude: naturalFromWord2# :: Word# -> Word# -> Natural
- IHaskellPrelude: naturalFromWordList :: [Word] -> Natural
- IHaskellPrelude: naturalGcd :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalGe :: Natural -> Natural -> Bool
- IHaskellPrelude: naturalGe# :: Natural -> Natural -> Bool#
- IHaskellPrelude: naturalGt :: Natural -> Natural -> Bool
- IHaskellPrelude: naturalGt# :: Natural -> Natural -> Bool#
- IHaskellPrelude: naturalIsOne :: Natural -> Bool
- IHaskellPrelude: naturalIsPowerOf2# :: Natural -> (# (# #) | Word# #)
- IHaskellPrelude: naturalIsZero :: Natural -> Bool
- IHaskellPrelude: naturalLcm :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalLe :: Natural -> Natural -> Bool
- IHaskellPrelude: naturalLe# :: Natural -> Natural -> Bool#
- IHaskellPrelude: naturalLog2 :: Natural -> Word
- IHaskellPrelude: naturalLog2# :: Natural -> Word#
- IHaskellPrelude: naturalLogBase :: Natural -> Natural -> Word
- IHaskellPrelude: naturalLogBase# :: Natural -> Natural -> Word#
- IHaskellPrelude: naturalLogBaseWord :: Word -> Natural -> Word
- IHaskellPrelude: naturalLogBaseWord# :: Word# -> Natural -> Word#
- IHaskellPrelude: naturalLt :: Natural -> Natural -> Bool
- IHaskellPrelude: naturalLt# :: Natural -> Natural -> Bool#
- IHaskellPrelude: naturalMul :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalNe :: Natural -> Natural -> Bool
- IHaskellPrelude: naturalNe# :: Natural -> Natural -> Bool#
- IHaskellPrelude: naturalNegate :: Natural -> Natural
- IHaskellPrelude: naturalOne :: Natural
- IHaskellPrelude: naturalOr :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalPopCount :: Natural -> Word
- IHaskellPrelude: naturalPopCount# :: Natural -> Word#
- IHaskellPrelude: naturalPowMod :: Natural -> Natural -> Natural -> Natural
- IHaskellPrelude: naturalQuot :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalQuotRem :: Natural -> Natural -> (Natural, Natural)
- IHaskellPrelude: naturalQuotRem# :: Natural -> Natural -> (# Natural, Natural #)
- IHaskellPrelude: naturalRem :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalSetBit :: Natural -> Word -> Natural
- IHaskellPrelude: naturalSetBit# :: Natural -> Word# -> Natural
- IHaskellPrelude: naturalShiftL :: Natural -> Word -> Natural
- IHaskellPrelude: naturalShiftL# :: Natural -> Word# -> Natural
- IHaskellPrelude: naturalShiftR :: Natural -> Word -> Natural
- IHaskellPrelude: naturalShiftR# :: Natural -> Word# -> Natural
- IHaskellPrelude: naturalSignum :: Natural -> Natural
- IHaskellPrelude: naturalSizeInBase# :: Word# -> Natural -> Word#
- IHaskellPrelude: naturalSqr :: Natural -> Natural
- IHaskellPrelude: naturalSub :: Natural -> Natural -> (# (# #) | Natural #)
- IHaskellPrelude: naturalSubThrow :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalSubUnsafe :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalTestBit :: Natural -> Word -> Bool
- IHaskellPrelude: naturalTestBit# :: Natural -> Word# -> Bool#
- IHaskellPrelude: naturalToAddr :: Natural -> Addr# -> Bool# -> IO Word
- IHaskellPrelude: naturalToAddr# :: Natural -> Addr# -> Bool# -> State# s -> (# State# s, Word# #)
- IHaskellPrelude: naturalToBigNat# :: Natural -> BigNat#
- IHaskellPrelude: naturalToMutableByteArray# :: Natural -> MutableByteArray# s -> Word# -> Bool# -> State# s -> (# State# s, Word# #)
- IHaskellPrelude: naturalToWord :: Natural -> Word
- IHaskellPrelude: naturalToWord# :: Natural -> Word#
- IHaskellPrelude: naturalToWordClamp :: Natural -> Word
- IHaskellPrelude: naturalToWordClamp# :: Natural -> Word#
- IHaskellPrelude: naturalToWordMaybe# :: Natural -> (# (# #) | Word# #)
- IHaskellPrelude: naturalXor :: Natural -> Natural -> Natural
- IHaskellPrelude: naturalZero :: Natural
- IHaskellPrelude: negate :: Num a => a -> a
- IHaskellPrelude: newtype () => All
- IHaskellPrelude: newtype () => Any
- IHaskellPrelude: newtype () => Down a
- IHaskellPrelude: newtype () => Dual a
- IHaskellPrelude: newtype () => Endo a
- IHaskellPrelude: newtype () => First a
- IHaskellPrelude: newtype () => Last a
- IHaskellPrelude: newtype () => Max a
- IHaskellPrelude: newtype () => Min a
- IHaskellPrelude: newtype () => Product a
- IHaskellPrelude: newtype () => Sum a
- IHaskellPrelude: newtype () => WrappedMonoid m
- IHaskellPrelude: notANumber :: Rational
- IHaskellPrelude: numerator :: Ratio a -> a
- IHaskellPrelude: numericEnumFrom :: Fractional a => a -> [a]
- IHaskellPrelude: numericEnumFromThen :: Fractional a => a -> a -> [a]
- IHaskellPrelude: numericEnumFromThenTo :: (Ord a, Fractional a) => a -> a -> a -> [a]
- IHaskellPrelude: numericEnumFromTo :: (Ord a, Fractional a) => a -> a -> [a]
- IHaskellPrelude: odd :: Integral a => a -> Bool
- IHaskellPrelude: overflowError :: a
- IHaskellPrelude: partitionEithers :: [Either a b] -> ([a], [b])
- IHaskellPrelude: powImpl :: (Num a, Integral b) => a -> b -> a
- IHaskellPrelude: powImplAcc :: (Num a, Integral b) => a -> b -> a -> a
- IHaskellPrelude: pred :: Enum a => a -> a
- IHaskellPrelude: predError :: String -> a
- IHaskellPrelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
- IHaskellPrelude: protectEsc :: (Char -> Bool) -> ShowS -> ShowS
- IHaskellPrelude: quot :: Integral a => a -> a -> a
- IHaskellPrelude: quotRem :: Integral a => a -> a -> (a, a)
- IHaskellPrelude: quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
- IHaskellPrelude: ratioPrec :: Int
- IHaskellPrelude: ratioPrec1 :: Int
- IHaskellPrelude: ratioZeroDenominatorError :: a
- IHaskellPrelude: realToFrac :: (Real a, Fractional b) => a -> b
- IHaskellPrelude: recip :: Fractional a => a -> a
- IHaskellPrelude: reduce :: Integral a => a -> a -> Ratio a
- IHaskellPrelude: rem :: Integral a => a -> a -> a
- IHaskellPrelude: replicateM :: Applicative m => Int -> m a -> m [a]
- IHaskellPrelude: replicateM_ :: Applicative m => Int -> m a -> m ()
- IHaskellPrelude: return :: Monad m => a -> m a
- IHaskellPrelude: rights :: [Either a b] -> [b]
- IHaskellPrelude: round :: (RealFrac a, Integral b) => a -> b
- IHaskellPrelude: sconcat :: Semigroup a => NonEmpty a -> a
- IHaskellPrelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- IHaskellPrelude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- IHaskellPrelude: show :: Show a => a -> String
- IHaskellPrelude: showChar :: Char -> ShowS
- IHaskellPrelude: showCommaSpace :: ShowS
- IHaskellPrelude: showList :: Show a => [a] -> ShowS
- IHaskellPrelude: showList__ :: (a -> ShowS) -> [a] -> ShowS
- IHaskellPrelude: showLitChar :: Char -> ShowS
- IHaskellPrelude: showLitString :: String -> ShowS
- IHaskellPrelude: showMultiLineString :: String -> [String]
- IHaskellPrelude: showParen :: Bool -> ShowS -> ShowS
- IHaskellPrelude: showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
- IHaskellPrelude: showSignedInt :: Int -> Int -> ShowS
- IHaskellPrelude: showSpace :: ShowS
- IHaskellPrelude: showString :: String -> ShowS
- IHaskellPrelude: shows :: Show a => a -> ShowS
- IHaskellPrelude: showsPrec :: Show a => Int -> a -> ShowS
- IHaskellPrelude: signum :: Num a => a -> a
- IHaskellPrelude: stimes :: (Semigroup a, Integral b) => b -> a -> a
- IHaskellPrelude: stimesIdempotent :: Integral b => b -> a -> a
- IHaskellPrelude: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
- IHaskellPrelude: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
- IHaskellPrelude: subtract :: Num a => a -> a -> a
- IHaskellPrelude: succ :: Enum a => a -> a
- IHaskellPrelude: succError :: String -> a
- IHaskellPrelude: toEnum :: Enum a => Int -> a
- IHaskellPrelude: toEnumError :: Show a => String -> Int -> (a, a) -> b
- IHaskellPrelude: toInteger :: Integral a => a -> Integer
- IHaskellPrelude: toRational :: Real a => a -> Rational
- IHaskellPrelude: truncate :: (RealFrac a, Integral b) => a -> b
- IHaskellPrelude: type ArgMax a b = Max Arg a b
- IHaskellPrelude: type ArgMin a b = Min Arg a b
- IHaskellPrelude: type Rational = Ratio Integer
- IHaskellPrelude: type ShowS = String -> String
- IHaskellPrelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- IHaskellPrelude: underflowError :: a
- IHaskellPrelude: unless :: Applicative f => Bool -> f () -> f ()
- IHaskellPrelude: void :: Functor f => f a -> f ()
- IHaskellPrelude: when :: Applicative f => Bool -> f () -> f ()
- IHaskellPrelude: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- IHaskellPrelude: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
+ IHaskellPrelude: (!?) :: [a] -> Int -> Maybe a
+ IHaskellPrelude: atomicSwapMutVar# :: forall {l :: Levity} d (a :: TYPE ('BoxedRep l)). MutVar# d a -> a -> State# d -> (# State# d, a #)
+ IHaskellPrelude: copyAddrToAddr# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
+ IHaskellPrelude: copyAddrToAddrNonOverlapping# :: Addr# -> Addr# -> Int# -> State# RealWorld -> State# RealWorld
+ IHaskellPrelude: copyMutableByteArrayNonOverlapping# :: MutableByteArray# d -> Int# -> MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
+ IHaskellPrelude: data Solo a
+ IHaskellPrelude: fmaddDouble# :: Double# -> Double# -> Double# -> Double#
+ IHaskellPrelude: fmaddFloat# :: Float# -> Float# -> Float# -> Float#
+ IHaskellPrelude: fmsubDouble# :: Double# -> Double# -> Double# -> Double#
+ IHaskellPrelude: fmsubFloat# :: Float# -> Float# -> Float# -> Float#
+ IHaskellPrelude: fnmaddDouble# :: Double# -> Double# -> Double# -> Double#
+ IHaskellPrelude: fnmaddFloat# :: Float# -> Float# -> Float# -> Float#
+ IHaskellPrelude: fnmsubDouble# :: Double# -> Double# -> Double# -> Double#
+ IHaskellPrelude: fnmsubFloat# :: Float# -> Float# -> Float# -> Float#
+ IHaskellPrelude: getSolo :: Solo a -> a
+ IHaskellPrelude: infixl 9 !?
+ IHaskellPrelude: setAddrRange# :: Addr# -> Int# -> Int# -> State# RealWorld -> State# RealWorld
+ IHaskellPrelude: unsnoc :: [a] -> Maybe ([a], a)
- IHaskell.Convert.Args: ConvertSpec :: f Bool -> f FilePath -> f FilePath -> f (LhsStyle Text) -> Bool -> ConvertSpec f
+ IHaskell.Convert.Args: ConvertSpec :: f Bool -> f FilePath -> f FilePath -> f (LhsStyle Text) -> Bool -> ConvertSpec (f :: Type -> Type)
- IHaskell.Convert.Args: [convertInput] :: ConvertSpec f -> f FilePath
+ IHaskell.Convert.Args: [convertInput] :: ConvertSpec (f :: Type -> Type) -> f FilePath
- IHaskell.Convert.Args: [convertLhsStyle] :: ConvertSpec f -> f (LhsStyle Text)
+ IHaskell.Convert.Args: [convertLhsStyle] :: ConvertSpec (f :: Type -> Type) -> f (LhsStyle Text)
- IHaskell.Convert.Args: [convertOutput] :: ConvertSpec f -> f FilePath
+ IHaskell.Convert.Args: [convertOutput] :: ConvertSpec (f :: Type -> Type) -> f FilePath
- IHaskell.Convert.Args: [convertOverwriteFiles] :: ConvertSpec f -> Bool
+ IHaskell.Convert.Args: [convertOverwriteFiles] :: ConvertSpec (f :: Type -> Type) -> Bool
- IHaskell.Convert.Args: [convertToIpynb] :: ConvertSpec f -> f Bool
+ IHaskell.Convert.Args: [convertToIpynb] :: ConvertSpec (f :: Type -> Type) -> f Bool
- IHaskell.Convert.Args: data ConvertSpec f
+ IHaskell.Convert.Args: data ConvertSpec (f :: Type -> Type)
- IHaskell.Display: data () => DisplayData
+ IHaskell.Display: data DisplayData
- IHaskell.Eval.Parser: data () => Located a
+ IHaskell.Eval.Parser: data Located a
- IHaskell.Eval.Parser: data () => StringLoc
+ IHaskell.Eval.Parser: data StringLoc
- IHaskell.Types: data () => DisplayData
+ IHaskell.Types: data DisplayData
- IHaskell.Types: data () => ExecuteReplyStatus
+ IHaskell.Types: data ExecuteReplyStatus
- IHaskell.Types: data () => ExecutionState
+ IHaskell.Types: data ExecutionState
- IHaskell.Types: data () => KernelSpec
+ IHaskell.Types: data KernelSpec
- IHaskell.Types: data () => Message
+ IHaskell.Types: data Message
- IHaskell.Types: data () => MessageHeader
+ IHaskell.Types: data MessageHeader
- IHaskell.Types: data () => MessageType
+ IHaskell.Types: data MessageType
- IHaskell.Types: data () => Metadata
+ IHaskell.Types: data Metadata
- IHaskell.Types: data () => MimeType
+ IHaskell.Types: data MimeType
- IHaskell.Types: data () => StreamType
+ IHaskell.Types: data StreamType
- IHaskellPrelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ IHaskellPrelude: ($!) :: (a -> b) -> a -> b
- IHaskellPrelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
+ IHaskellPrelude: ($) :: (a -> b) -> a -> b
- IHaskellPrelude: catch# :: forall {q :: RuntimeRep} {k :: Levity} (a :: TYPE q) (b :: TYPE ('BoxedRep k)). (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+ IHaskellPrelude: catch# :: forall {k :: Levity} a (b :: TYPE ('BoxedRep k)). (State# RealWorld -> (# State# RealWorld, a #)) -> (b -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
- IHaskellPrelude: class () => Eq a
+ IHaskellPrelude: class Eq a
- IHaskellPrelude: class () => IP (x :: Symbol) a | x -> a
+ IHaskellPrelude: class IP (x :: Symbol) a | x -> a
- IHaskellPrelude: class () => IsList l
+ IHaskellPrelude: class IsList l
- IHaskellPrelude: class () => IsString a
+ IHaskellPrelude: class IsString a
- IHaskellPrelude: class () => Typeable (a :: k)
+ IHaskellPrelude: class Typeable (a :: k)
- IHaskellPrelude: class () => WithDict cls meth
+ IHaskellPrelude: class WithDict cls meth
- IHaskellPrelude: coerce :: forall {k :: RuntimeRep} (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
+ IHaskellPrelude: coerce :: Coercible a b => a -> b
- IHaskellPrelude: control0# :: forall {r :: RuntimeRep} a (b :: TYPE r). PromptTag# a -> (((State# RealWorld -> (# State# RealWorld, b #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, b #)
+ IHaskellPrelude: control0# :: PromptTag# a -> (((State# RealWorld -> (# State# RealWorld, b #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, b #)
- IHaskellPrelude: data () => Bool
+ IHaskellPrelude: data Bool
- IHaskellPrelude: data () => ByteString
+ IHaskellPrelude: data ByteString
- IHaskellPrelude: data () => Char
+ IHaskellPrelude: data Char
- IHaskellPrelude: data () => DictBox a
+ IHaskellPrelude: data DictBox a
- IHaskellPrelude: data () => Double
+ IHaskellPrelude: data Double
- IHaskellPrelude: data () => DoubleBox (a :: TYPE 'DoubleRep)
+ IHaskellPrelude: data DoubleBox (a :: TYPE 'DoubleRep)
- IHaskellPrelude: data () => Float
+ IHaskellPrelude: data Float
- IHaskellPrelude: data () => FloatBox (a :: TYPE 'FloatRep)
+ IHaskellPrelude: data FloatBox (a :: TYPE 'FloatRep)
- IHaskellPrelude: data () => Handle
+ IHaskellPrelude: data Handle
- IHaskellPrelude: data () => IORef a
+ IHaskellPrelude: data IORef a
- IHaskellPrelude: data () => Int
+ IHaskellPrelude: data Int
- IHaskellPrelude: data () => IntBox (a :: TYPE 'IntRep)
+ IHaskellPrelude: data IntBox (a :: TYPE 'IntRep)
- IHaskellPrelude: data () => KindRep
+ IHaskellPrelude: data KindRep
- IHaskellPrelude: data () => Levity
+ IHaskellPrelude: data Levity
- IHaskellPrelude: data () => MVar a
+ IHaskellPrelude: data MVar a
- IHaskellPrelude: data () => Map k a
+ IHaskellPrelude: data Map k a
- IHaskellPrelude: data () => Multiplicity
+ IHaskellPrelude: data Multiplicity
- IHaskellPrelude: data () => NonEmpty a
+ IHaskellPrelude: data NonEmpty a
- IHaskellPrelude: data () => Opaque
+ IHaskellPrelude: data Opaque
- IHaskellPrelude: data () => Proxy (t :: k)
+ IHaskellPrelude: data Proxy (t :: k)
- IHaskellPrelude: data () => RuntimeRep
+ IHaskellPrelude: data RuntimeRep
- IHaskellPrelude: data () => SPEC
+ IHaskellPrelude: data SPEC
- IHaskellPrelude: data () => SomeException
+ IHaskellPrelude: data SomeException
- IHaskellPrelude: data () => Symbol
+ IHaskellPrelude: data Symbol
- IHaskellPrelude: data () => Text
+ IHaskellPrelude: data Text
- IHaskellPrelude: data () => TrName
+ IHaskellPrelude: data TrName
- IHaskellPrelude: data () => TyCon
+ IHaskellPrelude: data TyCon
- IHaskellPrelude: data () => TypeLitSort
+ IHaskellPrelude: data TypeLitSort
- IHaskellPrelude: data () => VecCount
+ IHaskellPrelude: data VecCount
- IHaskellPrelude: data () => VecElem
+ IHaskellPrelude: data VecElem
- IHaskellPrelude: data () => Void
+ IHaskellPrelude: data Void
- IHaskellPrelude: data () => Word
+ IHaskellPrelude: data Word
- IHaskellPrelude: data () => WordBox (a :: TYPE 'WordRep)
+ IHaskellPrelude: data WordBox (a :: TYPE 'WordRep)
- IHaskellPrelude: data () => [] a
+ IHaskellPrelude: data [] a
- IHaskellPrelude: eqStableName# :: StableName# a -> StableName# b -> Int#
+ IHaskellPrelude: eqStableName# :: forall {k :: Levity} {l :: Levity} (a :: TYPE ('BoxedRep k)) (b :: TYPE ('BoxedRep l)). StableName# a -> StableName# b -> Int#
- IHaskellPrelude: fork# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
+ IHaskellPrelude: fork# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
- IHaskellPrelude: forkOn# :: forall {q :: RuntimeRep} (a :: TYPE q). Int# -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
+ IHaskellPrelude: forkOn# :: Int# -> (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, ThreadId# #)
- IHaskellPrelude: infixl 7 %
+ IHaskellPrelude: infixl 7 *#
- IHaskellPrelude: keepAlive# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE ('BoxedRep l)) (b :: TYPE r). a -> State# RealWorld -> (State# RealWorld -> b) -> b
+ IHaskellPrelude: keepAlive# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d b. a -> State# d -> (State# d -> b) -> b
- IHaskellPrelude: leftSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {n :: Multiplicity} (a :: TYPE q) (b :: TYPE r). (a %n -> b) -> a %n -> b
+ IHaskellPrelude: leftSection :: forall {n :: Multiplicity} a b. (a %n -> b) -> a %n -> b
- IHaskellPrelude: maskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+ IHaskellPrelude: maskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
- IHaskellPrelude: maskUninterruptible# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+ IHaskellPrelude: maskUninterruptible# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
- IHaskellPrelude: newtype () => Alt (f :: k -> Type) (a :: k)
+ IHaskellPrelude: newtype Alt (f :: k -> Type) (a :: k)
- IHaskellPrelude: newtype () => Ap (f :: k -> Type) (a :: k)
+ IHaskellPrelude: newtype Ap (f :: k -> Type) (a :: k)
- IHaskellPrelude: newtype () => IO a
+ IHaskellPrelude: newtype IO a
- IHaskellPrelude: newtype () => ZipList a
+ IHaskellPrelude: newtype ZipList a
- IHaskellPrelude: oneShot :: forall {q :: RuntimeRep} {r :: RuntimeRep} (a :: TYPE q) (b :: TYPE r). (a -> b) -> a -> b
+ IHaskellPrelude: oneShot :: (a -> b) -> a -> b
- IHaskellPrelude: raise# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE ('BoxedRep l)) (b :: TYPE r). a -> b
+ IHaskellPrelude: raise# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. a -> b
- IHaskellPrelude: raiseDivZero# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+ IHaskellPrelude: raiseDivZero# :: (# #) -> b
- IHaskellPrelude: raiseIO# :: forall {l :: Levity} {r :: RuntimeRep} (a :: TYPE ('BoxedRep l)) (b :: TYPE r). a -> State# RealWorld -> (# State# RealWorld, b #)
+ IHaskellPrelude: raiseIO# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) b. a -> State# RealWorld -> (# State# RealWorld, b #)
- IHaskellPrelude: raiseOverflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+ IHaskellPrelude: raiseOverflow# :: (# #) -> b
- IHaskellPrelude: raiseUnderflow# :: forall {r :: RuntimeRep} (b :: TYPE r). (# #) -> b
+ IHaskellPrelude: raiseUnderflow# :: (# #) -> b
- IHaskellPrelude: rightSection :: forall {q :: RuntimeRep} {r :: RuntimeRep} {s :: RuntimeRep} {n :: Multiplicity} {o :: Multiplicity} (a :: TYPE q) (b :: TYPE r) (c :: TYPE s). (a %n -> b %o -> c) -> b %o -> a %n -> c
+ IHaskellPrelude: rightSection :: forall {n :: Multiplicity} {o :: Multiplicity} a b c. (a %n -> b %o -> c) -> b %o -> a %n -> c
- IHaskellPrelude: runRW# :: forall (r :: RuntimeRep) (o :: TYPE r). (State# RealWorld -> o) -> o
+ IHaskellPrelude: runRW# :: (State# RealWorld -> o) -> o
- IHaskellPrelude: sameArray# :: Array# a -> Array# a -> Int#
+ IHaskellPrelude: sameArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). Array# a -> Array# a -> Int#
- IHaskellPrelude: sameIOPort# :: IOPort# s a -> IOPort# s a -> Int#
+ IHaskellPrelude: sameIOPort# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). IOPort# s a -> IOPort# s a -> Int#
- IHaskellPrelude: sameMVar# :: MVar# s a -> MVar# s a -> Int#
+ IHaskellPrelude: sameMVar# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). MVar# s a -> MVar# s a -> Int#
- IHaskellPrelude: sameMutVar# :: MutVar# s a -> MutVar# s a -> Int#
+ IHaskellPrelude: sameMutVar# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). MutVar# s a -> MutVar# s a -> Int#
- IHaskellPrelude: sameMutableArray# :: MutableArray# s a -> MutableArray# s a -> Int#
+ IHaskellPrelude: sameMutableArray# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). MutableArray# s a -> MutableArray# s a -> Int#
- IHaskellPrelude: sameSmallArray# :: SmallArray# a -> SmallArray# a -> Int#
+ IHaskellPrelude: sameSmallArray# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). SmallArray# a -> SmallArray# a -> Int#
- IHaskellPrelude: sameSmallMutableArray# :: SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
+ IHaskellPrelude: sameSmallMutableArray# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
- IHaskellPrelude: sameTVar# :: TVar# s a -> TVar# s a -> Int#
+ IHaskellPrelude: sameTVar# :: forall {l :: Levity} s (a :: TYPE ('BoxedRep l)). TVar# s a -> TVar# s a -> Int#
- IHaskellPrelude: seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
+ IHaskellPrelude: seq :: a -> b -> b
- IHaskellPrelude: touch# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)). a -> State# RealWorld -> State# RealWorld
+ IHaskellPrelude: touch# :: forall {l :: Levity} (a :: TYPE ('BoxedRep l)) d. a -> State# d -> State# d
- IHaskellPrelude: unmaskAsyncExceptions# :: forall {q :: RuntimeRep} (a :: TYPE q). (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
+ IHaskellPrelude: unmaskAsyncExceptions# :: (State# RealWorld -> (# State# RealWorld, a #)) -> State# RealWorld -> (# State# RealWorld, a #)
Files
- ihaskell.cabal +3/−3
- main/Main.hs +4/−3
- src/IHaskell/Types.hs +7/−1
- src/StringUtils.hs +4/−2
ihaskell.cabal view
@@ -7,7 +7,7 @@ -- PVP summary: +--+------- breaking API changes -- | | +----- non-breaking API additions -- | | | +--- code changes with no API change-version: 0.12.0.0+version: 0.13.0.0 -- A short (one-line) description of the package. synopsis: A Haskell backend kernel for the Jupyter project.@@ -71,7 +71,7 @@ bytestring , exceptions , filepath ,- ghc >=8.4 && <9.11,+ ghc >=8.4 && <9.13, ghc-boot , haskeline , parsec ,@@ -95,7 +95,7 @@ unordered-containers -any, utf8-string -any, vector -any,- ipython-kernel >=0.11.0.0+ ipython-kernel >=0.12.0.0 exposed-modules: IHaskell.Display IHaskell.Convert
main/Main.hs view
@@ -192,7 +192,8 @@ forever $ do -- Read the request from the request channel.- request <- liftIO $ readChan $ shellRequestChannel interface+ -- when the request is completed, write the reply to `repChan`+ (repChan, request) <- liftIO $ readChan $ shellRequestChannel interface -- Create a header for the reply. replyHeader <- createReplyHeader (header request)@@ -213,7 +214,7 @@ tempState <- handleComm replier oldState request replyHeader newState <- flushWidgetMessages tempState [] widgetMessageHandler liftIO $ putMVar state newState- liftIO $ writeChan (shellReplyChannel interface) SendNothing+ liftIO $ writeChan repChan SendNothing else do -- Create the reply, possibly modifying kernel state. oldState <- liftIO $ takeMVar state@@ -221,7 +222,7 @@ liftIO $ putMVar state newState -- Write the reply to the reply channel.- liftIO $ writeChan (shellReplyChannel interface) reply+ liftIO $ writeChan repChan reply -- Notify the frontend that we're done computing. idleHeader <- liftIO $ dupHeader replyHeader StatusMessage
src/IHaskell/Types.hs view
@@ -47,6 +47,7 @@ import Data.Aeson (ToJSON (..), Value, (.=), object, Value(String)) import Data.Function (on) import Data.Text (pack)+import qualified Data.Text.Encoding as Text import Data.Binary import GHC.Generics @@ -303,7 +304,12 @@ dupHeader :: MessageHeader -> MessageType -> IO MessageHeader dupHeader hdr messageType = do uuid <- liftIO random- return hdr { mhMessageId = uuid, mhMsgType = messageType }+ let sessionBytes = Text.encodeUtf8 $ pack $ uuidToString $ mhSessionId hdr+ -- For IOPub message types, use session ID as identifier (topic)+ newIdentifiers = if isIOPubMessageType messageType+ then [sessionBytes]+ else mhIdentifiers hdr+ return hdr { mhMessageId = uuid, mhMsgType = messageType, mhIdentifiers = newIdentifiers } -- | Modifies a header and appends the version of the Widget Messaging Protocol as metadata setVersion :: MessageHeader -- ^ The header to modify
src/StringUtils.hs view
@@ -9,15 +9,17 @@ ) where import IHaskellPrelude+import Data.Char+import qualified Data.List as L import qualified Data.Text as T import Data.List.Split (splitOn) import qualified Data.List.Split as Split lstrip :: String -> String-lstrip = dropWhile (`elem` (" \t\r\n" :: String))+lstrip = dropWhile isSpace rstrip :: String -> String-rstrip = reverse . lstrip . reverse+rstrip = L.dropWhileEnd isSpace strip :: String -> String strip = rstrip . lstrip