Search results

assure :: forall a e g f. ErrorControl f g e => Monad f => g a -> (a -> Maybe e) -> f a

bind :: forall m a b. Bind m => m a -> (a -> m b) -> m b

discard :: forall a f b. Discard a => Bind f => f a -> (a -> f b) -> f b

bind' :: forall v1 v0 m c. HasBind c m => ObjectOf c v0 => ObjectOf c (m v1) => Restrictable Function c => m v0 -> (v0 -> (m v1)) -> m v1

bind :: forall c b a. HasChain a => a b -> (b -> a c) -> a c

A version of chain with the arguments flipped. This is provided only to support desugaring do notation. It is not recommended to use explicitly.

fairConjunction :: forall b a m. MonadLogic m => m a -> (a -> m b) -> m b

hummingbird :: forall m b a. Bind m => m a -> (a -> m b) -> m b

H combinator - hummingbird

BW(BC)

Λ a b c (a → b → a → c) → a → b → c

λ f x y . f x y x

when :: forall b a m. MonadLogic m => m a -> (a -> m b) -> m b

catchError :: forall e m a. MonadError e m => m a -> (e -> m a) -> m a

controlError :: forall f g e a. ErrorControl f g e => f a -> (e -> g a) -> g a

mapFlipped :: forall f a b. Functor f => f a -> (a -> b) -> f b

mapFlipped is map with its arguments reversed. For example:

[1, 2, 3] <#> \n -> n * n

flippedMap :: forall f a b. Functor f => f a -> (a -> b) -> f b

delay :: forall m a b. Delay m => a -> (a -> m b) -> m b

fromMaybeS :: forall a f. Selective f => f a -> f (Maybe a) -> f a

fromMaybeS :: forall @f @a. Select f => f a -> f (Maybe a) -> f a

If the second action is Nothing, run and return the first

cmapFlipped :: forall a b f. Contravariant f => f a -> (b -> a) -> f b

cmapFlipped is cmap with its arguments reversed.

intercept :: forall a e g f. ErrorControl f g e => f a -> (e -> a) -> g a

applyFlipped :: forall a b. a -> (a -> b) -> b

Applies an argument to a function. This is primarily used as the (#) operator, which allows parentheses to be omitted in some cases, or as a natural way to apply a value to a chain of composed functions.

applySecond :: forall a b f. Apply f => f a -> f b -> f b

Combine two effectful actions, keeping only the result of the second.

voidLeft :: forall f a b. Functor f => f a -> b -> f b

A version of voidRight with its arguments flipped.

fromMaybe' :: forall a. Maybe a -> a -> a

An infix form of fromMaybe with arguments flipped.

mulNat :: forall proxy a b c. ProductNat a b c => proxy a -> proxy b -> proxy c

plus :: forall proxy a b c. SumInt a b c => proxy a -> proxy b -> proxy c

plusNat :: forall proxy a b c. SumNat a b c => proxy a -> proxy b -> proxy c

powNat :: forall proxy a b c. ExponentiationNat a b c => proxy a -> proxy b -> proxy c

> powNat d2 d3
8 -- : NProxy D8

a raised to the power of b a^b = c

prod :: forall proxy a b c. ProductInt a b c => proxy a -> proxy b -> proxy c

divides :: forall a. Divisible a => a -> a -> Maybe a

sampleOnLeft_ :: forall event a b. IsEvent event => event a -> event b -> event b

downcast :: forall ctor from to. ctor -> from -> Maybe to

Attempt to cast to a type given a constructor for it

applySecond :: forall v1 v0 f c. HasApply c f => HasConst c => HasIdentity c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v1) => ObjectOf c (c v0 (c v1 v1)) => ObjectOf c (c (c v1 v1) (c v0 (c v1 v1))) => f v0 -> f v1 -> f v1

concat :: forall xs ys zs lproxy. Concat xs ys zs => lproxy xs -> lproxy ys -> lproxy zs

downcast :: forall ctor from to. ctor -> from -> Maybe to

Attempt to cast to a type given a constructor for it

drop :: forall n xs ys lproxy iproxy. Drop n xs ys => iproxy n -> lproxy xs -> lproxy ys

lookup :: forall c k r. Lookup c k r => c -> k -> Maybe r

Given some type and a key on that type, extract some value that corresponds to that key.

lookup :: forall c k r. Lookup c k r => c -> k -> Maybe r

Given some type and a key on that type, extract some value that corresponds to that key.

map :: forall f xs ys fproxy kproxy lproxy. Map f xs ys => fproxy f -> kproxy xs -> lproxy ys

take :: forall n xs ys lproxy iproxy. Take n xs ys => iproxy n -> lproxy xs -> lproxy ys

zip :: forall x y z lproxy. Zip x y z => lproxy x -> lproxy y -> lproxy z

getOrAlt :: forall v s r' r l h g f. Alternative h => Cons s v r' r => RowToList r l => RGetOrAlt f g s l r => g s -> f r -> h v

max :: forall a. PartialOrd a => a -> a -> Maybe a

min :: forall a. PartialOrd a => a -> a -> Maybe a

pMax :: forall a. PartialOrd a => a -> a -> Maybe a

pMin :: forall a. PartialOrd a => a -> a -> Maybe a

rsingleton :: forall f g s v r. RSingleton f g s => Cons s v () r => Lacks s () => g s -> v -> f r

singleton :: forall v s r g f. Cons s v () r => Lacks s () => RSingleton f g s => g s -> v -> f r

_call :: forall b a. a -> (a -> b) -> b

after :: forall k f. Eq k => Foldable f => k -> f k -> Maybe k

always_ :: forall a i. i -> a -> Maybe i

before :: forall k f. Eq k => Foldable f => k -> f k -> Maybe k

bind :: forall a. Semigroup a => a -> (a -> a) -> a

extract :: forall r x a. TypeEquals r x => r -> (x -> a) -> a

functorDecorateFlipped :: forall b a f. Functor f => Decorate b a => f a -> b -> f b

nmapFlipped :: forall b a fb fa. NestedFunctor fa fb a b => fa -> (a -> b) -> fb

t :: forall b a. a -> (a -> b) -> b

Reverse application which is probably exist inside Lens module

t :: forall b a. a -> (a -> b) -> b

thrush :: forall b a. a -> (a -> b) -> b

T combinator - thrush

CI

Λ a b . a → (a → b) → b

λ x f . f x

applyFirst :: forall a b f. Apply f => f a -> f b -> f a

Combine two effectful actions, keeping only the result of the first.

alt :: forall f a. Alt f => f a -> f a -> f a

optional :: forall f a. Alt f => Applicative f => f a -> f (Maybe a)

One or none.

optional empty = pure Nothing

The behaviour of optional (pure x) depends on whether the Alt instance satisfy the left catch law (pure a <|> b = pure a).

Either e does:

optional (Right x) = Right (Just x)

But Array does not:

optional [x] = [Just x, Nothing]

choose :: forall m a. MonadGen m => m a -> m a -> m a

Creates a generator that outputs a value chosen from one of two existing existing generators with even probability.

genMaybe :: forall m a. MonadGen m => m a -> m (Maybe a)

Creates a generator that outputs Maybe values, choosing a value from another generator for the inner value. The generator has a 75% chance of returning a Just over a Nothing.

optional :: forall f a. Alt f => Applicative f => f a -> f (Maybe a)

sampleOnRight_ :: forall event a b. IsEvent event => event a -> event b -> event a

Create an Event which samples the latest values from the first event at the times when the second event fires, ignoring the values produced by the second event.

sampleOn_ :: forall b a event. IsEvent event => event a -> event b -> event a

Create an Event which samples the latest values from the first event at the times when the second event fires, ignoring the values produced by the second event.

applyFirst :: forall v1 v0 f c. HasApply c f => HasConst c => HasMap c f => ObjectOf c v0 => ObjectOf c v1 => ObjectOf c (c v1 v0) => f v0 -> f v1 -> f v0

flipScalarMul :: forall k f. VectorField f k => f k -> k -> f k

max1 :: forall f a. Ord1 f => f a -> f a -> f a

