clash-prelude 0.99.2 → 0.99.3

raw patch · 14 files changed

+258/−169 lines, 14 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• README.md +1/−1
• clash-prelude.cabal +4/−1
• src/Clash/Class/BitPack.hs +5/−36
• src/Clash/Class/BitPack/Internal.hs +91/−0
• src/Clash/Explicit/BlockRam.hs +12/−6
• src/Clash/Explicit/BlockRam/File.hs +12/−6
• src/Clash/Explicit/RAM.hs +11/−5
• src/Clash/Signal/Bundle.hs +16/−94
• src/Clash/Signal/Bundle/Internal.hs +81/−0
• src/Clash/Signal/Internal.hs +9/−9
• src/Clash/Sized/RTree.hs +1/−1
• src/Clash/Sized/Vector.hs +1/−1
• src/Clash/Tutorial.hs +9/−9

@@ -1,5 +1,10 @@ # Changelog for [`clash-prelude` package](http://hackage.haskell.org/package/clash-prelude) +## 0.99.3 *July 26th 2018*+* Bundle and BitPack instances up to and including 62-tuples+* Handle undefined writes to RAM properly+* Handle undefined clock enables properly+ ## 0.99.1 *May 12th 2018* * Support for `ghc-typelits-natnormalise-0.6.1` * `Lift` instances for `TopEntity` and `PortName`

