packages feed

clash-prelude 0.99 → 0.99.1

raw patch · 14 files changed

+105/−30 lines, 14 filesdep ~ghc-typelits-extradep ~ghc-typelits-knownnatdep ~ghc-typelits-natnormalisePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: ghc-typelits-extra, ghc-typelits-knownnat, ghc-typelits-natnormalise

API changes (from Hackage documentation)

+ Clash.Annotations.Primitive: InlinePrimitive :: HDL -> String -> Primitive
+ Clash.Annotations.TopEntity: instance Language.Haskell.TH.Syntax.Lift Clash.Annotations.TopEntity.PortName
+ Clash.Annotations.TopEntity: instance Language.Haskell.TH.Syntax.Lift Clash.Annotations.TopEntity.TopEntity
+ Clash.Explicit.Prelude: ($!) :: () => a -> b -> a -> b
+ Clash.Explicit.Prelude: ($) :: () => a -> b -> a -> b
+ Clash.Explicit.Prelude: (&&) :: Bool -> Bool -> Bool
+ Clash.Explicit.Prelude: (*) :: Num a => a -> a -> a
+ Clash.Explicit.Prelude: (**) :: Floating a => a -> a -> a
+ Clash.Explicit.Prelude: (*>) :: Applicative f => f a -> f b -> f b
+ Clash.Explicit.Prelude: (+) :: Num a => a -> a -> a
+ Clash.Explicit.Prelude: (-) :: Num a => a -> a -> a
+ Clash.Explicit.Prelude: (.) :: () => b -> c -> a -> b -> a -> c
+ Clash.Explicit.Prelude: (/) :: Fractional a => a -> a -> a
+ Clash.Explicit.Prelude: (/=) :: Eq a => a -> a -> Bool
+ Clash.Explicit.Prelude: (<$) :: Functor f => a -> f b -> f a
+ Clash.Explicit.Prelude: (<$>) :: Functor f => a -> b -> f a -> f b
+ Clash.Explicit.Prelude: (<) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude: (<*) :: Applicative f => f a -> f b -> f a
+ Clash.Explicit.Prelude: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Clash.Explicit.Prelude: (<=) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude: (<>) :: Semigroup a => a -> a -> a
+ Clash.Explicit.Prelude: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Clash.Explicit.Prelude: (==) :: Eq a => a -> a -> Bool
+ Clash.Explicit.Prelude: (>) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude: (>=) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude: (>>) :: Monad m => m a -> m b -> m b
+ Clash.Explicit.Prelude: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Clash.Explicit.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ Clash.Explicit.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Clash.Explicit.Prelude: (||) :: Bool -> Bool -> Bool
+ Clash.Explicit.Prelude: EQ :: Ordering
+ Clash.Explicit.Prelude: False :: Bool
+ Clash.Explicit.Prelude: GT :: Ordering
+ Clash.Explicit.Prelude: Just :: a -> Maybe a
+ Clash.Explicit.Prelude: LT :: Ordering
+ Clash.Explicit.Prelude: Left :: a -> Either a b
+ Clash.Explicit.Prelude: Nothing :: Maybe a
+ Clash.Explicit.Prelude: Right :: b -> Either a b
+ Clash.Explicit.Prelude: True :: Bool
+ Clash.Explicit.Prelude: abs :: Num a => a -> a
+ Clash.Explicit.Prelude: acos :: Floating a => a -> a
+ Clash.Explicit.Prelude: acosh :: Floating a => a -> a
+ Clash.Explicit.Prelude: all :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Explicit.Prelude: and :: Foldable t => t Bool -> Bool
+ Clash.Explicit.Prelude: any :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Explicit.Prelude: appendFile :: FilePath -> String -> IO ()
+ Clash.Explicit.Prelude: asTypeOf :: () => a -> a -> a
+ Clash.Explicit.Prelude: asin :: Floating a => a -> a
+ Clash.Explicit.Prelude: asinh :: Floating a => a -> a
+ Clash.Explicit.Prelude: atan :: Floating a => a -> a
+ Clash.Explicit.Prelude: atan2 :: RealFloat a => a -> a -> a
+ Clash.Explicit.Prelude: atanh :: Floating a => a -> a
+ Clash.Explicit.Prelude: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Explicit.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude: class Functor f => Applicative (f :: * -> *)
+ Clash.Explicit.Prelude: class Bounded a
+ Clash.Explicit.Prelude: class Enum a
+ Clash.Explicit.Prelude: class Eq a
+ Clash.Explicit.Prelude: class Fractional a => Floating a
+ Clash.Explicit.Prelude: class Foldable (t :: * -> *)
+ Clash.Explicit.Prelude: class Num a => Fractional a
+ Clash.Explicit.Prelude: class Functor (f :: * -> *)
+ Clash.Explicit.Prelude: class (Real a, Enum a) => Integral a
+ Clash.Explicit.Prelude: class Applicative m => Monad (m :: * -> *)
+ Clash.Explicit.Prelude: class Semigroup a => Monoid a
+ Clash.Explicit.Prelude: class Num a
+ Clash.Explicit.Prelude: class Eq a => Ord a
+ Clash.Explicit.Prelude: class Read a
+ Clash.Explicit.Prelude: class (Num a, Ord a) => Real a
+ Clash.Explicit.Prelude: class (RealFrac a, Floating a) => RealFloat a
+ Clash.Explicit.Prelude: class (Real a, Fractional a) => RealFrac a
+ Clash.Explicit.Prelude: class Semigroup a
+ Clash.Explicit.Prelude: class Show a
+ Clash.Explicit.Prelude: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Clash.Explicit.Prelude: compare :: Ord a => a -> a -> Ordering
+ Clash.Explicit.Prelude: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Clash.Explicit.Prelude: const :: () => a -> b -> a
+ Clash.Explicit.Prelude: cos :: Floating a => a -> a
+ Clash.Explicit.Prelude: cosh :: Floating a => a -> a
+ Clash.Explicit.Prelude: curry :: () => (a, b) -> c -> a -> b -> c
+ Clash.Explicit.Prelude: cycle :: () => [a] -> [a]
+ Clash.Explicit.Prelude: data Bool
+ Clash.Explicit.Prelude: data Char
+ Clash.Explicit.Prelude: data Double
+ Clash.Explicit.Prelude: data Either a b
+ Clash.Explicit.Prelude: data Float
+ Clash.Explicit.Prelude: data IO a
+ Clash.Explicit.Prelude: data Int
+ Clash.Explicit.Prelude: data Integer
+ Clash.Explicit.Prelude: data Maybe a
+ Clash.Explicit.Prelude: data Ordering
+ Clash.Explicit.Prelude: data Word
+ Clash.Explicit.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Clash.Explicit.Prelude: div :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude: divMod :: Integral a => a -> a -> (a, a)
+ Clash.Explicit.Prelude: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Explicit.Prelude: either :: () => a -> c -> b -> c -> Either a b -> c
+ Clash.Explicit.Prelude: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Explicit.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Clash.Explicit.Prelude: enumFrom :: Enum a => a -> [a]
+ Clash.Explicit.Prelude: enumFromThen :: Enum a => a -> a -> [a]
+ Clash.Explicit.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Clash.Explicit.Prelude: enumFromTo :: Enum a => a -> a -> [a]
+ Clash.Explicit.Prelude: error :: HasCallStack => [Char] -> a
+ Clash.Explicit.Prelude: errorWithoutStackTrace :: () => [Char] -> a
+ Clash.Explicit.Prelude: even :: Integral a => a -> Bool
+ Clash.Explicit.Prelude: exp :: Floating a => a -> a
+ Clash.Explicit.Prelude: exponent :: RealFloat a => a -> Int
+ Clash.Explicit.Prelude: fail :: Monad m => String -> m a
+ Clash.Explicit.Prelude: filter :: () => a -> Bool -> [a] -> [a]
+ Clash.Explicit.Prelude: flip :: () => a -> b -> c -> b -> a -> c
+ Clash.Explicit.Prelude: floatDigits :: RealFloat a => a -> Int
+ Clash.Explicit.Prelude: floatRadix :: RealFloat a => a -> Integer
+ Clash.Explicit.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
+ Clash.Explicit.Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude: fmap :: Functor f => a -> b -> f a -> f b
+ Clash.Explicit.Prelude: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Clash.Explicit.Prelude: fromEnum :: Enum a => a -> Int
+ Clash.Explicit.Prelude: fromInteger :: Num a => Integer -> a
+ Clash.Explicit.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ Clash.Explicit.Prelude: fromRational :: Fractional a => Rational -> a
+ Clash.Explicit.Prelude: fst :: () => (a, b) -> a
+ Clash.Explicit.Prelude: gcd :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude: getChar :: IO Char
+ Clash.Explicit.Prelude: getContents :: IO String
+ Clash.Explicit.Prelude: getLine :: IO String
+ Clash.Explicit.Prelude: id :: () => a -> a
+ Clash.Explicit.Prelude: infix 4 `notElem`
+ Clash.Explicit.Prelude: infixl 4 <$>
+ Clash.Explicit.Prelude: infixr 0 $!
+ Clash.Explicit.Prelude: infixr 1 =<<
+ Clash.Explicit.Prelude: infixr 2 ||
+ Clash.Explicit.Prelude: infixr 3 &&
+ Clash.Explicit.Prelude: infixr 8 ^
+ Clash.Explicit.Prelude: infixr 9 .
+ Clash.Explicit.Prelude: interact :: String -> String -> IO ()
+ Clash.Explicit.Prelude: ioError :: () => IOError -> IO a
+ Clash.Explicit.Prelude: isDenormalized :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude: isIEEE :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude: isInfinite :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude: isNaN :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude: isNegativeZero :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude: lcm :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude: lex :: ReadS String
+ Clash.Explicit.Prelude: lines :: String -> [String]
+ Clash.Explicit.Prelude: log :: Floating a => a -> a
+ Clash.Explicit.Prelude: logBase :: Floating a => a -> a -> a
+ Clash.Explicit.Prelude: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Clash.Explicit.Prelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Clash.Explicit.Prelude: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Clash.Explicit.Prelude: mappend :: Monoid a => a -> a -> a
+ Clash.Explicit.Prelude: max :: Ord a => a -> a -> a
+ Clash.Explicit.Prelude: maxBound :: Bounded a => a
+ Clash.Explicit.Prelude: maximum :: (Foldable t, Ord a) => t a -> a
+ Clash.Explicit.Prelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ Clash.Explicit.Prelude: mconcat :: Monoid a => [a] -> a
+ Clash.Explicit.Prelude: mempty :: Monoid a => a
+ Clash.Explicit.Prelude: min :: Ord a => a -> a -> a
+ Clash.Explicit.Prelude: minBound :: Bounded a => a
+ Clash.Explicit.Prelude: minimum :: (Foldable t, Ord a) => t a -> a
+ Clash.Explicit.Prelude: mod :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude: negate :: Num a => a -> a
+ Clash.Explicit.Prelude: not :: Bool -> Bool
+ Clash.Explicit.Prelude: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Explicit.Prelude: null :: Foldable t => t a -> Bool
+ Clash.Explicit.Prelude: odd :: Integral a => a -> Bool
+ Clash.Explicit.Prelude: or :: Foldable t => t Bool -> Bool
+ Clash.Explicit.Prelude: otherwise :: Bool
+ Clash.Explicit.Prelude: pi :: Floating a => a
+ Clash.Explicit.Prelude: pred :: Enum a => a -> a
+ Clash.Explicit.Prelude: print :: Show a => a -> IO ()
+ Clash.Explicit.Prelude: product :: (Foldable t, Num a) => t a -> a
+ Clash.Explicit.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Clash.Explicit.Prelude: pure :: Applicative f => a -> f a
+ Clash.Explicit.Prelude: putChar :: Char -> IO ()
+ Clash.Explicit.Prelude: putStr :: String -> IO ()
+ Clash.Explicit.Prelude: putStrLn :: String -> IO ()
+ Clash.Explicit.Prelude: quot :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ Clash.Explicit.Prelude: read :: Read a => String -> a
+ Clash.Explicit.Prelude: readFile :: FilePath -> IO String
+ Clash.Explicit.Prelude: readIO :: Read a => String -> IO a
+ Clash.Explicit.Prelude: readList :: Read a => ReadS [a]
+ Clash.Explicit.Prelude: readLn :: Read a => IO a
+ Clash.Explicit.Prelude: readParen :: () => Bool -> ReadS a -> ReadS a
+ Clash.Explicit.Prelude: reads :: Read a => ReadS a
+ Clash.Explicit.Prelude: readsPrec :: Read a => Int -> ReadS a
+ Clash.Explicit.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
+ Clash.Explicit.Prelude: recip :: Fractional a => a -> a
+ Clash.Explicit.Prelude: rem :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude: return :: Monad m => a -> m a
+ Clash.Explicit.Prelude: round :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude: scaleFloat :: RealFloat a => Int -> a -> a
+ Clash.Explicit.Prelude: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Explicit.Prelude: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Explicit.Prelude: seq :: () => a -> b -> b
+ Clash.Explicit.Prelude: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Clash.Explicit.Prelude: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Clash.Explicit.Prelude: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Clash.Explicit.Prelude: show :: Show a => a -> String
+ Clash.Explicit.Prelude: showChar :: Char -> ShowS
+ Clash.Explicit.Prelude: showList :: Show a => [a] -> ShowS
+ Clash.Explicit.Prelude: showParen :: Bool -> ShowS -> ShowS
+ Clash.Explicit.Prelude: showString :: String -> ShowS
+ Clash.Explicit.Prelude: shows :: Show a => a -> ShowS
+ Clash.Explicit.Prelude: showsPrec :: Show a => Int -> a -> ShowS
+ Clash.Explicit.Prelude: significand :: RealFloat a => a -> a
+ Clash.Explicit.Prelude: signum :: Num a => a -> a
+ Clash.Explicit.Prelude: sin :: Floating a => a -> a
+ Clash.Explicit.Prelude: sinh :: Floating a => a -> a
+ Clash.Explicit.Prelude: snd :: () => (a, b) -> b
+ Clash.Explicit.Prelude: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Explicit.Prelude: sqrt :: Floating a => a -> a
+ Clash.Explicit.Prelude: subtract :: Num a => a -> a -> a
+ Clash.Explicit.Prelude: succ :: Enum a => a -> a
+ Clash.Explicit.Prelude: sum :: (Foldable t, Num a) => t a -> a
+ Clash.Explicit.Prelude: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Explicit.Prelude: tan :: Floating a => a -> a
+ Clash.Explicit.Prelude: tanh :: Floating a => a -> a
+ Clash.Explicit.Prelude: toEnum :: Enum a => Int -> a
+ Clash.Explicit.Prelude: toInteger :: Integral a => a -> Integer
+ Clash.Explicit.Prelude: toRational :: Real a => a -> Rational
+ Clash.Explicit.Prelude: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Clash.Explicit.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude: type FilePath = String
+ Clash.Explicit.Prelude: type IOError = IOException
+ Clash.Explicit.Prelude: type Rational = Ratio Integer
+ Clash.Explicit.Prelude: type ReadS a = String -> [(a, String)]
+ Clash.Explicit.Prelude: type ShowS = String -> String
+ Clash.Explicit.Prelude: type String = [Char]
+ Clash.Explicit.Prelude: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Clash.Explicit.Prelude: unlines :: [String] -> String
+ Clash.Explicit.Prelude: until :: () => a -> Bool -> a -> a -> a -> a
+ Clash.Explicit.Prelude: unwords :: [String] -> String
+ Clash.Explicit.Prelude: userError :: String -> IOError
+ Clash.Explicit.Prelude: words :: String -> [String]
+ Clash.Explicit.Prelude: writeFile :: FilePath -> String -> IO ()
+ Clash.Explicit.Prelude.Safe: ($!) :: () => a -> b -> a -> b
+ Clash.Explicit.Prelude.Safe: ($) :: () => a -> b -> a -> b
+ Clash.Explicit.Prelude.Safe: (&&) :: Bool -> Bool -> Bool
+ Clash.Explicit.Prelude.Safe: (*) :: Num a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: (**) :: Floating a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: (*>) :: Applicative f => f a -> f b -> f b
+ Clash.Explicit.Prelude.Safe: (+) :: Num a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: (-) :: Num a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: (.) :: () => b -> c -> a -> b -> a -> c
+ Clash.Explicit.Prelude.Safe: (/) :: Fractional a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: (/=) :: Eq a => a -> a -> Bool
+ Clash.Explicit.Prelude.Safe: (<$) :: Functor f => a -> f b -> f a
+ Clash.Explicit.Prelude.Safe: (<$>) :: Functor f => a -> b -> f a -> f b
+ Clash.Explicit.Prelude.Safe: (<) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude.Safe: (<*) :: Applicative f => f a -> f b -> f a
+ Clash.Explicit.Prelude.Safe: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Clash.Explicit.Prelude.Safe: (<=) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude.Safe: (<>) :: Semigroup a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Clash.Explicit.Prelude.Safe: (==) :: Eq a => a -> a -> Bool
+ Clash.Explicit.Prelude.Safe: (>) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude.Safe: (>=) :: Ord a => a -> a -> Bool
+ Clash.Explicit.Prelude.Safe: (>>) :: Monad m => m a -> m b -> m b
+ Clash.Explicit.Prelude.Safe: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Clash.Explicit.Prelude.Safe: (^) :: (Num a, Integral b) => a -> b -> a
+ Clash.Explicit.Prelude.Safe: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Clash.Explicit.Prelude.Safe: (||) :: Bool -> Bool -> Bool
+ Clash.Explicit.Prelude.Safe: EQ :: Ordering
+ Clash.Explicit.Prelude.Safe: False :: Bool
+ Clash.Explicit.Prelude.Safe: GT :: Ordering
+ Clash.Explicit.Prelude.Safe: Just :: a -> Maybe a
+ Clash.Explicit.Prelude.Safe: LT :: Ordering
+ Clash.Explicit.Prelude.Safe: Left :: a -> Either a b
+ Clash.Explicit.Prelude.Safe: Nothing :: Maybe a
+ Clash.Explicit.Prelude.Safe: Right :: b -> Either a b
+ Clash.Explicit.Prelude.Safe: True :: Bool
+ Clash.Explicit.Prelude.Safe: abs :: Num a => a -> a
+ Clash.Explicit.Prelude.Safe: acos :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: acosh :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: all :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Explicit.Prelude.Safe: and :: Foldable t => t Bool -> Bool
+ Clash.Explicit.Prelude.Safe: any :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Explicit.Prelude.Safe: appendFile :: FilePath -> String -> IO ()
+ Clash.Explicit.Prelude.Safe: asTypeOf :: () => a -> a -> a
+ Clash.Explicit.Prelude.Safe: asin :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: asinh :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: atan :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: atan2 :: RealFloat a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: atanh :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Explicit.Prelude.Safe: ceiling :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude.Safe: class Functor f => Applicative (f :: * -> *)
+ Clash.Explicit.Prelude.Safe: class Bounded a
+ Clash.Explicit.Prelude.Safe: class Enum a
+ Clash.Explicit.Prelude.Safe: class Eq a
+ Clash.Explicit.Prelude.Safe: class Fractional a => Floating a
+ Clash.Explicit.Prelude.Safe: class Foldable (t :: * -> *)
+ Clash.Explicit.Prelude.Safe: class Num a => Fractional a
+ Clash.Explicit.Prelude.Safe: class Functor (f :: * -> *)
+ Clash.Explicit.Prelude.Safe: class (Real a, Enum a) => Integral a
+ Clash.Explicit.Prelude.Safe: class Applicative m => Monad (m :: * -> *)
+ Clash.Explicit.Prelude.Safe: class Semigroup a => Monoid a
+ Clash.Explicit.Prelude.Safe: class Num a
+ Clash.Explicit.Prelude.Safe: class Eq a => Ord a
+ Clash.Explicit.Prelude.Safe: class Read a
+ Clash.Explicit.Prelude.Safe: class (Num a, Ord a) => Real a
+ Clash.Explicit.Prelude.Safe: class (RealFrac a, Floating a) => RealFloat a
+ Clash.Explicit.Prelude.Safe: class (Real a, Fractional a) => RealFrac a
+ Clash.Explicit.Prelude.Safe: class Semigroup a
+ Clash.Explicit.Prelude.Safe: class Show a
+ Clash.Explicit.Prelude.Safe: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Clash.Explicit.Prelude.Safe: compare :: Ord a => a -> a -> Ordering
+ Clash.Explicit.Prelude.Safe: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Clash.Explicit.Prelude.Safe: const :: () => a -> b -> a
+ Clash.Explicit.Prelude.Safe: cos :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: cosh :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: curry :: () => (a, b) -> c -> a -> b -> c
+ Clash.Explicit.Prelude.Safe: cycle :: () => [a] -> [a]
+ Clash.Explicit.Prelude.Safe: data Bool
+ Clash.Explicit.Prelude.Safe: data Char
+ Clash.Explicit.Prelude.Safe: data Double
+ Clash.Explicit.Prelude.Safe: data Either a b
+ Clash.Explicit.Prelude.Safe: data Float
+ Clash.Explicit.Prelude.Safe: data IO a
+ Clash.Explicit.Prelude.Safe: data Int
+ Clash.Explicit.Prelude.Safe: data Integer
+ Clash.Explicit.Prelude.Safe: data Maybe a
+ Clash.Explicit.Prelude.Safe: data Ordering
+ Clash.Explicit.Prelude.Safe: data Word
+ Clash.Explicit.Prelude.Safe: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Clash.Explicit.Prelude.Safe: div :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: divMod :: Integral a => a -> a -> (a, a)
+ Clash.Explicit.Prelude.Safe: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Explicit.Prelude.Safe: either :: () => a -> c -> b -> c -> Either a b -> c
+ Clash.Explicit.Prelude.Safe: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Explicit.Prelude.Safe: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Clash.Explicit.Prelude.Safe: enumFrom :: Enum a => a -> [a]
+ Clash.Explicit.Prelude.Safe: enumFromThen :: Enum a => a -> a -> [a]
+ Clash.Explicit.Prelude.Safe: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Clash.Explicit.Prelude.Safe: enumFromTo :: Enum a => a -> a -> [a]
+ Clash.Explicit.Prelude.Safe: error :: HasCallStack => [Char] -> a
+ Clash.Explicit.Prelude.Safe: errorWithoutStackTrace :: () => [Char] -> a
+ Clash.Explicit.Prelude.Safe: even :: Integral a => a -> Bool
+ Clash.Explicit.Prelude.Safe: exp :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: exponent :: RealFloat a => a -> Int
+ Clash.Explicit.Prelude.Safe: fail :: Monad m => String -> m a
+ Clash.Explicit.Prelude.Safe: filter :: () => a -> Bool -> [a] -> [a]
+ Clash.Explicit.Prelude.Safe: flip :: () => a -> b -> c -> b -> a -> c
+ Clash.Explicit.Prelude.Safe: floatDigits :: RealFloat a => a -> Int
+ Clash.Explicit.Prelude.Safe: floatRadix :: RealFloat a => a -> Integer
+ Clash.Explicit.Prelude.Safe: floatRange :: RealFloat a => a -> (Int, Int)
+ Clash.Explicit.Prelude.Safe: floor :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude.Safe: fmap :: Functor f => a -> b -> f a -> f b
+ Clash.Explicit.Prelude.Safe: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Clash.Explicit.Prelude.Safe: fromEnum :: Enum a => a -> Int
+ Clash.Explicit.Prelude.Safe: fromInteger :: Num a => Integer -> a
+ Clash.Explicit.Prelude.Safe: fromIntegral :: (Integral a, Num b) => a -> b
+ Clash.Explicit.Prelude.Safe: fromRational :: Fractional a => Rational -> a
+ Clash.Explicit.Prelude.Safe: fst :: () => (a, b) -> a
+ Clash.Explicit.Prelude.Safe: gcd :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: getChar :: IO Char
+ Clash.Explicit.Prelude.Safe: getContents :: IO String
+ Clash.Explicit.Prelude.Safe: getLine :: IO String
+ Clash.Explicit.Prelude.Safe: id :: () => a -> a
+ Clash.Explicit.Prelude.Safe: infix 4 `notElem`
+ Clash.Explicit.Prelude.Safe: infixl 4 <$>
+ Clash.Explicit.Prelude.Safe: infixr 0 $!
+ Clash.Explicit.Prelude.Safe: infixr 1 =<<
+ Clash.Explicit.Prelude.Safe: infixr 2 ||
+ Clash.Explicit.Prelude.Safe: infixr 3 &&
+ Clash.Explicit.Prelude.Safe: infixr 8 ^
+ Clash.Explicit.Prelude.Safe: infixr 9 .
+ Clash.Explicit.Prelude.Safe: interact :: String -> String -> IO ()
+ Clash.Explicit.Prelude.Safe: ioError :: () => IOError -> IO a
+ Clash.Explicit.Prelude.Safe: isDenormalized :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude.Safe: isIEEE :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude.Safe: isInfinite :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude.Safe: isNaN :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude.Safe: isNegativeZero :: RealFloat a => a -> Bool
+ Clash.Explicit.Prelude.Safe: lcm :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: lex :: ReadS String
+ Clash.Explicit.Prelude.Safe: lines :: String -> [String]
+ Clash.Explicit.Prelude.Safe: log :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: logBase :: Floating a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Clash.Explicit.Prelude.Safe: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Clash.Explicit.Prelude.Safe: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Clash.Explicit.Prelude.Safe: mappend :: Monoid a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: max :: Ord a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: maxBound :: Bounded a => a
+ Clash.Explicit.Prelude.Safe: maximum :: (Foldable t, Ord a) => t a -> a
+ Clash.Explicit.Prelude.Safe: maybe :: () => b -> a -> b -> Maybe a -> b
+ Clash.Explicit.Prelude.Safe: mconcat :: Monoid a => [a] -> a
+ Clash.Explicit.Prelude.Safe: mempty :: Monoid a => a
+ Clash.Explicit.Prelude.Safe: min :: Ord a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: minBound :: Bounded a => a
+ Clash.Explicit.Prelude.Safe: minimum :: (Foldable t, Ord a) => t a -> a
+ Clash.Explicit.Prelude.Safe: mod :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: negate :: Num a => a -> a
+ Clash.Explicit.Prelude.Safe: not :: Bool -> Bool
+ Clash.Explicit.Prelude.Safe: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Explicit.Prelude.Safe: null :: Foldable t => t a -> Bool
+ Clash.Explicit.Prelude.Safe: odd :: Integral a => a -> Bool
+ Clash.Explicit.Prelude.Safe: or :: Foldable t => t Bool -> Bool
+ Clash.Explicit.Prelude.Safe: otherwise :: Bool
+ Clash.Explicit.Prelude.Safe: pi :: Floating a => a
+ Clash.Explicit.Prelude.Safe: pred :: Enum a => a -> a
+ Clash.Explicit.Prelude.Safe: print :: Show a => a -> IO ()
+ Clash.Explicit.Prelude.Safe: product :: (Foldable t, Num a) => t a -> a
+ Clash.Explicit.Prelude.Safe: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Clash.Explicit.Prelude.Safe: pure :: Applicative f => a -> f a
+ Clash.Explicit.Prelude.Safe: putChar :: Char -> IO ()
+ Clash.Explicit.Prelude.Safe: putStr :: String -> IO ()
+ Clash.Explicit.Prelude.Safe: putStrLn :: String -> IO ()
+ Clash.Explicit.Prelude.Safe: quot :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: quotRem :: Integral a => a -> a -> (a, a)
+ Clash.Explicit.Prelude.Safe: read :: Read a => String -> a
+ Clash.Explicit.Prelude.Safe: readFile :: FilePath -> IO String
+ Clash.Explicit.Prelude.Safe: readIO :: Read a => String -> IO a
+ Clash.Explicit.Prelude.Safe: readList :: Read a => ReadS [a]
+ Clash.Explicit.Prelude.Safe: readLn :: Read a => IO a
+ Clash.Explicit.Prelude.Safe: readParen :: () => Bool -> ReadS a -> ReadS a
+ Clash.Explicit.Prelude.Safe: reads :: Read a => ReadS a
+ Clash.Explicit.Prelude.Safe: readsPrec :: Read a => Int -> ReadS a
+ Clash.Explicit.Prelude.Safe: realToFrac :: (Real a, Fractional b) => a -> b
+ Clash.Explicit.Prelude.Safe: recip :: Fractional a => a -> a
+ Clash.Explicit.Prelude.Safe: rem :: Integral a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: return :: Monad m => a -> m a
+ Clash.Explicit.Prelude.Safe: round :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude.Safe: scaleFloat :: RealFloat a => Int -> a -> a
+ Clash.Explicit.Prelude.Safe: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Explicit.Prelude.Safe: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Explicit.Prelude.Safe: seq :: () => a -> b -> b
+ Clash.Explicit.Prelude.Safe: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Clash.Explicit.Prelude.Safe: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Clash.Explicit.Prelude.Safe: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Clash.Explicit.Prelude.Safe: show :: Show a => a -> String
+ Clash.Explicit.Prelude.Safe: showChar :: Char -> ShowS
+ Clash.Explicit.Prelude.Safe: showList :: Show a => [a] -> ShowS
+ Clash.Explicit.Prelude.Safe: showParen :: Bool -> ShowS -> ShowS
+ Clash.Explicit.Prelude.Safe: showString :: String -> ShowS
+ Clash.Explicit.Prelude.Safe: shows :: Show a => a -> ShowS
+ Clash.Explicit.Prelude.Safe: showsPrec :: Show a => Int -> a -> ShowS
+ Clash.Explicit.Prelude.Safe: significand :: RealFloat a => a -> a
+ Clash.Explicit.Prelude.Safe: signum :: Num a => a -> a
+ Clash.Explicit.Prelude.Safe: sin :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: sinh :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: snd :: () => (a, b) -> b
+ Clash.Explicit.Prelude.Safe: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Explicit.Prelude.Safe: sqrt :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: subtract :: Num a => a -> a -> a
+ Clash.Explicit.Prelude.Safe: succ :: Enum a => a -> a
+ Clash.Explicit.Prelude.Safe: sum :: (Foldable t, Num a) => t a -> a
+ Clash.Explicit.Prelude.Safe: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Explicit.Prelude.Safe: tan :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: tanh :: Floating a => a -> a
+ Clash.Explicit.Prelude.Safe: toEnum :: Enum a => Int -> a
+ Clash.Explicit.Prelude.Safe: toInteger :: Integral a => a -> Integer
+ Clash.Explicit.Prelude.Safe: toRational :: Real a => a -> Rational
+ Clash.Explicit.Prelude.Safe: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Clash.Explicit.Prelude.Safe: truncate :: (RealFrac a, Integral b) => a -> b
+ Clash.Explicit.Prelude.Safe: type FilePath = String
+ Clash.Explicit.Prelude.Safe: type IOError = IOException
+ Clash.Explicit.Prelude.Safe: type Rational = Ratio Integer
+ Clash.Explicit.Prelude.Safe: type ReadS a = String -> [(a, String)]
+ Clash.Explicit.Prelude.Safe: type ShowS = String -> String
+ Clash.Explicit.Prelude.Safe: type String = [Char]
+ Clash.Explicit.Prelude.Safe: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Clash.Explicit.Prelude.Safe: unlines :: [String] -> String
+ Clash.Explicit.Prelude.Safe: until :: () => a -> Bool -> a -> a -> a -> a
+ Clash.Explicit.Prelude.Safe: unwords :: [String] -> String
+ Clash.Explicit.Prelude.Safe: userError :: String -> IOError
+ Clash.Explicit.Prelude.Safe: words :: String -> [String]
+ Clash.Explicit.Prelude.Safe: writeFile :: FilePath -> String -> IO ()
+ Clash.Prelude: ($!) :: () => a -> b -> a -> b
+ Clash.Prelude: ($) :: () => a -> b -> a -> b
+ Clash.Prelude: (&&) :: Bool -> Bool -> Bool
+ Clash.Prelude: (*) :: Num a => a -> a -> a
+ Clash.Prelude: (**) :: Floating a => a -> a -> a
+ Clash.Prelude: (*>) :: Applicative f => f a -> f b -> f b
+ Clash.Prelude: (+) :: Num a => a -> a -> a
+ Clash.Prelude: (-) :: Num a => a -> a -> a
+ Clash.Prelude: (.) :: () => b -> c -> a -> b -> a -> c
+ Clash.Prelude: (/) :: Fractional a => a -> a -> a
+ Clash.Prelude: (/=) :: Eq a => a -> a -> Bool
+ Clash.Prelude: (<$) :: Functor f => a -> f b -> f a
+ Clash.Prelude: (<$>) :: Functor f => a -> b -> f a -> f b
+ Clash.Prelude: (<) :: Ord a => a -> a -> Bool
+ Clash.Prelude: (<*) :: Applicative f => f a -> f b -> f a
+ Clash.Prelude: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Clash.Prelude: (<=) :: Ord a => a -> a -> Bool
+ Clash.Prelude: (<>) :: Semigroup a => a -> a -> a
+ Clash.Prelude: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Clash.Prelude: (==) :: Eq a => a -> a -> Bool
+ Clash.Prelude: (>) :: Ord a => a -> a -> Bool
+ Clash.Prelude: (>=) :: Ord a => a -> a -> Bool
+ Clash.Prelude: (>>) :: Monad m => m a -> m b -> m b
+ Clash.Prelude: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Clash.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ Clash.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Clash.Prelude: (||) :: Bool -> Bool -> Bool
+ Clash.Prelude: EQ :: Ordering
+ Clash.Prelude: False :: Bool
+ Clash.Prelude: GT :: Ordering
+ Clash.Prelude: Just :: a -> Maybe a
+ Clash.Prelude: LT :: Ordering
+ Clash.Prelude: Left :: a -> Either a b
+ Clash.Prelude: Nothing :: Maybe a
+ Clash.Prelude: Right :: b -> Either a b
+ Clash.Prelude: True :: Bool
+ Clash.Prelude: abs :: Num a => a -> a
+ Clash.Prelude: acos :: Floating a => a -> a
+ Clash.Prelude: acosh :: Floating a => a -> a
+ Clash.Prelude: all :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Prelude: and :: Foldable t => t Bool -> Bool
+ Clash.Prelude: any :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Prelude: appendFile :: FilePath -> String -> IO ()
+ Clash.Prelude: asTypeOf :: () => a -> a -> a
+ Clash.Prelude: asin :: Floating a => a -> a
+ Clash.Prelude: asinh :: Floating a => a -> a
+ Clash.Prelude: atan :: Floating a => a -> a
+ Clash.Prelude: atan2 :: RealFloat a => a -> a -> a
+ Clash.Prelude: atanh :: Floating a => a -> a
+ Clash.Prelude: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude: class Functor f => Applicative (f :: * -> *)
+ Clash.Prelude: class Bounded a
+ Clash.Prelude: class Enum a
+ Clash.Prelude: class Eq a
+ Clash.Prelude: class Fractional a => Floating a
+ Clash.Prelude: class Foldable (t :: * -> *)
+ Clash.Prelude: class Num a => Fractional a
+ Clash.Prelude: class Functor (f :: * -> *)
+ Clash.Prelude: class (Real a, Enum a) => Integral a
+ Clash.Prelude: class Applicative m => Monad (m :: * -> *)
+ Clash.Prelude: class Semigroup a => Monoid a
+ Clash.Prelude: class Num a
+ Clash.Prelude: class Eq a => Ord a
+ Clash.Prelude: class Read a
+ Clash.Prelude: class (Num a, Ord a) => Real a
+ Clash.Prelude: class (RealFrac a, Floating a) => RealFloat a
+ Clash.Prelude: class (Real a, Fractional a) => RealFrac a
+ Clash.Prelude: class Semigroup a
+ Clash.Prelude: class Show a
+ Clash.Prelude: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Clash.Prelude: compare :: Ord a => a -> a -> Ordering
+ Clash.Prelude: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Clash.Prelude: const :: () => a -> b -> a
+ Clash.Prelude: cos :: Floating a => a -> a
+ Clash.Prelude: cosh :: Floating a => a -> a
+ Clash.Prelude: curry :: () => (a, b) -> c -> a -> b -> c
+ Clash.Prelude: cycle :: () => [a] -> [a]
+ Clash.Prelude: data Bool
+ Clash.Prelude: data Char
+ Clash.Prelude: data Double
+ Clash.Prelude: data Either a b
+ Clash.Prelude: data Float
+ Clash.Prelude: data IO a
+ Clash.Prelude: data Int
+ Clash.Prelude: data Integer
+ Clash.Prelude: data Maybe a
+ Clash.Prelude: data Ordering
+ Clash.Prelude: data Word
+ Clash.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Clash.Prelude: div :: Integral a => a -> a -> a
+ Clash.Prelude: divMod :: Integral a => a -> a -> (a, a)
+ Clash.Prelude: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Prelude: either :: () => a -> c -> b -> c -> Either a b -> c
+ Clash.Prelude: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Clash.Prelude: enumFrom :: Enum a => a -> [a]
+ Clash.Prelude: enumFromThen :: Enum a => a -> a -> [a]
+ Clash.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Clash.Prelude: enumFromTo :: Enum a => a -> a -> [a]
+ Clash.Prelude: error :: HasCallStack => [Char] -> a
+ Clash.Prelude: errorWithoutStackTrace :: () => [Char] -> a
+ Clash.Prelude: even :: Integral a => a -> Bool
+ Clash.Prelude: exp :: Floating a => a -> a
+ Clash.Prelude: exponent :: RealFloat a => a -> Int
+ Clash.Prelude: fail :: Monad m => String -> m a
+ Clash.Prelude: filter :: () => a -> Bool -> [a] -> [a]
+ Clash.Prelude: flip :: () => a -> b -> c -> b -> a -> c
+ Clash.Prelude: floatDigits :: RealFloat a => a -> Int
+ Clash.Prelude: floatRadix :: RealFloat a => a -> Integer
+ Clash.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
+ Clash.Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude: fmap :: Functor f => a -> b -> f a -> f b
+ Clash.Prelude: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Clash.Prelude: fromEnum :: Enum a => a -> Int
+ Clash.Prelude: fromInteger :: Num a => Integer -> a
+ Clash.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ Clash.Prelude: fromRational :: Fractional a => Rational -> a
+ Clash.Prelude: fst :: () => (a, b) -> a
+ Clash.Prelude: gcd :: Integral a => a -> a -> a
+ Clash.Prelude: getChar :: IO Char
+ Clash.Prelude: getContents :: IO String
+ Clash.Prelude: getLine :: IO String
+ Clash.Prelude: id :: () => a -> a
+ Clash.Prelude: infix 4 `notElem`
+ Clash.Prelude: infixl 4 <$>
+ Clash.Prelude: infixr 0 $!
+ Clash.Prelude: infixr 1 =<<
+ Clash.Prelude: infixr 2 ||
+ Clash.Prelude: infixr 8 ^
+ Clash.Prelude: infixr 9 .
+ Clash.Prelude: interact :: String -> String -> IO ()
+ Clash.Prelude: ioError :: () => IOError -> IO a
+ Clash.Prelude: isDenormalized :: RealFloat a => a -> Bool
+ Clash.Prelude: isIEEE :: RealFloat a => a -> Bool
+ Clash.Prelude: isInfinite :: RealFloat a => a -> Bool
+ Clash.Prelude: isNaN :: RealFloat a => a -> Bool
+ Clash.Prelude: isNegativeZero :: RealFloat a => a -> Bool
+ Clash.Prelude: lcm :: Integral a => a -> a -> a
+ Clash.Prelude: lex :: ReadS String
+ Clash.Prelude: lines :: String -> [String]
+ Clash.Prelude: log :: Floating a => a -> a
+ Clash.Prelude: logBase :: Floating a => a -> a -> a
+ Clash.Prelude: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Clash.Prelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Clash.Prelude: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Clash.Prelude: mappend :: Monoid a => a -> a -> a
+ Clash.Prelude: max :: Ord a => a -> a -> a
+ Clash.Prelude: maxBound :: Bounded a => a
+ Clash.Prelude: maximum :: (Foldable t, Ord a) => t a -> a
+ Clash.Prelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ Clash.Prelude: mconcat :: Monoid a => [a] -> a
+ Clash.Prelude: mempty :: Monoid a => a
+ Clash.Prelude: min :: Ord a => a -> a -> a
+ Clash.Prelude: minBound :: Bounded a => a
+ Clash.Prelude: minimum :: (Foldable t, Ord a) => t a -> a
+ Clash.Prelude: mod :: Integral a => a -> a -> a
+ Clash.Prelude: negate :: Num a => a -> a
+ Clash.Prelude: not :: Bool -> Bool
+ Clash.Prelude: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Prelude: null :: Foldable t => t a -> Bool
+ Clash.Prelude: odd :: Integral a => a -> Bool
+ Clash.Prelude: or :: Foldable t => t Bool -> Bool
+ Clash.Prelude: oscillate :: HiddenClockReset domain gated synchronous => Bool -> SNat n -> Signal domain Bool
+ Clash.Prelude: otherwise :: Bool
+ Clash.Prelude: pi :: Floating a => a
+ Clash.Prelude: pred :: Enum a => a -> a
+ Clash.Prelude: print :: Show a => a -> IO ()
+ Clash.Prelude: product :: (Foldable t, Num a) => t a -> a
+ Clash.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Clash.Prelude: pure :: Applicative f => a -> f a
+ Clash.Prelude: putChar :: Char -> IO ()
+ Clash.Prelude: putStr :: String -> IO ()
+ Clash.Prelude: putStrLn :: String -> IO ()
+ Clash.Prelude: quot :: Integral a => a -> a -> a
+ Clash.Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ Clash.Prelude: read :: Read a => String -> a
+ Clash.Prelude: readFile :: FilePath -> IO String
+ Clash.Prelude: readIO :: Read a => String -> IO a
+ Clash.Prelude: readList :: Read a => ReadS [a]
+ Clash.Prelude: readLn :: Read a => IO a
+ Clash.Prelude: readParen :: () => Bool -> ReadS a -> ReadS a
+ Clash.Prelude: reads :: Read a => ReadS a
+ Clash.Prelude: readsPrec :: Read a => Int -> ReadS a
+ Clash.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
+ Clash.Prelude: recip :: Fractional a => a -> a
+ Clash.Prelude: rem :: Integral a => a -> a -> a
+ Clash.Prelude: return :: Monad m => a -> m a
+ Clash.Prelude: riseEvery :: HiddenClockReset domain gated synchronous => SNat n -> Signal domain Bool
+ Clash.Prelude: round :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude: scaleFloat :: RealFloat a => Int -> a -> a
+ Clash.Prelude: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Prelude: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Prelude: seq :: () => a -> b -> b
+ Clash.Prelude: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Clash.Prelude: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Clash.Prelude: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Clash.Prelude: show :: Show a => a -> String
+ Clash.Prelude: showChar :: Char -> ShowS
+ Clash.Prelude: showList :: Show a => [a] -> ShowS
+ Clash.Prelude: showParen :: Bool -> ShowS -> ShowS
+ Clash.Prelude: showString :: String -> ShowS
+ Clash.Prelude: shows :: Show a => a -> ShowS
+ Clash.Prelude: showsPrec :: Show a => Int -> a -> ShowS
+ Clash.Prelude: significand :: RealFloat a => a -> a
+ Clash.Prelude: signum :: Num a => a -> a
+ Clash.Prelude: sin :: Floating a => a -> a
+ Clash.Prelude: sinh :: Floating a => a -> a
+ Clash.Prelude: snd :: () => (a, b) -> b
+ Clash.Prelude: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Prelude: sqrt :: Floating a => a -> a
+ Clash.Prelude: subtract :: Num a => a -> a -> a
+ Clash.Prelude: succ :: Enum a => a -> a
+ Clash.Prelude: sum :: (Foldable t, Num a) => t a -> a
+ Clash.Prelude: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Prelude: tan :: Floating a => a -> a
+ Clash.Prelude: tanh :: Floating a => a -> a
+ Clash.Prelude: toEnum :: Enum a => Int -> a
+ Clash.Prelude: toInteger :: Integral a => a -> Integer
+ Clash.Prelude: toRational :: Real a => a -> Rational
+ Clash.Prelude: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Clash.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude: type FilePath = String
+ Clash.Prelude: type IOError = IOException
+ Clash.Prelude: type Rational = Ratio Integer
+ Clash.Prelude: type ReadS a = String -> [(a, String)]
+ Clash.Prelude: type ShowS = String -> String
+ Clash.Prelude: type String = [Char]
+ Clash.Prelude: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Clash.Prelude: unlines :: [String] -> String
+ Clash.Prelude: until :: () => a -> Bool -> a -> a -> a -> a
+ Clash.Prelude: unwords :: [String] -> String
+ Clash.Prelude: userError :: String -> IOError
+ Clash.Prelude: words :: String -> [String]
+ Clash.Prelude: writeFile :: FilePath -> String -> IO ()
+ Clash.Prelude.Safe: ($!) :: () => a -> b -> a -> b
+ Clash.Prelude.Safe: ($) :: () => a -> b -> a -> b
+ Clash.Prelude.Safe: (&&) :: Bool -> Bool -> Bool
+ Clash.Prelude.Safe: (*) :: Num a => a -> a -> a
+ Clash.Prelude.Safe: (**) :: Floating a => a -> a -> a
+ Clash.Prelude.Safe: (*>) :: Applicative f => f a -> f b -> f b
+ Clash.Prelude.Safe: (+) :: Num a => a -> a -> a
+ Clash.Prelude.Safe: (-) :: Num a => a -> a -> a
+ Clash.Prelude.Safe: (.) :: () => b -> c -> a -> b -> a -> c
+ Clash.Prelude.Safe: (/) :: Fractional a => a -> a -> a
+ Clash.Prelude.Safe: (/=) :: Eq a => a -> a -> Bool
+ Clash.Prelude.Safe: (<$) :: Functor f => a -> f b -> f a
+ Clash.Prelude.Safe: (<$>) :: Functor f => a -> b -> f a -> f b
+ Clash.Prelude.Safe: (<) :: Ord a => a -> a -> Bool
+ Clash.Prelude.Safe: (<*) :: Applicative f => f a -> f b -> f a
+ Clash.Prelude.Safe: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Clash.Prelude.Safe: (<=) :: Ord a => a -> a -> Bool
+ Clash.Prelude.Safe: (<>) :: Semigroup a => a -> a -> a
+ Clash.Prelude.Safe: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Clash.Prelude.Safe: (==) :: Eq a => a -> a -> Bool
+ Clash.Prelude.Safe: (>) :: Ord a => a -> a -> Bool
+ Clash.Prelude.Safe: (>=) :: Ord a => a -> a -> Bool
+ Clash.Prelude.Safe: (>>) :: Monad m => m a -> m b -> m b
+ Clash.Prelude.Safe: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Clash.Prelude.Safe: (^) :: (Num a, Integral b) => a -> b -> a
+ Clash.Prelude.Safe: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Clash.Prelude.Safe: (||) :: Bool -> Bool -> Bool
+ Clash.Prelude.Safe: EQ :: Ordering
+ Clash.Prelude.Safe: False :: Bool
+ Clash.Prelude.Safe: GT :: Ordering
+ Clash.Prelude.Safe: Just :: a -> Maybe a
+ Clash.Prelude.Safe: LT :: Ordering
+ Clash.Prelude.Safe: Left :: a -> Either a b
+ Clash.Prelude.Safe: Nothing :: Maybe a
+ Clash.Prelude.Safe: Right :: b -> Either a b
+ Clash.Prelude.Safe: True :: Bool
+ Clash.Prelude.Safe: abs :: Num a => a -> a
+ Clash.Prelude.Safe: acos :: Floating a => a -> a
+ Clash.Prelude.Safe: acosh :: Floating a => a -> a
+ Clash.Prelude.Safe: all :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Prelude.Safe: and :: Foldable t => t Bool -> Bool
+ Clash.Prelude.Safe: any :: Foldable t => a -> Bool -> t a -> Bool
+ Clash.Prelude.Safe: appendFile :: FilePath -> String -> IO ()
+ Clash.Prelude.Safe: asTypeOf :: () => a -> a -> a
+ Clash.Prelude.Safe: asin :: Floating a => a -> a
+ Clash.Prelude.Safe: asinh :: Floating a => a -> a
+ Clash.Prelude.Safe: atan :: Floating a => a -> a
+ Clash.Prelude.Safe: atan2 :: RealFloat a => a -> a -> a
+ Clash.Prelude.Safe: atanh :: Floating a => a -> a
+ Clash.Prelude.Safe: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Prelude.Safe: ceiling :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude.Safe: class Functor f => Applicative (f :: * -> *)
+ Clash.Prelude.Safe: class Bounded a
+ Clash.Prelude.Safe: class Enum a
+ Clash.Prelude.Safe: class Eq a
+ Clash.Prelude.Safe: class Fractional a => Floating a
+ Clash.Prelude.Safe: class Foldable (t :: * -> *)
+ Clash.Prelude.Safe: class Num a => Fractional a
+ Clash.Prelude.Safe: class Functor (f :: * -> *)
+ Clash.Prelude.Safe: class (Real a, Enum a) => Integral a
+ Clash.Prelude.Safe: class Applicative m => Monad (m :: * -> *)
+ Clash.Prelude.Safe: class Semigroup a => Monoid a
+ Clash.Prelude.Safe: class Num a
+ Clash.Prelude.Safe: class Eq a => Ord a
+ Clash.Prelude.Safe: class Read a
+ Clash.Prelude.Safe: class (Num a, Ord a) => Real a
+ Clash.Prelude.Safe: class (RealFrac a, Floating a) => RealFloat a
+ Clash.Prelude.Safe: class (Real a, Fractional a) => RealFrac a
+ Clash.Prelude.Safe: class Semigroup a
+ Clash.Prelude.Safe: class Show a
+ Clash.Prelude.Safe: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Clash.Prelude.Safe: compare :: Ord a => a -> a -> Ordering
+ Clash.Prelude.Safe: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Clash.Prelude.Safe: const :: () => a -> b -> a
+ Clash.Prelude.Safe: cos :: Floating a => a -> a
+ Clash.Prelude.Safe: cosh :: Floating a => a -> a
+ Clash.Prelude.Safe: curry :: () => (a, b) -> c -> a -> b -> c
+ Clash.Prelude.Safe: cycle :: () => [a] -> [a]
+ Clash.Prelude.Safe: data Bool
+ Clash.Prelude.Safe: data Char
+ Clash.Prelude.Safe: data Double
+ Clash.Prelude.Safe: data Either a b
+ Clash.Prelude.Safe: data Float
+ Clash.Prelude.Safe: data IO a
+ Clash.Prelude.Safe: data Int
+ Clash.Prelude.Safe: data Integer
+ Clash.Prelude.Safe: data Maybe a
+ Clash.Prelude.Safe: data Ordering
+ Clash.Prelude.Safe: data Word
+ Clash.Prelude.Safe: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Clash.Prelude.Safe: div :: Integral a => a -> a -> a
+ Clash.Prelude.Safe: divMod :: Integral a => a -> a -> (a, a)
+ Clash.Prelude.Safe: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Prelude.Safe: either :: () => a -> c -> b -> c -> Either a b -> c
+ Clash.Prelude.Safe: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Prelude.Safe: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Clash.Prelude.Safe: enumFrom :: Enum a => a -> [a]
+ Clash.Prelude.Safe: enumFromThen :: Enum a => a -> a -> [a]
+ Clash.Prelude.Safe: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Clash.Prelude.Safe: enumFromTo :: Enum a => a -> a -> [a]
+ Clash.Prelude.Safe: error :: HasCallStack => [Char] -> a
+ Clash.Prelude.Safe: errorWithoutStackTrace :: () => [Char] -> a
+ Clash.Prelude.Safe: even :: Integral a => a -> Bool
+ Clash.Prelude.Safe: exp :: Floating a => a -> a
+ Clash.Prelude.Safe: exponent :: RealFloat a => a -> Int
+ Clash.Prelude.Safe: fail :: Monad m => String -> m a
+ Clash.Prelude.Safe: filter :: () => a -> Bool -> [a] -> [a]
+ Clash.Prelude.Safe: flip :: () => a -> b -> c -> b -> a -> c
+ Clash.Prelude.Safe: floatDigits :: RealFloat a => a -> Int
+ Clash.Prelude.Safe: floatRadix :: RealFloat a => a -> Integer
+ Clash.Prelude.Safe: floatRange :: RealFloat a => a -> (Int, Int)
+ Clash.Prelude.Safe: floor :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude.Safe: fmap :: Functor f => a -> b -> f a -> f b
+ Clash.Prelude.Safe: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Clash.Prelude.Safe: fromEnum :: Enum a => a -> Int
+ Clash.Prelude.Safe: fromInteger :: Num a => Integer -> a
+ Clash.Prelude.Safe: fromIntegral :: (Integral a, Num b) => a -> b
+ Clash.Prelude.Safe: fromRational :: Fractional a => Rational -> a
+ Clash.Prelude.Safe: fst :: () => (a, b) -> a
+ Clash.Prelude.Safe: gcd :: Integral a => a -> a -> a
+ Clash.Prelude.Safe: getChar :: IO Char
+ Clash.Prelude.Safe: getContents :: IO String
+ Clash.Prelude.Safe: getLine :: IO String
+ Clash.Prelude.Safe: id :: () => a -> a
+ Clash.Prelude.Safe: infix 4 `notElem`
+ Clash.Prelude.Safe: infixl 4 <$>
+ Clash.Prelude.Safe: infixr 0 $!
+ Clash.Prelude.Safe: infixr 1 =<<
+ Clash.Prelude.Safe: infixr 2 ||
+ Clash.Prelude.Safe: infixr 8 ^
+ Clash.Prelude.Safe: infixr 9 .
+ Clash.Prelude.Safe: interact :: String -> String -> IO ()
+ Clash.Prelude.Safe: ioError :: () => IOError -> IO a
+ Clash.Prelude.Safe: isDenormalized :: RealFloat a => a -> Bool
+ Clash.Prelude.Safe: isIEEE :: RealFloat a => a -> Bool
+ Clash.Prelude.Safe: isInfinite :: RealFloat a => a -> Bool
+ Clash.Prelude.Safe: isNaN :: RealFloat a => a -> Bool
+ Clash.Prelude.Safe: isNegativeZero :: RealFloat a => a -> Bool
+ Clash.Prelude.Safe: lcm :: Integral a => a -> a -> a
+ Clash.Prelude.Safe: lex :: ReadS String
+ Clash.Prelude.Safe: lines :: String -> [String]
+ Clash.Prelude.Safe: log :: Floating a => a -> a
+ Clash.Prelude.Safe: logBase :: Floating a => a -> a -> a
+ Clash.Prelude.Safe: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Clash.Prelude.Safe: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Clash.Prelude.Safe: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Clash.Prelude.Safe: mappend :: Monoid a => a -> a -> a
+ Clash.Prelude.Safe: max :: Ord a => a -> a -> a
+ Clash.Prelude.Safe: maxBound :: Bounded a => a
+ Clash.Prelude.Safe: maximum :: (Foldable t, Ord a) => t a -> a
+ Clash.Prelude.Safe: maybe :: () => b -> a -> b -> Maybe a -> b
+ Clash.Prelude.Safe: mconcat :: Monoid a => [a] -> a
+ Clash.Prelude.Safe: mempty :: Monoid a => a
+ Clash.Prelude.Safe: min :: Ord a => a -> a -> a
+ Clash.Prelude.Safe: minBound :: Bounded a => a
+ Clash.Prelude.Safe: minimum :: (Foldable t, Ord a) => t a -> a
+ Clash.Prelude.Safe: mod :: Integral a => a -> a -> a
+ Clash.Prelude.Safe: negate :: Num a => a -> a
+ Clash.Prelude.Safe: not :: Bool -> Bool
+ Clash.Prelude.Safe: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Clash.Prelude.Safe: null :: Foldable t => t a -> Bool
+ Clash.Prelude.Safe: odd :: Integral a => a -> Bool
+ Clash.Prelude.Safe: or :: Foldable t => t Bool -> Bool
+ Clash.Prelude.Safe: otherwise :: Bool
+ Clash.Prelude.Safe: pi :: Floating a => a
+ Clash.Prelude.Safe: pred :: Enum a => a -> a
+ Clash.Prelude.Safe: print :: Show a => a -> IO ()
+ Clash.Prelude.Safe: product :: (Foldable t, Num a) => t a -> a
+ Clash.Prelude.Safe: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Clash.Prelude.Safe: pure :: Applicative f => a -> f a
+ Clash.Prelude.Safe: putChar :: Char -> IO ()
+ Clash.Prelude.Safe: putStr :: String -> IO ()
+ Clash.Prelude.Safe: putStrLn :: String -> IO ()
+ Clash.Prelude.Safe: quot :: Integral a => a -> a -> a
+ Clash.Prelude.Safe: quotRem :: Integral a => a -> a -> (a, a)
+ Clash.Prelude.Safe: read :: Read a => String -> a
+ Clash.Prelude.Safe: readFile :: FilePath -> IO String
+ Clash.Prelude.Safe: readIO :: Read a => String -> IO a
+ Clash.Prelude.Safe: readList :: Read a => ReadS [a]
+ Clash.Prelude.Safe: readLn :: Read a => IO a
+ Clash.Prelude.Safe: readParen :: () => Bool -> ReadS a -> ReadS a
+ Clash.Prelude.Safe: reads :: Read a => ReadS a
+ Clash.Prelude.Safe: readsPrec :: Read a => Int -> ReadS a
+ Clash.Prelude.Safe: realToFrac :: (Real a, Fractional b) => a -> b
+ Clash.Prelude.Safe: recip :: Fractional a => a -> a
+ Clash.Prelude.Safe: rem :: Integral a => a -> a -> a
+ Clash.Prelude.Safe: return :: Monad m => a -> m a
+ Clash.Prelude.Safe: round :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude.Safe: scaleFloat :: RealFloat a => Int -> a -> a
+ Clash.Prelude.Safe: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Prelude.Safe: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Clash.Prelude.Safe: seq :: () => a -> b -> b
+ Clash.Prelude.Safe: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Clash.Prelude.Safe: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Clash.Prelude.Safe: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Clash.Prelude.Safe: show :: Show a => a -> String
+ Clash.Prelude.Safe: showChar :: Char -> ShowS
+ Clash.Prelude.Safe: showList :: Show a => [a] -> ShowS
+ Clash.Prelude.Safe: showParen :: Bool -> ShowS -> ShowS
+ Clash.Prelude.Safe: showString :: String -> ShowS
+ Clash.Prelude.Safe: shows :: Show a => a -> ShowS
+ Clash.Prelude.Safe: showsPrec :: Show a => Int -> a -> ShowS
+ Clash.Prelude.Safe: significand :: RealFloat a => a -> a
+ Clash.Prelude.Safe: signum :: Num a => a -> a
+ Clash.Prelude.Safe: sin :: Floating a => a -> a
+ Clash.Prelude.Safe: sinh :: Floating a => a -> a
+ Clash.Prelude.Safe: snd :: () => (a, b) -> b
+ Clash.Prelude.Safe: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Clash.Prelude.Safe: sqrt :: Floating a => a -> a
+ Clash.Prelude.Safe: subtract :: Num a => a -> a -> a
+ Clash.Prelude.Safe: succ :: Enum a => a -> a
+ Clash.Prelude.Safe: sum :: (Foldable t, Num a) => t a -> a
+ Clash.Prelude.Safe: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Clash.Prelude.Safe: tan :: Floating a => a -> a
+ Clash.Prelude.Safe: tanh :: Floating a => a -> a
+ Clash.Prelude.Safe: toEnum :: Enum a => Int -> a
+ Clash.Prelude.Safe: toInteger :: Integral a => a -> Integer
+ Clash.Prelude.Safe: toRational :: Real a => a -> Rational
+ Clash.Prelude.Safe: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Clash.Prelude.Safe: truncate :: (RealFrac a, Integral b) => a -> b
+ Clash.Prelude.Safe: type FilePath = String
+ Clash.Prelude.Safe: type IOError = IOException
+ Clash.Prelude.Safe: type Rational = Ratio Integer
+ Clash.Prelude.Safe: type ReadS a = String -> [(a, String)]
+ Clash.Prelude.Safe: type ShowS = String -> String
+ Clash.Prelude.Safe: type String = [Char]
+ Clash.Prelude.Safe: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Clash.Prelude.Safe: unlines :: [String] -> String
+ Clash.Prelude.Safe: until :: () => a -> Bool -> a -> a -> a -> a
+ Clash.Prelude.Safe: unwords :: [String] -> String
+ Clash.Prelude.Safe: userError :: String -> IOError
+ Clash.Prelude.Safe: words :: String -> [String]
+ Clash.Prelude.Safe: writeFile :: FilePath -> String -> IO ()
- Clash.Explicit.Signal.Delayed: feedback :: (DSignal domain n a -> (DSignal domain n a, DSignal domain ((n + m) + 1) a)) -> DSignal domain n a
+ Clash.Explicit.Signal.Delayed: feedback :: (DSignal domain n a -> (DSignal domain n a, DSignal domain (n + m + 1) a)) -> DSignal domain n a
- Clash.Prelude: infixr 3 `registerB`
+ Clash.Prelude: infixr 3 &&
- Clash.Prelude.BitIndex: setSlice :: (BitPack a, BitSize a ~ ((m + 1) + i)) => SNat m -> SNat n -> BitVector ((m + 1) - n) -> a -> a
+ Clash.Prelude.BitIndex: setSlice :: (BitPack a, BitSize a ~ ((m + 1) + i)) => SNat m -> SNat n -> BitVector (m + 1 - n) -> a -> a
- Clash.Prelude.BitIndex: slice :: (BitPack a, BitSize a ~ ((m + 1) + i)) => SNat m -> SNat n -> a -> BitVector ((m + 1) - n)
+ Clash.Prelude.BitIndex: slice :: (BitPack a, BitSize a ~ ((m + 1) + i)) => SNat m -> SNat n -> a -> BitVector (m + 1 - n)
- Clash.Prelude.DataFlow: DF :: (Signal domain i -> Signal domain iEn -> Signal domain oEn -> (Signal domain o, Signal domain oEn, Signal domain iEn)) -> DataFlow domain iEn oEn i o
+ Clash.Prelude.DataFlow: DF :: Signal domain i -> Signal domain iEn -> Signal domain oEn -> (Signal domain o, Signal domain oEn, Signal domain iEn) -> DataFlow domain iEn oEn i o
- Clash.Prelude.Safe: infixr 3 `registerB`
+ Clash.Prelude.Safe: infixr 3 &&
- Clash.Promoted.Nat: div2Sub1BNat :: BNat ((2 * n) + 1) -> BNat n
+ Clash.Promoted.Nat: div2Sub1BNat :: BNat (2 * n + 1) -> BNat n
- Clash.Promoted.Nat: predBNat :: BNat (n + 1) -> (BNat n)
+ Clash.Promoted.Nat: predBNat :: (1 <= n) => BNat n -> BNat (n - 1)
- Clash.Signal.Delayed: feedback :: (DSignal domain n a -> (DSignal domain n a, DSignal domain ((n + m) + 1) a)) -> DSignal domain n a
+ Clash.Signal.Delayed: feedback :: (DSignal domain n a -> (DSignal domain n a, DSignal domain (n + m + 1) a)) -> DSignal domain n a
- Clash.Sized.Fixed: divide :: DivideC rep int1 frac1 int2 frac2 => Fixed rep int1 frac1 -> Fixed rep int2 frac2 -> Fixed rep ((int1 + frac2) + 1) (int2 + frac1)
+ Clash.Sized.Fixed: divide :: DivideC rep int1 frac1 int2 frac2 => Fixed rep int1 frac1 -> Fixed rep int2 frac2 -> Fixed rep (int1 + frac2 + 1) (int2 + frac1)
- Clash.Sized.Fixed: type ENumSFixedC int1 frac1 int2 frac2 = (KnownNat (int2 + frac2), KnownNat ((1 + Max int1 int2) + Max frac1 frac2), KnownNat (Max frac1 frac2), KnownNat (1 + Max int1 int2), KnownNat (int1 + frac1), KnownNat frac2, KnownNat int2, KnownNat frac1, KnownNat int1)
+ Clash.Sized.Fixed: type ENumSFixedC int1 frac1 int2 frac2 = (KnownNat (int2 + frac2), KnownNat (1 + Max int1 int2 + Max frac1 frac2), KnownNat (Max frac1 frac2), KnownNat (1 + Max int1 int2), KnownNat (int1 + frac1), KnownNat frac2, KnownNat int2, KnownNat frac1, KnownNat int1)
- Clash.Sized.Fixed: type FracSFixedC int frac = (NumSFixedC int frac, KnownNat (((int + frac) + 1) + (int + frac)))
+ Clash.Sized.Fixed: type FracSFixedC int frac = (NumSFixedC int frac, KnownNat ((int + frac + 1) + (int + frac)))
- Clash.Sized.Internal.BitVector: setSlice# :: BitVector ((m + 1) + i) -> SNat m -> SNat n -> BitVector ((m + 1) - n) -> BitVector ((m + 1) + i)
+ Clash.Sized.Internal.BitVector: setSlice# :: BitVector (m + 1 + i) -> SNat m -> SNat n -> BitVector (m + 1 - n) -> BitVector (m + 1 + i)
- Clash.Sized.Internal.BitVector: slice# :: BitVector ((m + 1) + i) -> SNat m -> SNat n -> BitVector ((m + 1) - n)
+ Clash.Sized.Internal.BitVector: slice# :: BitVector (m + 1 + i) -> SNat m -> SNat n -> BitVector (m + 1 - n)
- Clash.Sized.Internal.Index: minus# :: Index m -> Index n -> Index ((m + n) - 1)
+ Clash.Sized.Internal.Index: minus# :: Index m -> Index n -> Index (m + n - 1)
- Clash.Sized.Internal.Index: plus# :: Index m -> Index n -> Index ((m + n) - 1)
+ Clash.Sized.Internal.Index: plus# :: Index m -> Index n -> Index (m + n - 1)
- Clash.Sized.Vector: windows2d :: (KnownNat n, KnownNat m) => SNat (stY + 1) -> SNat (stX + 1) -> Vec ((stY + m) + 1) (Vec ((stX + n) + 1) a) -> Vec (m + 1) (Vec (n + 1) (Vec (stY + 1) (Vec (stX + 1) a)))
+ Clash.Sized.Vector: windows2d :: (KnownNat n, KnownNat m) => SNat (stY + 1) -> SNat (stX + 1) -> Vec ((stY + m) + 1) (Vec (stX + n + 1) a) -> Vec (m + 1) (Vec (n + 1) (Vec (stY + 1) (Vec (stX + 1) a)))