min1 :: forall f a. Ord1 f => f a -> f a -> f a

onIntegrityError :: forall m a. MonadError PGError m => m a -> m a -> m a

alt :: forall f a. Alternative f => f a -> f a -> f a

dappend :: forall cnt a. Diff cnt => cnt a -> cnt a -> cnt a

fromFoldableL :: forall a c f. Foldable f => Consable c => c a -> f a -> c a

Conversion from Foldable to Consable using foldl.

fromFoldableL [] [1,2,3,4]  == [4,3,2,1]
fromFoldableL [0] [1,2,3,4] == [4,3,2,1,0]

fromFoldableR :: forall a c f. Foldable f => Consable c => c a -> f a -> c a

Conversion from Foldable to Consable using foldr.

fromFoldableR [] [1,2,3,4]  == [1,2,3,4]
fromFoldableR [5] [1,2,3,4] == [1,2,3,4,5]

interleave :: forall m a. MonadLogic m => m a -> m a -> m a

optionMaybe :: forall a m. Alternative m => m a -> m (Maybe a)

snoc :: forall f a. Container f => f a -> a -> f a

voidRight :: forall f a b. Functor f => a -> f b -> f a

Ignore the return value of a computation, using the specified return value instead.

fromJust :: forall a. Partial => Maybe a -> a

A partial function that extracts the value from the Just data constructor. Passing Nothing to fromJust will throw an error at runtime.

fromMaybe :: forall f a. Unfoldable f => Maybe a -> f a

Convert a Maybe to any Unfoldable, such as lists or arrays.

fromMaybe (Nothing :: Maybe Int) == []
fromMaybe (Just 1) == [1]

enumFromTo :: forall a u. Enum a => Unfoldable1 u => a -> a -> u a

Returns a contiguous sequence of elements from the first value to the second value (inclusive).

enumFromTo 0 3 = [0, 1, 2, 3]
enumFromTo 'c' 'a' = ['c', 'b', 'a']

The example shows Array return values, but the result can be any type with an Unfoldable1 instance.

seek :: forall s a w. ComonadStore s w => s -> w a -> w a

Reposition the focus at the specified position.

filled :: forall m a style. MonadCanvasAction m => CanvasStyle style => style -> m a -> m a

Run a MonadCanvasAction with the given fillStyle, resetting it to the previous value after

putCtx :: forall a html ctx. Ctx ctx html => ctx -> html a -> html a

stroked :: forall m a style. MonadCanvasAction m => CanvasStyle style => style -> m a -> m a

Run a MonadCanvasAction with the given strokeStyle, resetting it to the previous value after

tellAccum :: forall acc html a. TellAccum acc html => acc -> html a -> html a

get :: forall v s r' r l g f. Cons s v r' r => RGet f g s l r => RowToList r l => g s -> f r -> v

match :: forall v r1 r0 l1 l0 g f. RMatch f g v l0 r0 l1 r1 => RowToList r0 l0 => RowToList r1 l1 => f r0 -> g r1 -> v

scalarMul :: forall f k. VectorField f k => k -> f k -> f k

• ∀v in V: one * v == v
• ∀a b in K, v in V: a * (b .* v) = (a * b) .* v
• ∀a b in K, v in V:
  • a .* (u + v) = a .* u + a .* v
  • (a + b) .* v = a .* v + b .* v

cons :: forall t a. Consable t => a -> t a -> t a

cons :: forall f a. Container f => a -> f a -> f a

convertOption :: forall field from to sproxy. ConvertOption field from to => sproxy field -> from -> to

fromJust :: forall a. Maybe a -> a

fromJust' :: forall a. Maybe a -> a

The partial and unsafe version of fromJust.

functorDecorate :: forall b a f. Functor f => Decorate a b => a -> f b -> f a

index :: forall f a b. Representable f a => f b -> (a -> b)

insert :: forall f a. Container f => Ord a => a -> f a -> f a

invokeAction :: forall m res args ctrl act. RemoteAction act ctrl args res => MonadReader Visualforce m => MonadAff m => MonadError RemoteActionError m => IsSymbol ctrl => Encode args => Decode res => act -> args -> m res