@@ -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.2 or higher (http://www.haskell.org/ghc/download_ghc_8_4_2)!+Only works with GHC-8.2 or higher (http://www.haskell.org/ghc/download_ghc_8_4_3)!  CλaSH (pronounced ‘clash’) is a functional hardware description language that borrows both its syntax and semantics from the functional programming language

@@ -1,5 +1,5 @@ Name:                 clash-prelude-Version:              0.99.2+Version:              0.99.3 Synopsis:             CAES Language for Synchronous Hardware - Prelude library Description:   CλaSH (pronounced ‘clash’) is a functional hardware description language that@@ -158,6 +158,9 @@                        Clash.Tutorial                       Clash.Examples++  other-modules:      Clash.Class.BitPack.Internal+                      Clash.Signal.Bundle.Internal    other-extensions:   CPP                       BangPatterns

@@ -11,6 +11,7 @@ {-# LANGUAGE FlexibleContexts     #-} {-# LANGUAGE MagicHash            #-} {-# LANGUAGE ScopedTypeVariables  #-}+{-# LANGUAGE TemplateHaskell      #-} {-# LANGUAGE TypeFamilies         #-} {-# LANGUAGE TypeOperators        #-} {-# LANGUAGE UndecidableInstances #-}@@ -42,6 +43,7 @@ import GHC.Generics import Prelude                        hiding (map) +import Clash.Class.BitPack.Internal   (deriveBitPackTuples) import Clash.Class.Resize             (zeroExtend) import Clash.Sized.BitVector   (Bit, BitVector, (++#), high, low)@@ -224,42 +226,6 @@   pack (a,b) = pack a ++# pack b   unpack ab  = let (a,b) = split# ab in (unpack a, unpack b) -instance (KnownNat (BitSize c), BitPack (a,b), BitPack c) =>-    BitPack (a,b,c) where-  type BitSize (a,b,c) = BitSize (a,b) + BitSize c-  pack (a,b,c) = pack (a,b) ++# pack c-  unpack (unpack -> ((a,b), c)) = (a,b,c)--instance (KnownNat (BitSize d), BitPack (a,b,c), BitPack d) =>-    BitPack (a,b,c,d) where-  type BitSize (a,b,c,d) = BitSize (a,b,c) + BitSize d-  pack (a,b,c,d) = pack (a,b,c) ++# pack d-  unpack (unpack -> ((a,b,c), d)) = (a,b,c,d)--instance (KnownNat (BitSize e), BitPack (a,b,c,d), BitPack e) =>-    BitPack (a,b,c,d,e) where-  type BitSize (a,b,c,d,e) = BitSize (a,b,c,d) + BitSize e-  pack (a,b,c,d,e) = pack (a,b,c,d) ++# pack e-  unpack (unpack -> ((a,b,c,d), e)) = (a,b,c,d,e)--instance (KnownNat (BitSize f), BitPack (a,b,c,d,e), BitPack f) =>-    BitPack (a,b,c,d,e,f) where-  type BitSize (a,b,c,d,e,f) = BitSize (a,b,c,d,e) + BitSize f-  pack (a,b,c,d,e,f) = pack (a,b,c,d,e) ++# pack f-  unpack (unpack -> ((a,b,c,d,e), f)) = (a,b,c,d,e,f)--instance (KnownNat (BitSize g), BitPack (a,b,c,d,e,f), BitPack g) =>-    BitPack (a,b,c,d,e,f,g) where-  type BitSize (a,b,c,d,e,f,g) = BitSize (a,b,c,d,e,f) + BitSize g-  pack (a,b,c,d,e,f,g) = pack (a,b,c,d,e,f) ++# pack g-  unpack (unpack -> ((a,b,c,d,e,f), g)) = (a,b,c,d,e,f,g)--instance (KnownNat (BitSize h), BitPack (a,b,c,d,e,f,g), BitPack h) =>-    BitPack (a,b,c,d,e,f,g,h) where-  type BitSize (a,b,c,d,e,f,g,h) = BitSize (a,b,c,d,e,f,g) + BitSize h-  pack (a,b,c,d,e,f,g,h) = pack (a,b,c,d,e,f,g) ++# pack h-  unpack (unpack -> ((a,b,c,d,e,f,g), h)) = (a,b,c,d,e,f,g,h)- instance (BitPack a, KnownNat (BitSize a)) => BitPack (Maybe a) where   type BitSize (Maybe a) = 1 + BitSize a   pack Nothing  = pack# low ++# 0@@ -309,3 +275,6 @@ -- | Convert a Bool to a Bit bitToBool :: Bit -> Bool bitToBool = bitCoerce++-- Derive the BitPack instance for tuples of size 3 to 62+deriveBitPackTuples ''BitPack ''BitSize 'pack 'unpack '(++#)

@@ -0,0 +1,91 @@+{-# LANGUAGE TemplateHaskell #-}++module Clash.Class.BitPack.Internal where++import           Control.Monad         (replicateM)+import           Data.List             (foldl')+import           GHC.TypeLits          (KnownNat)+import           Language.Haskell.TH++-- | Contruct all the tuple (starting at size 3) instances for BitPack.+deriveBitPackTuples+  :: Name+  -- ^ BitPack+  -> Name+  -- ^ BitSize+  -> Name+  -- ^ pack+  -> Name+  -- ^ unpack+  -> Name+  -- ^ append (++#)+  -> DecsQ+deriveBitPackTuples bitPackName bitSizeName packName unpackName appendName = do+  let bitPack  = ConT bitPackName+      bitSize  = ConT bitSizeName+      knownNat = ConT ''KnownNat+      plus     = ConT $ mkName "+"++  allNames <- replicateM 62 (newName "a")+  x <- newName "x"+  y <- newName "y"++  pure $ flip map [3..62] $ \tupleNum ->+    let names  = take tupleNum allNames+        (v:vs) = fmap VarT names+        tuple xs = foldl' AppT (TupleT $ length xs) xs++        -- Instance declaration+        context =+          [ bitPack `AppT` v+          , knownNat `AppT` (bitSize `AppT` v)+          , bitPack `AppT` tuple vs+          , knownNat `AppT` (bitSize `AppT` tuple vs)+          ]+        instTy = AppT bitPack $ tuple (v:vs)++        -- Associated type BitSize+        bitSizeTypeEq =+          TySynEqn+            [ tuple (v:vs) ]+            $ plus `AppT` (bitSize `AppT` v) `AppT`+              (bitSize `AppT` foldl AppT (TupleT $ tupleNum - 1) vs)+        bitSizeType = TySynInstD bitSizeName bitSizeTypeEq++        pack =+          FunD+            packName+            [ Clause+                [ TupP $ map VarP names ]+                ( let (e:es) = map VarE names+                  in NormalB $ AppE+                    (VarE appendName `AppE` (VarE packName `AppE` e))+                    (VarE packName `AppE` TupE es)+                )+                []+            ]++        unpack =+          FunD+            unpackName+            [ Clause+                [ VarP x ]+                ( NormalB $+                    let (p:ps) = map VarP names+                    in+                    LetE+                      [ ValD+                          ( TupP [ p, VarP y ] )+                          ( NormalB $ VarE unpackName `AppE` VarE x )+                          []+                      , ValD+                          ( TupP ps )+                          ( NormalB $ VarE unpackName `AppE` VarE y )+                          []+                      ]+                      ( TupE $ map VarE names )+                )+                []+            ]++    in InstanceD Nothing context instTy [bitSizeType, pack, unpack]

@@ -403,7 +403,7 @@ import Clash.Signal.Bundle    (unbundle) import Clash.Sized.Unsigned   (Unsigned) import Clash.Sized.Vector     (Vec, toList)-import Clash.XException       (errorX, seqX)+import Clash.XException       (errorX, maybeX, seqX)  {- $setup >>> import Clash.Explicit.Prelude as C@@ -761,21 +761,27 @@   Just ena ->     go' (V.fromList (toList content))        (withFrozenCallStack (errorX "blockRam: intial value undefined"))-       ena rd (wen .&&. ena)+       ena rd (ena .&&. wen)   where     -- no clock enable     go !ram o (r :- rs) (e :- en) (w :- wr) (d :- din) =-      let ram' = upd ram e w d+      let ram' = upd ram e (fromEnum w) d           o'   = ram V.! r       in  o `seqX` o :- go ram' o' rs en wr din     -- clock enable     go' !ram o (re :- res) (r :- rs) (e :- en) (w :- wr) (d :- din) =-      let ram' = upd ram e w d+      let ram' = upd ram e (fromEnum w) d           o'   = if re then ram V.! r else o       in  o `seqX` o :- go' ram' o' res rs en wr din -    upd ram True  addr d = ram V.// [(addr,d)]-    upd ram False _    _ = ram+    upd ram we waddr d = case maybeX we of+      Nothing -> case maybeX waddr of+        Nothing -> V.map (const (seq waddr d)) ram+        Just wa -> ram V.// [(wa,d)]+      Just True -> case maybeX waddr of+        Nothing -> V.map (const (seq waddr d)) ram+        Just wa -> ram V.// [(wa,d)]+      _ -> ram {-# NOINLINE blockRam# #-}  -- | Create read-after-write blockRAM from a read-before-write one

@@ -110,7 +110,7 @@ import Clash.Signal.Internal (Clock, Signal (..), (.&&.), clockEnable) import Clash.Signal.Bundle   (unbundle) import Clash.Sized.Unsigned  (Unsigned)-import Clash.XException      (errorX, seqX)+import Clash.XException      (errorX, maybeX, seqX)   -- | Create a blockRAM with space for 2^@n@ elements@@ -230,21 +230,27 @@   Just ena ->     go' ramI        (withFrozenCallStack (errorX "blockRamFile#: intial value undefined"))-       ena rd (wen .&&. ena)+       ena rd (ena .&&. wen)   where     -- no clock enable     go !ram o (r :- rs) (e :- en) (w :- wr) (d :- din) =-      let ram' = upd ram e w d+      let ram' = upd ram e (fromEnum w) d           o'   = ram V.! r       in  o `seqX` o :- go ram' o' rs en wr din     -- clock enable     go' !ram o (re :- res) (r :- rs) (e :- en) (w :- wr) (d :- din) =-      let ram' = upd ram e w d+      let ram' = upd ram e (fromEnum w) d           o'   = if re then ram V.! r else o       in  o `seqX` o :- go' ram' o' res rs en wr din -    upd ram True  addr d = ram V.// [(addr,d)]-    upd ram False _    _ = ram+    upd ram we waddr d = case maybeX we of+      Nothing -> case maybeX waddr of+        Nothing -> V.map (const (seq waddr d)) ram+        Just wa -> ram V.// [(wa,d)]+      Just True -> case maybeX waddr of+        Nothing -> V.map (const (seq waddr d)) ram+        Just wa -> ram V.// [(wa,d)]+      _ -> ram      content = unsafePerformIO (initMem file)     ramI    = V.fromList content

@@ -43,7 +43,7 @@ import Clash.Promoted.Nat    (SNat (..), snatToNum, pow2SNat) import Clash.Signal.Internal (Clock (..), Signal (..), clockEnable) import Clash.Sized.Unsigned  (Unsigned)-import Clash.XException      (errorX)+import Clash.XException      (errorX, maybeX)  -- | Create a RAM with space for 2^@n@ elements --@@ -122,16 +122,22 @@               (withFrozenCallStack (errorX "asyncRam#: initial value undefined"))     en'  = case clockEnable wclk of              Nothing  -> en-             Just wgt -> en .&&. wgt+             Just wgt -> wgt .&&. en     dout = go ramI rd' en' wr din      go :: V.Vector a -> Signal wdom Int -> Signal wdom Bool        -> Signal wdom Int -> Signal wdom a -> Signal wdom a     go !ram (r :- rs) (e :- es) (w :- ws) (d :- ds) =-      let ram' = upd ram e w d+      let ram' = upd ram e (fromEnum w) d           o    = ram V.! r       in  o :- go ram' rs es ws ds -    upd ram True  addr d = ram V.// [(addr,d)]-    upd ram False _    _ = ram+    upd ram we waddr d = case maybeX we of+      Nothing -> case maybeX waddr of+        Nothing -> V.map (const (seq waddr d)) ram+        Just wa -> ram V.// [(wa,d)]+      Just True -> case maybeX waddr of+        Nothing -> V.map (const (seq waddr d)) ram+        Just wa -> ram V.// [(wa,d)]+      _ -> ram {-# NOINLINE asyncRam# #-}

@@ -11,6 +11,7 @@ {-# LANGUAGE DefaultSignatures      #-} {-# LANGUAGE KindSignatures         #-} {-# LANGUAGE MagicHash              #-}+{-# LANGUAGE TemplateHaskell        #-} {-# LANGUAGE TypeFamilies           #-} {-# LANGUAGE TypeFamilyDependencies #-} {-# LANGUAGE TypeOperators          #-}@@ -24,19 +25,20 @@   ) where -import Control.Applicative   (liftA2)-import GHC.TypeLits          (KnownNat)-import Prelude               hiding (head, map, tail)+import Control.Applicative          (liftA2)+import GHC.TypeLits                 (KnownNat)+import Prelude                      hiding (head, map, tail) -import Clash.NamedTypes      ((:::))-import Clash.Signal.Internal (Domain, Signal (..))-import Clash.Sized.BitVector (Bit, BitVector)-import Clash.Sized.Fixed     (Fixed)-import Clash.Sized.Index     (Index)-import Clash.Sized.Signed    (Signed)-import Clash.Sized.Unsigned  (Unsigned)-import Clash.Sized.Vector    (Vec, traverse#, lazyV)-import Clash.Sized.RTree     (RTree, lazyT)+import Clash.NamedTypes             ((:::))+import Clash.Signal.Bundle.Internal (deriveBundleTuples)+import Clash.Signal.Internal        (Domain, Signal (..))+import Clash.Sized.BitVector        (Bit, BitVector)+import Clash.Sized.Fixed            (Fixed)+import Clash.Sized.Index            (Index)+import Clash.Sized.Signed           (Signed)+import Clash.Sized.Unsigned         (Unsigned)+import Clash.Sized.Vector           (Vec, traverse#, lazyV)+import Clash.Sized.RTree            (RTree, lazyT)  -- | Isomorphism between a 'Clash.Signal.Signal' of a product type (e.g. a tuple) and a -- product type of 'Clash.Signal.Signal''s.@@ -74,7 +76,7 @@   -- | Example:   --   -- @-  -- __bundle__ :: ('Signal' domain a, 'Signal' domain b) -> 'Signal' clk (a,b)+  -- __bundle__ :: ('Signal' domain a, 'Signal' domain b) -> 'Signal' domain (a,b)   -- @   --   -- However:@@ -131,87 +133,7 @@   bundle   u = pure u   unbundle _ = () -instance Bundle (a,b) where-  type Unbundled t (a,b) = (Signal t a, Signal t b)-  bundle       = uncurry (liftA2 (,))-  unbundle tup = (fmap fst tup, fmap snd tup)--instance Bundle (a,b,c) where-  type Unbundled t (a,b,c) = (Signal t a, Signal t b, Signal t c)-  bundle   (a,b,c) = (,,) <$> a <*> b <*> c-  unbundle tup     = (fmap (\(x,_,_) -> x) tup-                     ,fmap (\(_,x,_) -> x) tup-                     ,fmap (\(_,_,x) -> x) tup-                     )--instance Bundle (a,b,c,d) where-  type Unbundled t (a,b,c,d) = ( Signal t a, Signal t b, Signal t c-                               , Signal t d-                               )-  bundle   (a,b,c,d) = (,,,) <$> a <*> b <*> c <*> d-  unbundle tup       = (fmap (\(x,_,_,_) -> x) tup-                       ,fmap (\(_,x,_,_) -> x) tup-                       ,fmap (\(_,_,x,_) -> x) tup-                       ,fmap (\(_,_,_,x) -> x) tup-                       )--instance Bundle (a,b,c,d,e) where-  type Unbundled t (a,b,c,d,e) = ( Signal t a, Signal t b, Signal t c-                                 , Signal t d, Signal t e-                                 )-  bundle   (a,b,c,d,e) = (,,,,) <$> a <*> b <*> c <*> d <*> e-  unbundle tup         = (fmap (\(x,_,_,_,_) -> x) tup-                         ,fmap (\(_,x,_,_,_) -> x) tup-                         ,fmap (\(_,_,x,_,_) -> x) tup-                         ,fmap (\(_,_,_,x,_) -> x) tup-                         ,fmap (\(_,_,_,_,x) -> x) tup-                         )--instance Bundle (a,b,c,d,e,f) where-  type Unbundled t (a,b,c,d,e,f) = ( Signal t a, Signal t b, Signal t c-                                   , Signal t d, Signal t e, Signal t f-                                   )-  bundle   (a,b,c,d,e,f) = (,,,,,) <$> a <*> b <*> c <*> d <*> e <*> f-  unbundle tup           = (fmap (\(x,_,_,_,_,_) -> x) tup-                           ,fmap (\(_,x,_,_,_,_) -> x) tup-                           ,fmap (\(_,_,x,_,_,_) -> x) tup-                           ,fmap (\(_,_,_,x,_,_) -> x) tup-                           ,fmap (\(_,_,_,_,x,_) -> x) tup-                           ,fmap (\(_,_,_,_,_,x) -> x) tup-                           )--instance Bundle (a,b,c,d,e,f,g) where-  type Unbundled t (a,b,c,d,e,f,g) = ( Signal t a, Signal t b, Signal t c-                                     , Signal t d, Signal t e, Signal t f-                                     , Signal t g-                                     )-  bundle   (a,b,c,d,e,f,g) = (,,,,,,) <$> a <*> b <*> c <*> d <*> e <*> f-                                      <*> g-  unbundle tup             = (fmap (\(x,_,_,_,_,_,_) -> x) tup-                             ,fmap (\(_,x,_,_,_,_,_) -> x) tup-                             ,fmap (\(_,_,x,_,_,_,_) -> x) tup-                             ,fmap (\(_,_,_,x,_,_,_) -> x) tup-                             ,fmap (\(_,_,_,_,x,_,_) -> x) tup-                             ,fmap (\(_,_,_,_,_,x,_) -> x) tup-                             ,fmap (\(_,_,_,_,_,_,x) -> x) tup-                             )--instance Bundle (a,b,c,d,e,f,g,h) where-  type Unbundled t (a,b,c,d,e,f,g,h) = ( Signal t a, Signal t b, Signal t c-                                       , Signal t d, Signal t e, Signal t f-                                       , Signal t g, Signal t h-                                       )-  bundle   (a,b,c,d,e,f,g,h) = (,,,,,,,) <$> a <*> b <*> c <*> d <*> e <*> f-                                         <*> g <*> h-  unbundle tup               = (fmap (\(x,_,_,_,_,_,_,_) -> x) tup-                               ,fmap (\(_,x,_,_,_,_,_,_) -> x) tup-                               ,fmap (\(_,_,x,_,_,_,_,_) -> x) tup-                               ,fmap (\(_,_,_,x,_,_,_,_) -> x) tup-                               ,fmap (\(_,_,_,_,x,_,_,_) -> x) tup-                               ,fmap (\(_,_,_,_,_,x,_,_) -> x) tup-                               ,fmap (\(_,_,_,_,_,_,x,_) -> x) tup-                               ,fmap (\(_,_,_,_,_,_,_,x) -> x) tup-                               )+deriveBundleTuples ''Bundle ''Unbundled 'bundle 'unbundle  instance KnownNat n => Bundle (Vec n a) where   type Unbundled t (Vec n a) = Vec n (Signal t a)

@@ -0,0 +1,81 @@+{-# LANGUAGE TemplateHaskell #-}++module Clash.Signal.Bundle.Internal where++import           Clash.Signal.Internal (Signal)+import           Control.Monad         (replicateM)+import           Data.List             (foldl')+import           Language.Haskell.TH++-- | Contruct all the tuple instances for Bundle.+deriveBundleTuples+  :: Name+  -- ^ Bundle+  -> Name+  -- ^ Unbundled+  -> Name+  -- ^ bundle+  -> Name+  -- ^ unbundle+  -> DecsQ+deriveBundleTuples bundleTyName unbundledTyName bundleName unbundleName = do+  let bundleTy = ConT bundleTyName+      signal   = ConT ''Signal++  allNames <- replicateM 62 (newName "a")+  tempNames <- replicateM 62 (newName "b")+  t <- newName "t"+  x <- newName "x"+  tup <- newName "tup"++  pure $ flip map [2..62] $ \tupleNum ->+    let names = take tupleNum allNames+        temps = take tupleNum tempNames+        vars  = fmap VarT names+        tuple = foldl' AppT (TupleT tupleNum)++        -- Instance declaration+        instTy = AppT bundleTy $ tuple vars++        -- Associated type Unbundled+        unbundledTypeEq =+          TySynEqn+            [ VarT t, tuple vars ]+            $ tuple $ map (AppT (signal `AppT` VarT t)) vars+        unbundledType = TySynInstD unbundledTyName unbundledTypeEq++        bundleLambda = LamE (map VarP temps) (TupE $ map VarE temps)+        applicatives = VarE '(<$>) : repeat (VarE '(<*>))+        bundle =+          FunD+            bundleName+            [ Clause+                [ TupP $ map VarP names ]+                ( NormalB+                $ foldl'+                    (\f (a, b) -> a `AppE` f `AppE` b)+                    bundleLambda+                    (zip applicatives $ map VarE names)+                )+                []+            ]++        unbundleLambda n =+          LamE+            [ TupP [ if i == n then VarP x else WildP | i <- [0..tupleNum-1] ] ]+            (VarE x)++        unbundle =+          FunD+            unbundleName+            [ Clause+                [ VarP tup ]+                ( NormalB . TupE $+                    map +                      (\n -> VarE 'fmap `AppE` unbundleLambda n `AppE` VarE tup)+                      [0..tupleNum-1]+                )+                []+            ]++    in InstanceD Nothing [] instTy [unbundledType, bundle, unbundle]

@@ -586,7 +586,7 @@ register# Clock {} (Async rst) i =     go (withFrozenCallStack (errorX "register: initial value undefined")) rst   where-    go o ~(r :- rs) as@(~(x :- xs)) =+    go o (r :- rs) as@(~(x :- xs)) =       let o' = if r then i else o           -- [Note: register strictness annotations]       in  o' `seqX` o' :- (as `seq` go x rs xs)@@ -594,20 +594,20 @@ register# (GatedClock _ _ ena) (Sync rst)  i =     go (withFrozenCallStack (errorX "register: initial value undefined")) rst ena   where-    go o rt@(~(r :- rs)) ~(e :- es) as@(~(x :- xs)) =-      let o' = if r then i else x+    go o rt@(~(r :- rs)) enas@(~(e :- es)) as@(~(x :- xs)) =+      let oE = if e then x else o+          oR = if r then i else oE           -- [Note: register strictness annotations]-      in  o `seqX` o :- (rt `seq` as `seq` if e then go o' rs es xs-                                                else go o  rs es xs)+      in  o `seqX` o :- (rt `seq` enas `seq` as `seq` go oR rs es xs)  register# (GatedClock _ _ ena) (Async rst) i =     go (withFrozenCallStack (errorX "register: initial value undefined")) rst ena   where-    go o ~(r :- rs) ~(e :- es) as@(~(x :- xs)) =-      let o' = if r then i else o+    go o (r :- rs) enas@(~(e :- es)) as@(~(x :- xs)) =+      let oR = if r then i else o+          oE = if e then x else oR           -- [Note: register strictness annotations]-      in  o' `seqX` o' :- (as `seq` if e then go x  rs es xs-                                         else go o' rs es xs)+      in  oR `seqX` oR :- (as `seq` enas `seq` go oE rs es xs) {-# NOINLINE register# #-}  {-# INLINE mux #-}

@@ -276,7 +276,7 @@ -- -- In order to accommodate the type of our 'Clash.Class.Num.plus', where the -- result is larger than the arguments, we must use a dependently typed fold in--- the the form of 'dtfold':+-- the form of 'dtfold': -- -- @ -- {\-\# LANGUAGE UndecidableInstances \#-\}

@@ -1792,7 +1792,7 @@ -- -- In order to accommodate the type of our 'Clash.Class.Num.plus', where the -- result is larger than the arguments, we must use a dependently typed fold in--- the the form of 'dtfold':+-- the form of 'dtfold': -- -- @ -- {\-\# LANGUAGE UndecidableInstances \#-\}

@@ -607,7 +607,7 @@ after which warnings are being reported. The reason is that 'stimuliGenerator' will keep on producing the last sample, (4,4), while the 'outputVerifier' will keep on expecting the last sample, 14. In the VHDL testbench these errors won't-show, as the the global clock will be stopped after 4 ticks.+show, as the global clock will be stopped after 4 ticks.  You should now again run @:vhdl@ in the interpreter; this time the compiler will take a bit longer to generate all the circuits. Inside the @.\/vhdl\/MAC@@@ -801,7 +801,7 @@  Instances of this 'Bundle' type-class are defined as /isomorphisms/ for: -  * All tuples until and including 8-tuples+  * All tuples up to and including 62-tuples (GHC limit)   * The 'Vec'tor type  But they are defined as /identities/ for:@@ -1235,13 +1235,13 @@ * @~SIGDO[\<HOLE\>]@: Create a signal declaration, using @\<HOLE\>@ as the name   of the signal, and the type of the result. * @~TYPELEM[\<HOLE\>]@: The element type of the vector type represented by @\<HOLE\>@.-  The content of @\<HOLE\>@ must either be: @TYPM[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.+  The content of @\<HOLE\>@ must either be: @TYP[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@. * @~COMPNAME@: The name of the component in which the primitive is instantiated. * @~LENGTH[\<HOLE\>]@: The vector length of the type represented by @\<HOLE\>@. * @~DEPTH[\<HOLE\>]@: The tree depth of the type represented by @\<HOLE\>@.-  The content of @\<HOLE\>@ must either be: @TYPM[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.+  The content of @\<HOLE\>@ must either be: @TYP[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@. * @~SIZE[\<HOLE\>]@: The number of bits needed to encode the type represented by @\<HOLE\>@.-  The content of @\<HOLE\>@ must either be: @TYPM[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@.+  The content of @\<HOLE\>@ must either be: @TYP[N]@, @TYPO@, or @TYPELEM[\<HOLE\>]@. * @~IF \<CONDITION\> ~THEN \<THEN\> ~ELSE \<ELSE\> ~FI@: renders the \<ELSE\>   part when \<CONDITION\> evaluates to /0/, and renders the \<THEN\> in all   other cases. Valid @\<CONDITION\>@s are @~LENGTH[\<HOLE\>]@, @~SIZE[\<HOLE\>]@,@@ -1258,7 +1258,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\>]@.-* @~INCLUDENAME@: the generated name of the included component.+* @~INCLUDENAME[N]@: the generated name of the @N@'th 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@@ -1452,7 +1452,7 @@       cnt = 'Clash.Explicit.Signal.register' clk rst 0 (cnt + 1)   @ -  As it is not possible to convert the the individual bits to a 'Clock'.+  As it is not possible to convert the individual bits to a 'Clock'.    However! What is possible is to do the following: @@ -1805,7 +1805,7 @@      Product types supported by 'bundle' are: -    * All tuples until and including 8-tuples+    * All tuples up to and including 62-tuples (GHC limit)     * The 'Vec'tor type  * __Type error: Couldn't match expected type @('Signal' domain a, 'Signal' domain b)@ with__@@ -1828,7 +1828,7 @@      Product types supported by 'unbundle' are: -    * All tuples until and including 8-tuples+    * All tuples up to and including 62-tuples (GHC limit)     * The 'Vec'tor type  * __Clash.Netlist(..): Not in normal form: \<REASON\>: \<EXPR\>__: