Search results

fix :: forall l. Lazy l => (l -> l) -> l

fix defines a value as the fixed point of a function.

The Lazy instance allows us to generate the result lazily.

fix :: forall i o. (Emitter i -> { input :: Emitter i, output :: Emitter o }) -> Emitter o

Compute a fixed point.

fix :: forall i. (Event i -> Event i) -> Event i

Compute a fixed point

fix :: forall event i. IsEvent event => (event i -> event i) -> event i

fix :: forall o i. (Event i -> { input :: Event i, output :: Event o }) -> Event o

Compute a fixed point

fix :: forall event o i. IsEvent event => (event i -> { input :: event i, output :: event o }) -> event o

fix :: forall m a b. (Codec' m a b -> Codec' m a b) -> Codec' m a b

fix :: forall a. (JsonCodec a -> JsonCodec a) -> JsonCodec a

Helper function for defining recursive codecs in situations where the codec definition causes a "The value of <codec> is undefined here" error.

import Data.Codec.Argonaut as CA
import Data.Codec.Argonaut.Common as CAC
import Data.Codec.Argonaut.Record as CAR
import Data.Maybe (Maybe)
import Data.Newtype (class Newtype)
import Data.Profunctor (wrapIso)

newtype IntList = IntList { cell ∷ Int, rest ∷ Maybe IntList }

derive instance newtypeLoopyList ∷ Newtype IntList _

codecIntList ∷ CA.JsonCodec IntList
codecIntList =
  CA.fix \codec →
    wrapIso IntList $
      CAR.object "IntList" { cell: CA.int, rest: CAC.maybe codec }

fix :: forall a. (a -> a) -> a

Fixed point Y combinator

Λ a . (a → a) → a

λ f . (λ x. f (x x)) (λ x . f (x x))

fix :: forall a. (a -> a) -> a

Fix :: forall f a. (f (Fix f) a) -> Fix f a

fix :: forall outputChannels payload. (Audible outputChannels payload -> Audible outputChannels payload) -> Audible outputChannels payload

fix :: forall r a u. (Pattern u a r -> Pattern u a r) -> Pattern u a r

fiX :: ReactIcon

fix :: forall i eff. EventQueue (Eff (QueueEffects eff)) i i -> Eff (QueueEffects eff) (EventQueueInstance (Eff (QueueEffects eff)) i)

Creates an EventQueue that can feed back into itself.

fixB :: forall event a. Pollable event event => IsEvent event => a -> (APoll event a -> APoll event a) -> APoll event a

Compute a fixed point

fixB :: forall a. a -> (ABehavior Event a -> ABehavior Event a) -> ABehavior Event a

Compute a fixed point

fixed :: Int -> Format

Create a toFixed-based format from an integer. Values smaller than 0 and larger than 20 will be clamped.

fixed :: Position

fixed :: CompressionStrategy

fixed :: forall logic obj. Array (Entity logic obj) -> Entity logic obj

fixed :: StyleProperty

fixed :: forall lock payload. Array (Domable lock payload) -> Domable lock payload

Once upon a time, this function was used to create a list of Domable-s that are merged together. Now, as Domable is a Monoid, you can use fold instead.

A fixed point representation of a real number, with the specified precision.

A value is multiplied by the precision, truncated and stored as a big integer. That is, we approximate the number by numerator/10^precision, storing only the numerator, and carrying the precision around as type information.

The Semiring and associated instances allow us to perform basic arithmetic operations. Unlike Number, addition of Fixed numbers does satisfy the associativity law, but like Number, most of the other laws of the numeric hierarchy classes are not satisfied due to rounding errors.

fixed :: Proxy @Symbol "fixed"

fixed :: Option Tooltip (Options Fixed)

fixed :: Fixed

fixed :: StringConst "fixed"

Fixed :: PartType

fixDyn :: forall m a b. MonadFRP m => (WeakDynamic a -> m (Tuple (Dynamic a) b)) -> m b

fixFRP :: forall input output m b. FixFRP input output => MonadFRP m => (input -> m (Tuple output b)) -> m b

Fixity :: { associativity :: Associativity, precedence :: Precedence } -> Fixity

fixNat :: Int -> Permutation -> Maybe Int

fixPure :: forall a. ((Unit -> a) -> a) -> a

fixFRP_ :: forall input output m. FixFRP input output => MonadFRP m => (input -> m output) -> m Unit

fixture :: String -> CypressM Foreign

fixedsym :: SProxy "fixed"

fixedTop :: ClassName

fixedTop :: ClassName

fixedTop :: ClassName

fixEvent :: forall m a b. MonadFRP m => (Event a -> m (Tuple (Event a) b)) -> m b