Function that invoke the action defined by referring to contraints which holds details about the correct controller to invoke. Example:

data PCMRequests = ..

data CreatePCMRequests = CreatePCMRequests

instance remoteActionCreatePCMs :: RemoteAction CreatePCMRequests "PCMMassController.createRecords" PCMRequests Unit

createPCMRequest :: Visualforce -> PCMRequests -> Aff (Either RemoteActionError Unit)
createPCMRequest vf rec =  runReaderT (runExceptT $ invokeAction CreatePCMRequests rec) vf

option :: forall a m. Alternative m => a -> m a -> m a

replaceInArray :: forall a f. HasUuid a => Functor f => a -> f a -> f a

splice :: forall f t. Corecursive t (SqlF f) => Maybe t -> t

toDefault :: forall a. Default a => Maybe a -> a

Turns Nothing into a “default” (zero) value.

The Protobuf spec requires that a no presence field set to its “default” (zero) value must not be serialized to the wire.

When receiving messages we can use this function to interpret a missing no presence field as a “default” value.

unsafeMaybeToNullableAttr :: forall a. Maybe a -> a

WARNING: This is for JS interop -- don't use this to unwrap Maybes!

Unsafely nulls out a value so the resulting html attributes are less noisy Ex: R.input { type: unsafeMaybeToNullableAttr Nothing } avoids rendering the type attribute while still validating the type of the Maybe's content matches the type of the DOM field. It's only slightly safer than using unsafeCreateDOMComponent to avoid DOM type checking entirely.

duplicate :: forall a w. Extend w => w a -> w (w a)

Duplicate a comonadic context.

duplicate is dual to Control.Bind.join.

unfoldable :: forall m f a. MonadRec m => MonadGen m => Unfoldable f => m a -> m (f a)

Creates a generator that produces unfoldable structures based on an existing generator for the elements.

The size of the unfoldable will be determined by the current size state for the generator. To generate an unfoldable structure of a particular size, use the resize function from the MonadGen class first.

unwrapCofree :: forall f w a. ComonadCofree f w => w a -> f (w a)

fork :: forall f m a. MonadFork f m => m a -> m (f a)

suspend :: forall f m a. MonadFork f m => m a -> m (f a)

toBase :: forall b m a. MonadUnlift b m => m a -> m (b a)

Run the given action inside the base monad b.

split :: forall f a. Applicative f => f a -> f (f a)

add :: forall a. Semiring a => a -> a -> a

append :: forall a. Semigroup a => a -> a -> a

conj :: forall a. HeytingAlgebra a => a -> a -> a

const :: forall a b. a -> b -> a

Returns its first argument and ignores its second.

const 1 "hello" = 1

It can also be thought of as creating a function that ignores its argument:

const 1 = \_ -> 1

disj :: forall a. HeytingAlgebra a => a -> a -> a

div :: forall a. EuclideanRing a => a -> a -> a

gcd :: forall a. Eq a => EuclideanRing a => a -> a -> a

The greatest common divisor of two values.

genericAdd :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

A Generic implementation of the add member from the Semiring type class.

genericAdd' :: forall a. GenericSemiring a => a -> a -> a

genericAppend :: forall a rep. Generic a rep => GenericSemigroup rep => a -> a -> a

A Generic implementation of the append member from the Semigroup type class.

genericAppend' :: forall a. GenericSemigroup a => a -> a -> a

genericConj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the conj member from the HeytingAlgebra type class.

genericConj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericDisj :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the disj member from the HeytingAlgebra type class.

genericDisj' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericImplies :: forall a rep. Generic a rep => GenericHeytingAlgebra rep => a -> a -> a

A Generic implementation of the implies member from the HeytingAlgebra type class.

genericImplies' :: forall a. GenericHeytingAlgebra a => a -> a -> a

genericMul :: forall a rep. Generic a rep => GenericSemiring rep => a -> a -> a

A Generic implementation of the mul member from the Semiring type class.

genericMul' :: forall a. GenericSemiring a => a -> a -> a

genericSub :: forall a rep. Generic a rep => GenericRing rep => a -> a -> a