Files

CHANGELOG.md view
@@ -1,5 +1,10 @@ # Changelog for [`clash-prelude` package](http://hackage.haskell.org/package/clash-prelude) +## 0.99.1 *May 12th 2018*+* Support for `ghc-typelits-natnormalise-0.6.1`+* `Lift` instances for `TopEntity` and `PortName`+* `InlinePrimitive` support: specify HDL primitives inline with Haskell code+ ## 0.99 *March 31st 2018* * Major API overhaul: check the migration guide at the end of `Clash.Tutorial` * New features:
README.md view
@@ -5,7 +5,7 @@ [![Hackage Dependencies](https://img.shields.io/hackage-deps/v/clash-prelude.svg?style=flat)](http://packdeps.haskellers.com/feed?needle=exact%3Aclash-prelude)  __WARNING__-Only works with GHC-8.0.* (http://www.haskell.org/ghc/download_ghc_8_0_2)!+Only works with GHC-8.2 or higher (http://www.haskell.org/ghc/download_ghc_8_4_2)!  CλaSH (pronounced ‘clash’) is a functional hardware description language that borrows both its syntax and semantics from the functional programming language
clash-prelude.cabal view
@@ -1,5 +1,5 @@ Name:                 clash-prelude-Version:              0.99+Version:              0.99.1 Synopsis:             CAES Language for Synchronous Hardware - Prelude library Description:   CλaSH (pronounced ‘clash’) is a functional hardware description language that@@ -196,9 +196,9 @@                       integer-gmp               >= 0.5.1.0 && < 1.1,                       deepseq                   >= 1.4.1.0 && < 1.5,                       ghc-prim                  >= 0.3.1.0 && < 0.6,-                      ghc-typelits-extra        >= 0.2.1   && < 0.3,-                      ghc-typelits-knownnat     >= 0.2.2   && < 0.5,-                      ghc-typelits-natnormalise >= 0.4.2   && < 0.6,+                      ghc-typelits-extra        >= 0.2.5   && < 0.3,+                      ghc-typelits-knownnat     >= 0.5     && < 0.6,+                      ghc-typelits-natnormalise >= 0.6     && < 0.7,                       half                      >= 0.2.2.3 && < 1.0,                       lens                      >= 4.9     && < 4.17,                       QuickCheck                >= 2.7     && < 2.12,@@ -220,7 +220,8 @@   else     build-depends:       base    >= 4     && < 5,-      doctest >= 0.9.1 && < 0.16+      doctest >= 0.9.1 && < 0.16,+      clash-prelude  benchmark benchmark-clash-prelude   type:             exitcode-stdio-1.0
src/Clash/Annotations/Primitive.hs view
@@ -24,11 +24,12 @@   | VHDL   deriving (Eq, Show, Read, Data) --- | Instruct the clash compiler to look for primitive HDL templates in the--- indicated directory. For distribution of new packages with primitive HDL--- templates.+-- | The 'Primitive' constructor instructs the clash compiler to look for primitive+-- HDL templates in the indicated directory. 'InlinePrimitive' is equivalent but+-- provides the HDL template inline. They are intended for the distribution of+-- new packages with primitive HDL templates. ----- === Example+-- === Example of 'Primitive' -- -- You have some existing IP written in one of HDLs supported by Clash, and -- you want to distribute some bindings so that the IP can be easily instantiated@@ -70,6 +71,44 @@ -- -- Add more files to the @data-files@ stanza in your @.cabal@ files and more -- @ANN@ pragma's if you want to add more primitive templates for other HDLs+--+-- === Example of 'InlinePrimitive'+--+-- The following example shows off an inline HDL primitive template. It uses the+-- [interpolate](https://hackage.haskell.org/package/interpolate) package for+-- nicer multiline strings.+--+-- @+-- {\-\# LANGUAGE DataKinds   \#-\}+-- {\-\# LANGUAGE QuasiQuotes \#-\}+--+-- module InlinePrimitive where+--+-- import           Clash.Annotations.Primitive+-- import           Clash.Prelude+-- import           Data.String.Interpolate      (i)+-- import           Data.String.Interpolate.Util (unindent)+--+-- {\-\# ANN example (InlinePrimitive VHDL $ unindent [i|+--   [ { \"BlackBox\" :+--       { "name" : "InlinePrimitive.example"+--       , "templateD" :+--   "-- begin InlinePrimitive example:+--   ~GENSYM[example][0] : block+--   ~RESULT <= 1 + ~ARG[0];+--   end block;+--   -- end InlinePrimitive example"+--       }+--     }+--   ]+--   |]) \#-\}+-- {\-\# NOINLINE example \#-\}+-- example :: Signal System (BitVector 2) -> Signal System (BitVector 2)+-- example = fmap succ+-- @ data Primitive   = Primitive HDL FilePath+  -- ^ Description of a primitive for a given 'HDL' in a file at 'FilePath'+  | InlinePrimitive HDL String+  -- ^ Description of a primitive for a given 'HDL' as an inline 'String'   deriving (Show, Read, Data)
src/Clash/Annotations/TopEntity.hs view
@@ -20,7 +20,7 @@       means deleting the cache; changing this file will result in /undefined/       behaviour. -Functions with a 'Synthesize' annotation do must adhere to the following+Functions with a 'Synthesize' annotation must adhere to the following restrictions:      * Although functions with a 'Synthesize' annotation can of course depend@@ -200,6 +200,8 @@ {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric      #-} +{-# LANGUAGE TemplateHaskellQuotes #-}+ {-# LANGUAGE Safe #-}  {-# OPTIONS_HADDOCK show-extensions #-}@@ -214,7 +216,8 @@ where  import           GHC.Generics-import qualified Language.Haskell.TH as TH+import qualified Language.Haskell.TH        as TH+import           Language.Haskell.TH.Syntax (Lift(lift)) import           Data.Data  -- | TopEntity annotation@@ -251,6 +254,16 @@   | TestBench TH.Name   deriving (Data,Show,Generic) +instance Lift TopEntity where+  lift (Synthesize name inputs output) =+    TH.appsE+      [ TH.conE 'Synthesize+      , TH.stringE name+      , TH.listE (map lift inputs)+      , lift output+      ]+  lift (TestBench _) = error "Cannot lift a TestBench"+ -- | Give port names for arguments/results. -- -- Give a data type and function:@@ -342,6 +355,16 @@   --   -- You can use an empty String ,\"\" , in case you want an auto-generated name.   deriving (Data,Show,Generic)++instance Lift PortName where+  lift (PortName name) =+    TH.appE (TH.conE 'PortName) (TH.stringE name)+  lift (PortProduct name ports) =+    TH.appsE+      [ TH.conE 'PortProduct+      , TH.stringE name+      , TH.listE $ map lift ports+      ]  -- | Default 'Synthesize' annotation which has no specified names for the input -- and output ports.
src/Clash/Explicit/Prelude.hs view
@@ -87,6 +87,7 @@   , module Clash.Promoted.Nat   , module Clash.Promoted.Nat.Literals   , module Clash.Promoted.Nat.TH+    -- ** Type-level strings   , module Clash.Promoted.Symbol     -- ** Template Haskell   , Lift (..)
src/Clash/Explicit/Prelude/Safe.hs view
@@ -77,6 +77,7 @@   , module Clash.Promoted.Nat   , module Clash.Promoted.Nat.Literals   , module Clash.Promoted.Nat.TH+    -- ** Type-level strings   , module Clash.Promoted.Symbol     -- ** Type classes     -- *** Clash
src/Clash/Prelude.hs view
@@ -74,6 +74,8 @@   , windowD   , isRising   , isFalling+  , riseEvery+  , oscillate     -- * Exported modules     -- ** Synchronous signals   , module Clash.Signal@@ -103,6 +105,8 @@   , module Clash.Promoted.Nat   , module Clash.Promoted.Nat.Literals   , module Clash.Promoted.Nat.TH+    -- ** Type-level strings+  , module Clash.Promoted.Symbol     -- ** Template Haskell   , Lift (..)     -- ** Type classes@@ -154,6 +158,7 @@ import           Clash.Promoted.Nat import           Clash.Promoted.Nat.TH import           Clash.Promoted.Nat.Literals+import           Clash.Promoted.Symbol import           Clash.Sized.BitVector import           Clash.Sized.Fixed import           Clash.Sized.Index
src/Clash/Prelude/Safe.hs view
@@ -91,6 +91,8 @@   , module Clash.Promoted.Nat   , module Clash.Promoted.Nat.Literals   , module Clash.Promoted.Nat.TH+    -- ** Type-level strings+  , module Clash.Promoted.Symbol     -- ** Type classes     -- *** Clash   , module Clash.Class.BitPack@@ -139,6 +141,7 @@ import           Clash.Promoted.Nat import           Clash.Promoted.Nat.TH import           Clash.Promoted.Nat.Literals+import           Clash.Promoted.Symbol import           Clash.Sized.BitVector import           Clash.Sized.Fixed import           Clash.Sized.Index
src/Clash/Promoted/Nat.hs view
@@ -18,7 +18,9 @@  {-# LANGUAGE Trustworthy #-} -{-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise -fplugin GHC.TypeLits.KnownNat.Solver #-}+{-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}+{-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise       #-}+ {-# OPTIONS_HADDOCK show-extensions #-}  module Clash.Promoted.Nat@@ -374,18 +376,11 @@ -- | Predecessor of a base-2 encoded natural number -- -- __NB__: Not synthesisable-predBNat :: BNat (n+1) -> (BNat n)+predBNat :: (1 <= n) => BNat n -> BNat (n-1) predBNat (B1 a) = case stripZeros a of   BT -> BT   a' -> B0 a'-predBNat (B0 x)  = B1 (go x)-  where-    go :: BNat m -> BNat (m-1)-    go (B1 a) = case stripZeros a of-      BT -> BT-      a' -> B0 a'-    go (B0 a)  = B1 (go a)-    go BT      = error "impossible: 0 ~ 0 - 1"+predBNat (B0 x) = B1 (predBNat x)  -- | Divide a base-2 encoded natural number by 2 --
src/Clash/Signal/Internal.hs view
@@ -109,7 +109,6 @@ >>> :set -XMagicHash >>> :set -XTypeApplications >>> import Clash.Promoted.Nat->>> import Clash.Promoted.Symbol >>> import Clash.XException >>> type System = Dom "System" 10000 >>> let systemClockGen = clockGen @System
src/Clash/Sized/Internal/Index.hs view
@@ -20,6 +20,8 @@ {-# LANGUAGE Unsafe #-}  {-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}+{-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise       #-}+ {-# OPTIONS_HADDOCK show-extensions not-home #-}  module Clash.Sized.Internal.Index
src/Clash/Sized/Vector.hs view
@@ -23,7 +23,9 @@  {-# LANGUAGE Trustworthy #-} -{-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise -fplugin GHC.TypeLits.KnownNat.Solver #-}+{-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}+{-# OPTIONS_GHC -fplugin GHC.TypeLits.Normalise       #-}+ {-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-redundant-constraints #-}  {-# OPTIONS_HADDOCK show-extensions #-}@@ -1845,7 +1847,7 @@   where     go :: forall n . SNat n -> Vec (2^n) a -> (p @@ n)     go _  (x `Cons` Nil) = f x-    go sn xs =+    go sn xs@(Cons _ (Cons _ _)) =       let sn' :: SNat (n - 1)           sn'       = sn `subSNat` d1           (xsL,xsR) = splitAt (pow2SNat sn') xs
src/Clash/Tutorial.hs view
@@ -276,7 +276,7 @@    (4) Verify that everything is working by: -      * Downloading the <https://raw.githubusercontent.com/clash-lang/clash-compiler/36a60d7979012b39bcaac66ec7048a7ec7167fbe/examples/FIR.hs Fir.hs> example+      * Downloading the <https://raw.githubusercontent.com/clash-lang/clash-compiler/4bfeb5a63e8c0dddc34d2d973c2200d01f71acee/examples/FIR.hs Fir.hs> example       * Run: @clashi FIR.hs@       * Execute, in the interpreter, the @:vhdl@ command       * Execute, in the interpreter, the @:verilog@ command@@ -1270,7 +1270,7 @@   expression in @\<HOLE\>@, which has a bit vector (@std_logic_vector@) type, is   converted to type indicated by @\<TYPE\>@. The @\<TYPE\>@ hole indicates the   must be either @~TYP[N]@, @~TYPO@, or @~TYPELEM[\<HOLE\>]@.-* @~QSysIncludeName@: the generated name of the included QSys component.+* @~INCLUDENAME@: the generated name of the included component. * @~FILEPATH[\<HOLE\>]@: The argument mentioned in @\<HOLE\>@ is a file which   must be copied to the location of the generated HDL. * @~GENERATE@: Verilog: create a /generate/ statement, except when already in@@ -2230,8 +2230,8 @@  * With the overhaul of 'Clash.Annotations.TopEntity' annotations and the   introduction of explicit clock and reset arguments, PLLs and other clock-  sources are now regular Clash function such as those found in-  "Clash.Intel.ClockGen" and "Clash.Xilinx.ClockGen"+  sources are now regular Clash functions such as those found in+  "Clash.Intel.ClockGen" and "Clash.Xilinx.ClockGen".   === Examples@@ -2356,7 +2356,6 @@ module Blinker where  import Clash.Prelude-import Clash.Promoted.Symbol import Clash.Intel.ClockGen  type Dom50 = Dom \"System\" 20000