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 m a b. (Codec' m a b -> Codec' m a b) -> Codec' m a b

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 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 :: Number -> Sizing

fixed :: Proxy @Symbol "fixed"

fixed :: Option Tooltip (Options Fixed)

Fixed :: Area -> WindowMode

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

fixEffect :: forall a. ((Unit -> a) -> Effect a) -> Effect a

fiXCircle :: ReactIcon

fixRecord :: forall ro_list ri ro m b. FixFRPRecord ro_list ri ro => MonadFRP m => Proxy ro_list -> (Record ri -> m (Tuple (Record ro) b)) -> m b

fiXSquare :: ReactIcon

fixtureFn :: EffectFn2 String Cy Foreign

FixityType :: SourceToken -> (QualifiedName Proper) -> SourceToken -> (Name Operator) -> FixityOp

FixedWidth :: Format

FixedWidth :: Format

FixedWidth :: (NonEmptyArray Words) -> Block

FixityType :: (QualifiedName (ProperName ProperNameType_TypeConstructor)) -> (OpName OpNameType_TypeOpName) -> FixityOp

FixityType :: (SmartQualifiedName (ProperName ProperNameType_TypeConstructor)) -> (OpName OpNameType_TypeOpName) -> FixityOp

fiXOctagon :: ReactIcon

FixityValue :: (QualifiedName (Either Ident Proper)) -> SourceToken -> (Name Operator) -> FixityOp

fixedBottom :: ClassName

fixedBottom :: ClassName

fixedBottom :: ClassName

An update function that occurs at a fixed, regular interval, rather than on every animation frame.

FixityValue :: (Either (QualifiedName Ident) (QualifiedName (ProperName ProperNameType_ConstructorName))) -> (OpName OpNameType_ValueOpName) -> FixityOp

FixityValue :: (Either (SmartQualifiedName Ident) (SmartQualifiedNameConstructor)) -> (OpName OpNameType_ValueOpName) -> FixityOp

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

Positions of a fixed navbar

FixedChildren' :: forall logic obj. (FixedChildren logic obj) -> Entity logic obj

fixedSizeArray :: forall props u a. { editor :: FormBuilder { readonly :: Boolean | props } u a, label :: String } -> FormBuilder { readonly :: Boolean | props } (Array u) (Array a)

Edit an Array of values without letting the user add or remove entries.

fixComplexComplex :: forall r obj logic interpreter payload. Flatten logic interpreter obj r payload -> Fix interpreter obj r payload -> (Entity logic (obj payload) -> Entity logic (obj payload)) -> Entity logic (obj payload)

fixedPrecisionInput :: forall precision. KnownPrecision precision => FixedPrecisionInputProps precision -> JSX