A Generic implementation of the sub member from the Ring type class.

genericSub' :: forall a. GenericRing a => a -> a -> a

implies :: forall a. HeytingAlgebra a => a -> a -> a

lcm :: forall a. Eq a => EuclideanRing a => a -> a -> a

The least common multiple of two values.

leftDiv :: forall a. DivisionRing a => a -> a -> a

Left division, defined as leftDiv a b = recip b * a. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

max :: forall a. Ord a => a -> a -> a

Take the maximum of two values. If they are considered equal, the first argument is chosen.

min :: forall a. Ord a => a -> a -> a

Take the minimum of two values. If they are considered equal, the first argument is chosen.

mod :: forall a. EuclideanRing a => a -> a -> a

mul :: forall a. Semiring a => a -> a -> a

rightDiv :: forall a. DivisionRing a => a -> a -> a

Right division, defined as rightDiv a b = a * recip b. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

sub :: forall a. Ring a => a -> a -> a

extract :: forall w a. Comonad w => w a -> a

and :: forall a f. Foldable f => HeytingAlgebra a => f a -> a

The conjunction of all the values in a data structure. When specialized to Boolean, this function will test whether all of the values in a data structure are true.

fold :: forall f m. Foldable f => Monoid m => f m -> m

Fold a data structure, accumulating values in some Monoid.

fold1 :: forall t m. Foldable1 t => Semigroup m => t m -> m

Fold a data structure, accumulating values in some Semigroup.

intercalate :: forall f m. Foldable f => Monoid m => m -> f m -> m

Fold a data structure, accumulating values in some Monoid, combining adjacent elements using the specified separator.

For example:

> intercalate ", " ["Lorem", "ipsum", "dolor"]
= "Lorem, ipsum, dolor"

> intercalate "*" ["a", "b", "c"]
= "a*b*c"

> intercalate [1] [[2, 3], [4, 5], [6, 7]]
= [2, 3, 1, 4, 5, 1, 6, 7]

intercalate :: forall f m. Foldable1 f => Semigroup m => m -> f m -> m

Fold a data structure using a Semigroup instance, combining adjacent elements using the specified separator.

length :: forall a b f. Foldable f => Semiring b => f a -> b

Returns the size/length of a finite structure. Optimized for structures that are similar to cons-lists, because there is no general way to do better.

maximum :: forall f a. Ord a => Foldable1 f => f a -> a

minimum :: forall f a. Ord a => Foldable1 f => f a -> a

or :: forall a f. Foldable f => HeytingAlgebra a => f a -> a

The disjunction of all the values in a data structure. When specialized to Boolean, this function will test whether any of the values in a data structure is true.

product :: forall a f. Foldable f => Semiring a => f a -> a

Find the product of the numeric values in a data structure.

sum :: forall a f. Foldable f => Semiring a => f a -> a

Find the sum of the numeric values in a data structure.

surround :: forall f m. Foldable f => Semigroup m => m -> f m -> m

fold but with each element surrounded by some fixed value.

For example:

> surround "*" []
= "*"

> surround "*" ["1"]
= "*1*"

> surround "*" ["1", "2"]
= "*1*2*"

> surround "*" ["1", "2", "3"]
= "*1*2*3*"

forever :: forall m a b. MonadRec m => m a -> m b

forever runs an action indefinitely, using the MonadRec instance to ensure constant stack usage.

For example:

main = forever $ trace "Hello, World!"

proof :: forall a b p. TypeEquals a b => p a -> p b

elements :: forall m f a. MonadGen m => Foldable1 f => f a -> m a

Creates a generator that outputs a value chosen from a selection with uniform probability.

coerce :: forall f a b. Contravariant f => Functor f => f a -> f b

ask :: forall e w a. ComonadAsk e w => w a -> e

peek :: forall s w a. ComonadStore s w => s -> w a -> a

pos :: forall s w a. ComonadStore s w => w a -> s

track :: forall t w a. ComonadTraced t w => t -> w a -> a

inj :: forall f g a. Inject f g => f a -> g a

sans :: forall m a b. At m a b => a -> m -> m

