Search results
liftEffect :: forall m a. MonadEffect m => Effect a -> m a
pull :: forall a m. MonadEffect m => Effect a -> m a
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.
unsafePerformEffect :: forall a. Effect a -> a
Run an effectful computation.
Note: use of this function can result in arbitrary side-effects.
inj :: forall f g a. Inject f g => f a -> g a
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
liftBase :: forall b m a. MonadBase b m => b a -> m a
folded :: forall event a. IsEvent event => Monoid a => event a -> event a
Combine subsequent events using a Monoid
.
folded :: forall a event. IsEvent event => Monoid a => event a -> event a
Combine subsequent events using a Monoid
.
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.
restoreAfter :: forall m a. MonadCanvasAction m => m a -> m a
Runs save
, then the provided action, then restore
lookAhead :: forall m a. LookAheadParsing m => m a -> m a
once :: forall a m. MonadLogic m => m a -> m a
try :: forall m a. Parsing m => m a -> m a
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
coerce :: forall f a b. Contravariant f => Functor f => f a -> f b
cleared :: forall f a b. Filterable f => f a -> f b
Filter out all values.
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
init :: forall xs ys lproxy. Init xs ys => lproxy xs -> lproxy ys
length :: forall xs r lproxy iproxy. Length xs r => lproxy xs -> iproxy r
forever :: forall b a m. Monad m => m a -> m b
pure :: forall f a. Applicative f => a -> f 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
.
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.
singleton :: forall f a. Unfoldable1 f => a -> f a
Contain a single value. For example:
singleton "foo" == (NEL.singleton "foo" :: NEL.NonEmptyList String)
downFrom :: forall a u. Enum a => Unfoldable u => a -> u a
Produces all predecessors of an Enum
value, excluding the start value.
downFromIncluding :: forall a u. Enum a => Unfoldable1 u => a -> u a
Produces all predecessors of an Enum
value, including the start value.
downFromIncluding top
will return all values in an Enum
, in reverse
order.
upFrom :: forall a u. Enum a => Unfoldable u => a -> u a
Produces all successors of an Enum
value, excluding the start value.
upFromIncluding :: forall a u. Enum a => Unfoldable1 u => a -> u a
Produces all successors of an Enum
value, including the start value.
upFromIncluding bottom
will return all values in an Enum
.
ask :: forall e w a. ComonadAsk e w => w a -> e
pos :: forall s w a. ComonadStore s w => w a -> s
throwError :: forall e m a. MonadThrow e m => e -> m a
getSingleton :: forall f a. SingletonFunctor f => f a -> a
colambek :: forall t f. Recursive t f => Corecursive t f => f t -> t
embed :: forall t f. Corecursive t f => f t -> t
lambek :: forall t f. Recursive t f => Corecursive t f => t -> f t
project :: forall t f. Recursive t f => t -> f t
sequenceProduct :: forall specI specO f. SequenceProduct specI specO f => specI -> f specO