Hoogle Search

Within LTS Haskell 24.48 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. forceVX :: forall (n :: Nat) a . KnownNat n => Vec n a -> Vec n a

    clash-prelude Clash.Explicit.Prelude.Safe

    Evaluate all elements of a vector to WHNF. Does not propagate XExceptions.

  2. forward :: forall (d :: Nat) (dom :: Domain) (n :: Nat) a . SNat d -> DSignal dom n a -> DSignal dom (n + d) a

    clash-prelude Clash.Explicit.Signal.Delayed

    EXPERIMENTAL Access a delayed signal from the past in the present. In contrast with delayed and friends forward does not insert any logic. This means using this function violates the delay invariant of DSignal. This is sometimes useful when combining unrelated delayed signals where inserting logic is not wanted or when abstracting over internal delayed signals where the internal delay information should not be leaked. For example, the circuit below returns a sequence of numbers as a pair but the internal delay information between the elements of the pair should not leak into the type.

    numbers
    :: forall dom
    . KnownDomain dom
    => Clock dom
    -> Reset dom
    -> Enable dom
    -> DSignal dom 5 (Int, Int)
    numbers clk rst en = DB.bundle (forward d1 s1, s2)
    where
    s1 :: DSignal dom 4 Int
    s1 = delayed clk rst en (100 :> 10 :> 5 :> 1 :> Nil) (pure 200)
    s2 :: DSignal dom 5 Int
    s2 = fmap (2*) $ delayN d1 0 en clk s1
    
    >>> sampleN 8 (toSignal (numbers systemClockGen systemResetGen enableGen))
    [(1,0),(1,2),(5,2),(10,10),(100,20),(200,200),(200,400),(200,400)]
    

  3. forceV :: forall (n :: Nat) a . KnownNat n => Vec n a -> Vec n a

    clash-prelude Clash.Prelude

    Evaluate all elements of a vector to WHNF

  4. forceVX :: forall (n :: Nat) a . KnownNat n => Vec n a -> Vec n a

    clash-prelude Clash.Prelude

    Evaluate all elements of a vector to WHNF. Does not propagate XExceptions.

  5. forceV :: forall (n :: Nat) a . KnownNat n => Vec n a -> Vec n a

    clash-prelude Clash.Prelude.Safe

    Evaluate all elements of a vector to WHNF

  6. forceVX :: forall (n :: Nat) a . KnownNat n => Vec n a -> Vec n a

    clash-prelude Clash.Prelude.Safe

    Evaluate all elements of a vector to WHNF. Does not propagate XExceptions.

  7. forward :: forall (d :: Nat) (dom :: Domain) (n :: Nat) a . SNat d -> DSignal dom n a -> DSignal dom (n + d) a

    clash-prelude Clash.Signal.Delayed

    EXPERIMENTAL Access a delayed signal from the past in the present. In contrast with delayed and friends forward does not insert any logic. This means using this function violates the delay invariant of DSignal. This is sometimes useful when combining unrelated delayed signals where inserting logic is not wanted or when abstracting over internal delayed signals where the internal delay information should not be leaked. For example, the circuit below returns a sequence of numbers as a pair but the internal delay information between the elements of the pair should not leak into the type.

    numbers
    :: forall dom
    . KnownDomain dom
    => Clock dom
    -> Reset dom
    -> Enable dom
    -> DSignal dom 5 (Int, Int)
    numbers clk rst en = DB.bundle (forward d1 s1, s2)
    where
    s1 :: DSignal dom 4 Int
    s1 = delayed clk rst en (100 :> 10 :> 5 :> 1 :> Nil) (pure 200)
    s2 :: DSignal dom 5 Int
    s2 = fmap (2*) $ delayN d1 0 en clk s1
    
    >>> sampleN 8 (toSignal (numbers systemClockGen systemResetGen enableGen))
    [(1,0),(1,2),(5,2),(10,10),(100,20),(200,200),(200,400),(200,400)]
    

  8. forward :: forall (d :: Nat) (dom :: Domain) (n :: Nat) a . SNat d -> DSignal dom n a -> DSignal dom (n + d) a

    clash-prelude Clash.Signal.Delayed.Internal

    EXPERIMENTAL Access a delayed signal from the past in the present. In contrast with delayed and friends forward does not insert any logic. This means using this function violates the delay invariant of DSignal. This is sometimes useful when combining unrelated delayed signals where inserting logic is not wanted or when abstracting over internal delayed signals where the internal delay information should not be leaked. For example, the circuit below returns a sequence of numbers as a pair but the internal delay information between the elements of the pair should not leak into the type.

    numbers
    :: forall dom
    . KnownDomain dom
    => Clock dom
    -> Reset dom
    -> Enable dom
    -> DSignal dom 5 (Int, Int)
    numbers clk rst en = DB.bundle (forward d1 s1, s2)
    where
    s1 :: DSignal dom 4 Int
    s1 = delayed clk rst en (100 :> 10 :> 5 :> 1 :> Nil) (pure 200)
    s2 :: DSignal dom 5 Int
    s2 = fmap (2*) $ delayN d1 0 en clk s1
    
    >>> sampleN 8 (toSignal (numbers systemClockGen systemResetGen enableGen))
    [(1,0),(1,2),(5,2),(10,10),(100,20),(200,200),(200,400),(200,400)]
    

  9. forceV :: forall (n :: Nat) a . KnownNat n => Vec n a -> Vec n a

    clash-prelude Clash.Sized.Vector

    Evaluate all elements of a vector to WHNF

  10. forceVX :: forall (n :: Nat) a . KnownNat n => Vec n a -> Vec n a

    clash-prelude Clash.Sized.Vector

    Evaluate all elements of a vector to WHNF. Does not propagate XExceptions.

Page 134 of many | Previous | Next