join :: forall f m a. MonadFork f m => f a -> m a

uninterruptible :: forall e f m a. MonadBracket e f m => m a -> m a

add :: forall x y z. Add x y z => x -> y -> z

and :: forall b1 b2 b3. And b1 b2 b3 => b1 -> b2 -> b3

div :: forall x y z. Div x y z => x -> y -> z

eq :: forall b1 b2 b3. Eq b1 b2 b3 => b1 -> b2 -> b3

gcd :: forall x y z. GCD x y z => x -> y -> z

imp :: forall b1 b2 b3. Imp b1 b2 b3 => b1 -> b2 -> b3

max :: forall x y z. Max x y z => x -> y -> z

min :: forall x y z. Min x y z => x -> y -> z

mod :: forall x y r. Mod x y r => x -> y -> r

mul :: forall x y z. Mul x y z => x -> y -> z

or :: forall b1 b2 b3. Or b1 b2 b3 => b1 -> b2 -> b3

sub :: forall x y z. Sub x y z => x -> y -> z

trich :: forall x y r. Trich x y r => x -> y -> r

xor :: forall b1 b2 b3. Xor b1 b2 b3 => b1 -> b2 -> b3

cleared :: forall f a b. Filterable f => f a -> f b

Filter out all values.

hmap :: forall f a b. HMap f a b => f -> a -> b

hmapWithIndex :: forall f a b. HMapWithIndex f a b => f -> a -> b

mapping :: forall f a b. Mapping f a b => f -> a -> b

resulting :: forall f acc x. Resulting f acc x => f -> acc -> x

variadic :: forall f acc args. Variadic f acc args => f -> acc -> args

variadicWithIndex :: forall f acc args. VariadicWithIndex f acc args => f -> acc -> args

call :: forall s. IsString s => Monoid s => s -> s -> s

Syntax for CSS function call.

getSingleton :: forall f a. SingletonFunctor f => f a -> a

liftBase :: forall b m a. MonadBase b m => b a -> m a

reduce :: forall f i o. Reducible f i o => f -> i -> o

lact :: forall g s. LeftAction g s => g -> s -> s

ract :: forall g s. RightAction g s => s -> g -> s

convertOptions :: forall t i o. ConvertOptions t i o => t -> i -> o

defaults :: forall defaults provided all. Defaults defaults provided all => defaults -> provided -> all

length :: forall sproxy proxy a b. Length a b => sproxy a -> proxy b

parseInt :: forall sproxy proxy sym a. ParseInt sym a => sproxy sym -> proxy a

parse Int a Value-Level

parseInt (Proxy  :: _ "-1337") ~> N1337
parseInt (SProxy :: _ "-1337") ~> N1337
    -- N1137 would be type alias for Neg (Succ^1337 Z)

parseNat :: forall sproxy proxy sym a. ParseNat sym a => sproxy sym -> proxy a

value-level parse of number

parseNat (Proxy  "10") ~> D10
parseNat (SProxy "10") ~> D10

colambek :: forall t f. Recursive t f => Corecursive t f => f t -> t

embed :: forall t f. Corecursive t f => f t -> t

folded :: forall event a. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

maddL :: forall x r. LeftModule x r => x -> x -> x

maddR :: forall x r. RightModule x r => x -> x -> x

mmulL :: forall x r. LeftModule x r => r -> x -> x

mmulR :: forall x r. RightModule x r => x -> r -> x

msubL :: forall x r. LeftModule x r => x -> x -> x

msubR :: forall x r. RightModule x r => x -> x -> x

bindTo :: forall f o. f -> o -> f

defaultUndef :: forall a. a -> a -> a

folded :: forall a event. IsEvent event => Monoid a => event a -> event a

Combine subsequent events using a Monoid.

new :: forall f a o. f -> a -> o

Call new on the function with an array or pseudoarray of arguments

dot :: forall p n. ToPos n p => Semiring n => p -> p -> n

Get the dot product of two vectors

mapProduct :: forall mp a b. MapProduct mp a b => mp -> a -> b

putInsideMod :: forall r p n. ToRegion n r => AsPosEndo n p => EuclideanRing n => r -> p -> p

