Hoogle Search
Within LTS Haskell 24.34 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
stepQueryUIwithLeader :: (MonadClient m, MonadClientUI m) => m (Maybe RequestUI)LambdaHack Game.LambdaHack.Client.UI No documentation available.
-
LambdaHack Game.LambdaHack.Client.UI.SlideshowM This is one step of UI menu management user session. There is limited looping involved to return a changed position in the menu each time so that the surrounding code has anything interesting to do. The exception is when finally confirming a selection, in which case it's usually not changed compared to last step, but it's presented differently to indicate it was confirmed. Any extra keys in the OKX argument on top of the those in Slideshow argument need to be contained in the [K.KM] argument. Otherwise they are not accepted.
stepNames :: MigrationSteps be () a -> [Text]beam-migrate Database.Beam.Migrate.Types Collect the names of all steps in hte given MigrationSteps
stepLock :: forall (dom :: Domain) . LockStep a b => DataFlow dom Bool a b bclash-prelude Clash.Prelude.DataFlow Extend the synchronization granularity from a single Boolean value. Given:
f :: DataFlow Bool Bool a b g :: DataFlow Bool Bool c d h :: DataFlow Bool Bool (p,q) (a,c)
We cannot simply write:h `seqDF` (f `parDF` g)
because, f `parDF` g, has type, DataFlow (Bool,Bool) (Bool,Bool) (a,c) (b,d), which does not match the expected synchronization granularity of h. We need a circuit in between that has the type:DataFlow Bool (Bool,Bool) (a,c) (a,c)
Simply &&-ing the ready signals in the backward direction, and duplicating the valid signal in the forward direction is however not enough. We need to make sure that f does not consume values when g is not ready and visa versa, because h cannot update the values of its output tuple independently. f's valid port is hence only asserted when h is valid and g is ready to receive new values. g's valid port is only asserted when h is valid and f is ready to receive new values. f and g will hence be proceeding in lock-step. The stepLock function ensures that all synchronization signals are properly connected:h `seqDF` stepLock `seqDF` (f `parDF` g)
Note 1: ensure that the components that you are synchronizing have buffered/delayed ready and valid signals, or stepLock has the potential to introduce combinational loops. You can do this by placing fifoDFs on the parallel channels. Extending the above example, you would write:h `seqDF` stepLock `seqDF` ((fifoDF d4 Nil `seqDF` f) `parDF` (fifoDF d4 Nil `seqDF` g))
Note 2: stepLock works for arbitrarily nested tuples. That is:p :: DataFlow Bool Bool z ((a,c),c) q :: DataFlow ((Bool,Bool),Bool) ((Bool,Bool),Bool) ((a,c),c) ((b,d),d) q = f `parDF` g `parDF` g r = p `seqDF` stepLock `seqDF` q
Does the right thing.stepSpecificSuffix :: Descriptor -> Int -> Maybe Stringcron System.Cron.Internal.Describe.Types No documentation available.
stepNoCB :: Statement -> IO StepResultdirect-sqlite Database.SQLite3 https://www.sqlite.org/c3ref/step.html Faster step for statements that don't callback to Haskell functions (e.g. by using custom SQL functions).
stepNoCB :: Statement -> IO (Either Error StepResult)direct-sqlite Database.SQLite3.Direct https://www.sqlite.org/c3ref/step.html Faster step for statements that don't callback to Haskell functions (e.g. by using custom SQL functions).
stepPos :: Step (f :: k -> Type) (a :: k) -> Naturalfunctor-combinators Control.Applicative.Step No documentation available.
stepVal :: Step (f :: k -> Type) (a :: k) -> f afunctor-combinators Control.Applicative.Step No documentation available.
-
functor-combinators Control.Applicative.Step "Uncons and cons" an f branch before a Steps. This is basically a witness that stepsDown and stepsUp form an isomorphism.