Search results

liftEffect :: forall m a. MonadEffect m => Effect a -> m a

pull :: forall a m. MonadEffect m => Effect a -> m a

read :: forall g a. RWLockGuard g => g a -> Aff a

pure :: forall f a. Applicative f => a -> f 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!"

singleton :: forall f a. Unfoldable1 f => a -> f a

Contain a single value. For example:

singleton "foo" == (NEL.singleton "foo" :: NEL.NonEmptyList String)

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.

unsafePerformEffect :: forall a. Effect a -> a

Run an effectful computation.

Note: use of this function can result in arbitrary side-effects.

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.

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

throwError :: forall e m a. MonadThrow e m => e -> m a

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

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

Filter out all values.

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

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

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

Combine subsequent events using a Monoid.

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

project :: forall t f. Recursive t f => t -> f t

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

Combine subsequent events using a Monoid.

sequenceProduct :: forall specI specO f. SequenceProduct specI specO f => specI -> f specO

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.

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

pure :: forall v f c. HasPure c f => ObjectOf c v => v -> f v

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

Runs save, then the provided action, then restore

bottom1_ :: forall f a. Bottom1_ f => a -> f a

bottom2 :: forall f a b. Bottom2 f a => a -> f b

top1_ :: forall f a. Top1_ f => a -> f a

act :: forall m b a. Mother m => a -> m b

drain :: forall a s n n1. ToString n1 s => IsSymbol s => Analytic (a n) => Analytic (a n1) => Add n1 1 n => a n -> a n1

Decrement the dimension of a point/vector by removing its last coordinate.

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

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

immerse :: forall a n n1. Analytic (a n) => Analytic (a n1) => Add n 1 n1 => a n -> a n1

Increments the dimension of a point/vector by adding a zero coordinate after the other coordinates.

lookAhead :: forall m a. LookAheadParsing m => m a -> m a

mockFun :: forall params fun verifyParams m. MockBuilder params fun verifyParams => MonadEffect m => params -> m fun

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

pure :: forall d a. Syntax d => Eq a => a -> d a

pure :: forall f a. Unital Function Unit Unit f => Functor f => a -> f a

pure :: forall a b. HasPure a => b -> a b

pure :: forall f a. Applicative f => a -> f a

query :: forall m q r. MonadSession m => AsQuery q => FromRows r => q -> m r

Executes a query and unmarshals the result into r

read :: forall box val m. Read box val => MonadDelay m => box -> m val

Read the current value. Will never cause a refresh.

repeat :: forall a u. Unfoldable1 u => a -> u a

Create an infinite Unfoldable1 by repeating a single element.

siteClock :: forall s m i c. Site s m i c => s -> m c

siteId :: forall s m i c. Site s m i c => s -> m i

throw :: forall (t10 :: Type -> Type) (t11 :: Type) (a12 :: Type). MonadThrow Error t10 => Show a12 => a12 -> t10 t11

try :: forall m a. Parsing m => m a -> m a

unfold :: forall f a s. Convert s (Statements a) => Unfoldable1 f => s -> f a

abs :: forall a. Ord a => Ring a => a -> a

The absolute value function. abs x is defined as if x >= zero then x else negate x.

from :: forall a rep. Generic a rep => a -> rep

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

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

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

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

negate x can be used as a shorthand for zero - x.

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

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

signum :: forall a. Ord a => Ring a => a -> a

The sign function; returns one if the argument is positive, negate one if the argument is negative, or zero if the argument is zero. For floating point numbers with signed zeroes, when called with a zero, this function returns the argument in order to preserve the sign. For any x, we should have signum x * abs x == x.

to :: forall a rep. Generic a rep => rep -> a

unwrap :: forall t a. Newtype t a => t -> a

wrap :: forall t a. Newtype t a => a -> t

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

unsafeCoerce :: forall a b. a -> b