Put a position inside a region by using the modulus operator

sort :: forall f a. Functor f => Foldable f => Unfoldable f => Ord a => f a -> f a

Sort any structure (which has Foldable, Unfoldable, and Functor instances) by converting to an OrdSeq and back again. I am fairly sure this is usually O(n*log(n)), although of course this depends on the Unfoldable and Foldable instances.

act :: forall m s. Action m s => m -> s -> s

Convert a value of type @m@ to an action on @s@ values.

askRunInBase :: forall b m a. MonadUnlift b m => m (m a -> b a)

A monomorphic version of askUnlift which can be more convenient when you only want to use the resulting runner function once with a concrete type.

If you run into type issues using this, try using askUnlit instead.

at :: forall c k r. Monoid r => Lookup c k r => c -> k -> r

This simple helper works on any Lookup instance where the return type is a Monoid, and is the same as lookup except that it returns a t instead of a Maybe t. If lookup would return Nothing, then at returns mempty.

at :: forall c k r. Monoid r => Lookup c k r => c -> k -> r

This simple helper works on any Lookup instance where the return type is a Monoid, and is the same as lookup except that it returns a t instead of a Maybe t. If lookup would return Nothing, then at returns mempty.

buildLeaf :: forall e f p v. ElementBuilder e f p v => e -> f p -> v

init :: forall xs ys lproxy. Init xs ys => lproxy xs -> lproxy ys

join :: forall a. JoinSemilattice a => a -> a -> a

length :: forall xs r lproxy iproxy. Length xs r => lproxy xs -> iproxy r

meet :: forall a. MeetSemilattice a => a -> a -> a

pathAppend :: forall m. XPathLike m => m -> m -> m

Put a path seperator between two XPaths and return the resulting XPath.

pathAppendNSx :: forall m. XPathLike m => m -> m -> m

Useful variant of pathAppend needed for some XPath implementations; insert a separator with a dummy namespace ("x") for the second XPath fragment. For example: root /? "record" /? "identifier" == "/x:record/x:identifier".

restoreAfter :: forall m a. MonadCanvasAction m => m a -> m a

Runs save, then the provided action, then restore

setCtx :: forall props' props ctx. WithContextProps props' props ctx => ctx -> props' -> props

adjacentSibling :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

and :: forall a. Binary a => a -> a -> a

child :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

dbg :: forall s a. Show s => s -> a -> a

descendant :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

diff :: forall a d. Diff a d => a -> a -> d

from1 :: forall f rep a. Generic1 f rep => f a -> rep

generalSibling :: forall a b c. IsExtensibleSelector a => ToVal a => Combine b c => a -> b -> c

join :: forall a. JoinSemilattice a => a -> a -> a

maddL :: forall x r. LeftModule x r => x -> x -> x

maddR :: forall x r. RightModule x r => x -> x -> x

meet :: forall a. MeetSemilattice a => a -> a -> a

mmulL :: forall x r. LeftModule x r => r -> x -> x

mmulR :: forall x r. RightModule x r => x -> r -> x

msubL :: forall x r. LeftModule x r => x -> x -> x

msubR :: forall x r. RightModule x r => x -> x -> x

nand :: forall α. HeytingAlgebra α => α -> α -> α

nor :: forall α. HeytingAlgebra α => α -> α -> α

or :: forall a. Binary a => a -> a -> a

patch :: forall a d. Patch a d => a -> d -> a

pursxStringAnonymous :: forall accumulator next res. PursxStringAnonymous accumulator next res => accumulator -> next -> res

pursxValAnonymous :: forall accumulator next res. PursxValAnonymous accumulator next res => accumulator -> next -> res

reciprocal :: forall n n1 n2 a r. Add n2 1 n1 => Add n1 1 n => Arity a n => Divisible r => Eq r => EuclideanRing r => Leadable r => Ord r => Pad n2 (Polynomial r) a => Peel r r => Unpad n2 (Polynomial r) a => a -> a -> a

Computes the reciprocal of the first polynomial in the extension whose minimal polynomial is provided by the second polynomial

set :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses Function s t a b => b -> s -> t