A highly unsafe function, which can be used to persuade the type system that any type is the same as any other type. When using this function, it is your (that is, the caller's) responsibility to ensure that the underlying representation for both types is the same.

Because this function is extraordinarily flexible, type inference can greatly suffer. It is highly recommended to define specializations of this function rather than using it as-is. For example:

fromBoolean :: Boolean -> Json
fromBoolean = unsafeCoerce

This way, you won't have any nasty surprises due to the inferred type being different to what you expected.

After the v0.14.0 PureScript release, some of what was accomplished via unsafeCoerce can now be accomplished via coerce from purescript-safe-coerce. See that library's documentation for more context.

inj :: forall a b. Inject a b => a -> b

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.

unsafePartial :: forall a. (Partial => a) -> a

Discharge a partiality constraint, unsafely.

from :: forall a b. TypeEquals a b => b -> a

to :: forall a b. TypeEquals a b => a -> b

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

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

convertDuration :: forall a b. Duration a => Duration b => a -> b

Converts directly between durations of differing types.

negateDuration :: forall a. Duration a => a -> a

Negates a duration, turning a positive duration negative or a negative duration positive.

coerce :: forall a b. Coercible a b => a -> b

Coerce a value of one type to a value of some other type, without changing its runtime representation. This function behaves identically to unsafeCoerce at runtime. Unlike unsafeCoerce, it is safe, because the Coercible constraint prevents any use of this function from compiling unless the compiler can prove that the two types have the same runtime representation.

One application for this function is to avoid doing work that you know is a no-op because of newtypes. For example, if you have an Array (Conj a) and you want an Array (Disj a), you could do Data.Array.map (un Conj >>> Disj), but this performs an unnecessary traversal of the array, with O(n) cost. coerce accomplishes the same with only O(1) cost:

mapConjToDisj :: forall a. Array (Conj a) -> Array (Disj a)
mapConjToDisj = coerce

div10 :: forall x q. Div10 x q => x -> q

isDivBy :: forall d x. IsDivBy d x => d -> x

mul10 :: forall x q. Mul10 x q => x -> q

not :: forall b1 b2. Not b1 b2 => b1 -> b2

pred :: forall x y. Pred x y => x -> y

succ :: forall x y. Succ x y => x -> y

cast :: forall a b. Castable a b => a -> b

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

coerce :: forall expected given. Coerce given expected => given -> expected

coerce :: forall expected given. Coerce given expected => given -> expected

ginverse :: forall g. Group g => g -> g

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

convertTo :: forall t f r. Recursive t f => Corecursive r f => t -> r

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

fill :: forall partial complete. Fillable partial complete => partial -> complete

justify :: forall unjust just. Justifiable unjust just => unjust -> just

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

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

nextPrime :: forall a. Ord a => Semiring a => EuclideanRing a => a -> a

Ad infinitum

pad :: forall @n a b. Pad n a b => a -> b

unpad :: forall @n a b. Unpad n a b => b -> a

area :: forall s n. ToSize n s => Semiring n => s -> n

Get the area of a size

convertPos :: forall p1 p2 n. ToPos n p1 => FromPos n p2 => p1 -> p2

convertRegion :: forall p1 p2 n. ToRegion n p1 => FromRegion n p2 => p1 -> p2

convertSize :: forall p1 p2 n. ToSize n p1 => FromSize n p2 => p1 -> p2

init :: forall fn a. Init fn a => fn -> a

initProduct :: forall f a. InitProduct f a => f -> a

measure :: forall a v. Measured a v => a -> v

midPos :: forall s p n. ToRegion n s => FromPos n p => EuclideanRing n => s -> p

Get the center position of a region

perimeter :: forall s n. ToSize n s => Semiring n => s -> n

Get the perimeter of a size

ratio :: forall s n. ToSize n s => EuclideanRing n => s -> n

Get the ratio of a size by dividing the width by the height

undefer :: forall a. (Deferred => a) -> a

Note: use of this function may result in arbitrary side effects.

always :: forall a b. Always a b => a -> b

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

Prepend an '@'

complement :: forall p. Bounded p => Ring p => p -> p

convert :: forall b a. TokenUnit a => TokenUnit b => a -> b

Convert between two denominations

debugger :: forall a. a -> a

Inserts a JavaScript debugger statement, then returns its argument.

dir :: forall a. a -> a

Calls console.dir with its argument, then returns it.

inj :: forall l a. Includes l a => a -> l

Inject a value into an otherwise empty heterogeneous list.

log :: forall a. a -> a

Calls console.log with its argument, then returns it.

-- log a value as it's used
func a = todo $ log a

-- explicitly log an argument because it may not be used
func a =
  let
    _ = log a
  in
    todo

-- log the value inside a functor
func ma = do
  a <- log <$> pure ma
  todo

logShow :: forall a. Show a => a -> a

For an argument a, calls console.log on show a, then returns a.

nextSibling :: forall n m. IsNode n => IsNode m => n -> m

Gets the next sibling

parentNode :: forall n m. IsNode n => IsNode m => n -> m

prevSibling :: forall n m. IsNode n => IsNode m => n -> m

Gets the previous sibling

tUnit :: forall u1 u0 bf c. HasTUnit c bf u0 u1 => HasUnit c u1 => u0 -> u1

unsafeDir :: forall a b. a -> b

Like dir except it coerces the input to any type.

unsafeLog :: forall a b. a -> b

Like log except it coerces the input to any type.

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

Prepend a dummy namespace

abs :: forall a. Num a => a -> a

asTS :: forall b a. IsTSEq a b => a -> b

coerce :: forall a b. Coercible a b => a -> b

convertImpl :: forall input output. ToInternalConverter input output => input -> output

dbgs :: forall s. Show s => s -> s

embed :: forall a r. Algebra a r => r -> a

foldLineNames :: forall i o. FoldLineNames i o => i -> o

foldOf :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses (Forget a) s t a b => s -> a

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

fromFractional :: forall b a. Fractional a => Fractional b => a -> b

A helper function for general conversion between Fractional values.

fromIntegral :: forall b a. Integral a => Integral b => a -> b

A helper function for general conversion between Integral values.

hasJSRep :: forall a. HasJSRep a => a -> a

magicProps :: forall props. props -> props

mkPrim :: forall a b. Primitive a b => a -> b

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

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

negate :: forall a. Num a => a -> a

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

px :: forall next res. PursxStringAnonymous ((Proxy "a") /\ (Proxy "") /\ (Record ())) next res => next -> res

signum :: forall a. Num a => a -> a

stripLeadingZeros :: forall a. Elastic a => a -> a

toTuples :: forall a b. ToTuples a b => a -> b

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

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

view :: forall s t a b @sym lenses. IsSymbol sym => ParseSymbol sym lenses => ConstructBarlow lenses (Forget a) s t a b => s -> a

xformEventProps :: forall props. props -> props

_diagram :: forall t @d. IsTool t => IsDiagram d => t -> d

_fromVertex :: forall _l _n e v. LayoutNetwork _l _n e v => e -> v

_layout :: forall d @l. IsDiagram d => IsLayout l => d -> l

_locationObject :: forall p @g. IsPart p => IsGraphObject g => p -> g

_model :: forall d @m. IsDiagram d => IsModel m => d -> m

_network :: forall l n _e _v. LayoutNetwork l n _e _v => l -> n

_nodeTemplate :: forall d @p. IsDiagram d => IsPart p => d -> p

_originalFromNode :: forall t @n. IsLinkingBaseTool t => IsNode n => t -> n

_originalFromPort :: forall t @p. IsLinkingBaseTool t => IsGraphObject p => t -> p

_originalToNode :: forall t @n. IsLinkingBaseTool t => IsNode n => t -> n

_originalToPort :: forall t @p. IsLinkingBaseTool t => IsGraphObject p => t -> p

_resizeObject :: forall p @g. IsPart p => IsGraphObject g => p -> g

_rotateObject :: forall p @g. IsPart p => IsGraphObject g => p -> g

_selectionObject :: forall p @g. IsPart p => IsGraphObject g => p -> g

_targetPort :: forall t @p. IsLinkingBaseTool t => IsGraphObject p => t -> p

_temporaryFromNode :: forall t @n. IsLinkingBaseTool t => IsNode n => t -> n

_temporaryFromPort :: forall t @p. IsLinkingBaseTool t => IsGraphObject p => t -> p

_temporaryToNode :: forall t @n. IsLinkingBaseTool t => IsNode n => t -> n

_temporaryToPort :: forall t @p. IsLinkingBaseTool t => IsGraphObject p => t -> p

_toVertex :: forall _l _n e v. LayoutNetwork _l _n e v => e -> v

absoluteValue :: forall a. HasLess a => HasSubtract a => HasZero a => a -> a

Returns the absolute value of a number.

absoluteValue (-2) -- 2
absoluteValue 3 -- 3

align :: forall r a. Decorate Alignment a => Variadic Alignment r => a -> r

allpass :: forall i allpass. AllpassCtor i allpass => i -> allpass

Change an allpass filter

allpass { freq: 440.0 }
allpass { freq: 440.0, q: 1.0 }
allpass 440.0

allpass :: forall i allpass. AllpassCtor i allpass => i -> allpass

Create an allpass filter, connecting it to another unit

allpass { freq: 440.0 } { sinOsc: unit }
allpass { freq: 440.0, q: 1.0 } { sinOsc: unit }
allpass 440.0 { sinOsc: unit }

args :: forall params args return. ParamDivider params args return => params -> args

argsToTuple :: forall args tuple. ArgsAsTuple args tuple => args -> tuple

array :: forall f t. Corecursive t (SqlF EJsonF) => Foldable f => f t -> t

askFor :: forall a p. Ask a => p a -> a

Equivalent to ask except for accepting a Proxy for specifying the exact requested type

bandpass :: forall i bandpass. BandpassCtor i bandpass => i -> bandpass

Create a bandpass filter, connecting it to another unit

bandpass { freq: 440.0 } { sinOsc: unit }
bandpass { freq: 440.0, q: 1.0 } { sinOsc: unit }
bandpass 440.0 { sinOsc: unit }

bandpass :: forall i bandpass. BandpassCtor i bandpass => i -> bandpass

Create a bandpass filter, connecting it to another unit

bandpass { freq: 440.0 } { sinOsc: unit }
bandpass { freq: 440.0, q: 1.0 } { sinOsc: unit }
bandpass 440.0 { sinOsc: unit }

build :: forall b x. Buildable b x => b -> x

callback :: forall a c f. Castable c a => EffectFnMaker f c => f -> a

cast :: forall from to. Cast from to => from -> to

coerceReactProps :: forall props nonDataProps targetProps. CoerceReactProps props nonDataProps targetProps => props -> targetProps

coerceReactProps :: forall props nonDataProps targetProps. CoerceReactProps props nonDataProps targetProps => props -> targetProps

column :: forall r a. Decorate Column a => Variadic Column r => a -> r

compressor :: forall i compressor. DynamicsCompressorCtor i compressor => i -> compressor

Change a compressor.

compressor { threshold: -10.0 } { buf: playBuf "track" }
compressor { knee: 20.0, ratio: 10.0 } { buf: playBuf "track" }
compressor { attack: 0.01, release: 0.3 } { buf: playBuf "track" }

compressor :: forall i compressor. DynamicsCompressorCtor i compressor => i -> compressor

Make a compressor.

compressor { threshold: -10.0 } { buf: playBuf "track" }
compressor { knee: 20.0, ratio: 10.0 } { buf: playBuf "track" }
compressor { attack: 0.01, release: 0.3 } { buf: playBuf "track" }

constant :: forall i o. ConstantCtor i o => i -> o

Change a constant value

constant 0.5

constant :: forall i o. ConstantCtor i o => i -> o

Make a constant value

constant 0.5

constructRecord :: forall ty fn proxy. ConstructRecord ty fn => proxy ty -> fn

convert :: forall a b. Convert a b => a -> b

convertImpl :: forall input output. ToInternalConverter input output => input -> output

convertOptionsWithDefaults :: forall provided all. ConvertOptionsWithDefaults ToCollatorOptions (Record CollatorOptions) provided all => provided -> all

convertOptionsWithDefaults :: forall provided all. ConvertOptionsWithDefaults ToDateTimeFormatOptions (Record DateTimeFormatOptions) provided all => provided -> all

convertOptionsWithDefaults :: forall provided all. ConvertOptionsWithDefaults ToNumberFormatOptions (Record NumberFormatOptions) provided all => provided -> all

curried :: forall f output. Curried f output => f -> output

dataTooltipPosition :: forall r a. Decorate TooltipPosition a => Variadic Attribute r => a -> r

defMutationOpts :: forall baseClient queryOpts mutationOpts. QueryClient baseClient queryOpts mutationOpts => baseClient -> mutationOpts

defQueryOpts :: forall baseClient queryOpts mutationOpts. QueryClient baseClient queryOpts mutationOpts => baseClient -> queryOpts

defSubOpts :: forall baseClient opts. SubscriptionClient baseClient opts => baseClient -> opts

defWatchOpts :: forall baseClient opts. WatchQueryClient baseClient opts => baseClient -> opts

delayTime :: forall nt r ap p. Newtype nt (Variant (delayTime :: AudioParameter p | r)) => ToAudioParameter ap p => ap -> nt

discardTupledUnits :: forall a b. DiscardTupledUnits a b => a -> b

effectful :: forall f output. Effectful f output => f -> output

encode :: forall a o op s. Symbiote a o op s => a -> s

encodeOp :: forall a o op s. Symbiote a o op s => op -> s

float :: forall r a. Decorate Float a => Variadic Float r => a -> r

frequency :: forall nt r ap p. Newtype nt (Variant (frequency :: AudioParameter p | r)) => ToAudioParameter ap p => ap -> nt

fromTagged :: forall tagged untagged. Tagged tagged untagged => tagged -> untagged

Convert a tagged union to an untagged union. E.g.

data IST = IT Int | ST String 
derive instance Generic IST _ 

type ISU = Int |+| String 

ist :: IST
ist = ST "Wurst"

isu :: ISU 
isu = fromTagged ist
-- asOneOf "Wurst"

fromTaggedHelper :: forall taggedGen untagged. TaggedHelper taggedGen untagged => taggedGen -> untagged

gain :: forall nt r ap p. Newtype nt (Variant (gain :: AudioParameter p | r)) => ToAudioParameter ap p => ap -> nt

genericAbsurd :: forall a t. Generic t NoConstructors => t -> a

Absurd for any Generic data-type with no constructors.

genericSumToVariantArgImpl :: forall rep out. GenericSumToVariantArg rep out => rep -> out

getGeometry :: forall m g. HasGeometry m g => m -> g

highpass :: forall i highpass. HighpassCtor i highpass => i -> highpass

Change a highpass filter

highpass { freq: 440.0 }
highpass { freq: 440.0, q: 1.0 }
highpass 440.0

highpass :: forall i highpass. HighpassCtor i highpass => i -> highpass

Make a highpass filter

highpass { freq: 440.0 } { osc: sinOsc 440.0 }
highpass { freq: 440.0, q: 1.0 } { osc: sinOsc 440.0 }
highpass 440.0 { osc: sinOsc 440.0 }

highshelf :: forall i highshelf. HighshelfCtor i highshelf => i -> highshelf

Change a highshelf filter

highshelf { freq: 440.0 }
highshelf { freq: 440.0, gain: 1.0 }
highshelf 440.0

highshelf :: forall i highshelf. HighshelfCtor i highshelf => i -> highshelf

Make a highshelf filter

highshelf { freq: 440.0 } { osc: sinOsc 440.0 }
highshelf { freq: 440.0, gain: 1.0 } { osc: sinOsc 440.0 }
highshelf 440.0 { osc: sinOsc 440.0 }

identity :: forall a. a -> a

Returns the value it was given.

identity 1 -- 1

This is the identity function.

image :: forall r a. Decorate Image a => Variadic Image r => a -> r

init :: forall token a. Init token a => token -> a

keyNoop :: forall a. Key a => a -> a

liftVariadic :: forall a r. Variadic a r => a -> r

liftVariadicPreloader :: forall a r. VariadicPreloader a r => a -> r

loopBuf :: forall i loopBuf. LoopBufCtor i loopBuf => i -> loopBuf

Change a looping buffer.

loopBuf { playbackRate: 1.0 } "track"
loopBuf { playbackRate: 1.0, loopStart: 0.5 } "track"
loopBuf "track"

loopBuf :: forall i loopBuf. LoopBufCtor i loopBuf => i -> loopBuf

Make a looping buffer.

loopBuf { playbackRate: 1.0 } "track"
loopBuf { playbackRate: 1.0, loopStart: 0.5 } "track"
loopBuf "track"

lowpass :: forall i lowpass. LowpassCtor i lowpass => i -> lowpass

Change a lowpass filter

lowpass { freq: 440.0 }
lowpass { freq: 440.0, q: 1.0 }
lowpass 440.0

lowpass :: forall i lowpass. LowpassCtor i lowpass => i -> lowpass

Make a lowpass filter

lowpass { freq: 440.0 } { osc: sinOsc 440.0 }
lowpass { freq: 440.0, q: 1.0 } { osc: sinOsc 440.0 }
lowpass 440.0 { osc: sinOsc 440.0 }

lowshelf :: forall i lowshelf. LowshelfCtor i lowshelf => i -> lowshelf

Change a lowshelf filter

lowshelf { freq: 440.0 }
lowshelf { freq: 440.0, gain: 1.0 }
lowshelf 440.0

lowshelf :: forall i lowshelf. LowshelfCtor i lowshelf => i -> lowshelf

Make a lowshelf filter

lowshelf { freq: 440.0 } { osc: sinOsc 440.0 }
lowshelf { freq: 440.0, gain: 1.0 } { osc: sinOsc 440.0 }
lowshelf 440.0 { osc: sinOsc 440.0 }

makeMicrophone :: forall audio engine. AudioInterpret audio engine => audio -> engine

Make a microphone.

makeSpeaker :: forall audio engine. AudioInterpret audio engine => audio -> engine

Make a node representing the loudspeaker. For sound to be rendered, it must go to a loudspeaker.

makeVariantLabels :: forall a b. HMapWithIndex MakeVariantLabel a b => a -> b

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

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

mm :: forall a b. MM a b => a -> b

mold :: forall e t. Moldable t e => Monoid e => t -> e

Combine all the elements in the moldable type using the action of the monoid

negate :: forall a. HasSubtract a => HasZero a => a -> a

Negates the value by subtracting the value from zero.

negate 2 -- -2