Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- data Event a
- type ClockInfo m = ReaderT DTime m
- type SF m = MSF (ClockInfo m)
- type DTime = Double
- type Time = Double
- identity :: Monad m => SF m a a
- constant :: Monad m => b -> SF m a b
- time :: Monad m => SF m () Time
- localTime :: Monad m => SF m () Time
- integral :: (Monad m, VectorSpace a s) => SF m a a
- integralFrom :: (Monad m, VectorSpace a s) => a -> SF m a a
- derivative :: (Monad m, VectorSpace a s) => SF m a a
- derivativeFrom :: (Monad m, VectorSpace a s) => a -> SF m a a
- noEvent :: Event a
- event :: a -> (b -> a) -> Event b -> a
- fromEvent :: Event p -> p
- isEvent :: Event a -> Bool
- tag :: Event a -> b -> Event b
- mergeBy :: (a -> a -> a) -> Event a -> Event a -> Event a
- lMerge :: Event a -> Event a -> Event a
- rMerge :: Event a -> Event a -> Event a
- eventToMaybe :: Event a -> Maybe a
- maybeToEvent :: Maybe a -> Event a
- boolToEvent :: Bool -> Event ()
- edge :: Monad m => SF m Bool (Event ())
- edgeBy :: Monad m => (a -> a -> Maybe b) -> a -> SF m a (Event b)
- edgeFrom :: Monad m => Bool -> SF m Bool (Event ())
- notYet :: Monad m => SF m (Event a) (Event a)
- hold :: Monad m => a -> SF m (Event a) a
- loopPre :: Monad m => c -> SF m (a, c) (b, c) -> SF m a b
- never :: Monad m => SF m a (Event b)
- now :: Monad m => b -> SF m a (Event b)
- once :: Monad m => SF m (Event a) (Event a)
- takeEvents :: Monad m => Int -> SF m (Event a) (Event a)
- after :: Monad m => Time -> b -> SF m a (Event b)
- occasionally :: MonadRandom m => Time -> b -> SF m a (Event b)
- (-->) :: Monad m => b -> SF m a b -> SF m a b
- (>--) :: Monad m => a -> SF m a b -> SF m a b
- replaceOnce :: Monad m => a -> SF m a a
- accumHoldBy :: Monad m => (b -> a -> b) -> b -> SF m (Event a) b
- parB :: Monad m => [SF m a b] -> SF m a [b]
- dpSwitchB :: (Monad m, Traversable col) => col (SF m a b) -> SF m (a, col b) (Event c) -> (col (SF m a b) -> c -> SF m a (col b)) -> SF m a (col b)
- dSwitch :: Monad m => SF m a (b, Event c) -> (c -> SF m a b) -> SF m a b
- switch :: Monad m => SF m a (b, Event c) -> (c -> SF m a b) -> SF m a b
- parC :: Monad m => SF m a b -> SF m [a] [b]
- parC' :: Monad m => [SF m a b] -> SF m [a] [b]
- iterFrom :: Monad m => (a -> a -> DTime -> b -> b) -> b -> SF m a b
- reactimate :: Monad m => m a -> (Bool -> m (DTime, Maybe a)) -> (Bool -> b -> m Bool) -> SF Identity a b -> m ()
- dup :: b -> (b, b)
- leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
- (^<<) :: Arrow a => (c -> d) -> a b c -> a b d
- (<<^) :: Arrow a => a c d -> (b -> c) -> a b d
- (>>^) :: Arrow a => a b c -> (c -> d) -> a b d
- (^>>) :: Arrow a => (b -> c) -> a c d -> a b d
- returnA :: Arrow a => a b b
- class Category a => Arrow (a :: Type -> Type -> Type) where
- newtype Kleisli (m :: Type -> Type) a b = Kleisli {
- runKleisli :: a -> m b
- class Arrow a => ArrowZero (a :: Type -> Type -> Type) where
- zeroArrow :: a b c
- class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type) where
- (<+>) :: a b c -> a b c -> a b c
- class Arrow a => ArrowChoice (a :: Type -> Type -> Type) where
- class Arrow a => ArrowApply (a :: Type -> Type -> Type) where
- app :: a (a b c, b) c
- newtype ArrowMonad (a :: Type -> Type -> Type) b = ArrowMonad (a () b)
- class Arrow a => ArrowLoop (a :: Type -> Type -> Type) where
- loop :: a (b, d) (c, d) -> a b c
- (>>>) :: Category cat => cat a b -> cat b c -> cat a c
- (<<<) :: Category cat => cat b c -> cat a b -> cat a c
- pauseOn :: Show a => (a -> Bool) -> String -> MSF IO a a
- traceWhen :: (Monad m, Show a) => (a -> Bool) -> (String -> m ()) -> String -> MSF m a a
- traceWith :: (Monad m, Show a) => (String -> m ()) -> String -> MSF m a a
- repeatedly :: Monad m => (a -> a) -> a -> MSF m () a
- unfold :: Monad m => (a -> (b, a)) -> a -> MSF m () b
- mealy :: Monad m => (a -> s -> (b, s)) -> s -> MSF m a b
- accumulateWith :: Monad m => (a -> s -> s) -> s -> MSF m a s
- mappendFrom :: (Monoid n, Monad m) => n -> MSF m n n
- mappendS :: (Monoid n, Monad m) => MSF m n n
- sumFrom :: (RModule v, Monad m) => v -> MSF m v v
- sumS :: (RModule v, Monad m) => MSF m v v
- count :: (Num n, Monad m) => MSF m a n
- fifo :: Monad m => MSF m [a] (Maybe a)
- next :: Monad m => b -> MSF m a b -> MSF m a b
- iPost :: Monad m => b -> MSF m a b -> MSF m a b
- iPre :: Monad m => a -> MSF m a a
- withSideEffect_ :: Monad m => m b -> MSF m a a
- withSideEffect :: Monad m => (a -> m b) -> MSF m a a
- mapMaybeS :: Monad m => MSF m a b -> MSF m (Maybe a) (Maybe b)
- type MStream (m :: Type -> Type) a = MSF m () a
- type MSink (m :: Type -> Type) a = MSF m a ()
- morphS :: (Monad m2, Monad m1) => (forall c. m1 c -> m2 c) -> MSF m1 a b -> MSF m2 a b
- liftTransS :: (MonadTrans t, Monad m, Monad (t m)) => MSF m a b -> MSF (t m) a b
- (>>>^) :: MonadBase m1 m2 => MSF m2 a b -> MSF m1 b c -> MSF m2 a c
- (^>>>) :: MonadBase m1 m2 => MSF m1 a b -> MSF m2 b c -> MSF m2 a c
- liftBaseS :: (Monad m2, MonadBase m1 m2) => MSF m1 a b -> MSF m2 a b
- liftBaseM :: (Monad m2, MonadBase m1 m2) => (a -> m1 b) -> MSF m2 a b
- arrM :: Monad m => (a -> m b) -> MSF m a b
- constM :: Monad m => m b -> MSF m a b
- embed :: Monad m => MSF m a b -> [a] -> m [b]
- feedback :: Monad m => c -> MSF m (a, c) (b, c) -> MSF m a b
- morphGS :: Monad m2 => (forall c. (a1 -> m1 (b1, c)) -> a2 -> m2 (b2, c)) -> MSF m1 a1 b1 -> MSF m2 a2 b2
- data MSF (m :: Type -> Type) a b
- class (Eq a, Floating a) => VectorSpace v a | v -> a where
- zeroVector :: v
- (*^) :: a -> v -> v
- (^/) :: v -> a -> v
- negateVector :: v -> v
- (^+^) :: v -> v -> v
- (^-^) :: v -> v -> v
- dot :: v -> v -> a
- norm :: v -> a
- normalize :: v -> v
Documentation
integralFrom :: (Monad m, VectorSpace a s) => a -> SF m a a Source #
derivative :: (Monad m, VectorSpace a s) => SF m a a Source #
derivativeFrom :: (Monad m, VectorSpace a s) => a -> SF m a a Source #
lMerge :: Event a -> Event a -> Event a Source #
Left-biased event merge (always prefer left event, if present).
rMerge :: Event a -> Event a -> Event a Source #
Right-biased event merge (always prefer right event, if present).
eventToMaybe :: Event a -> Maybe a Source #
maybeToEvent :: Maybe a -> Event a Source #
boolToEvent :: Bool -> Event () Source #
notYet :: Monad m => SF m (Event a) (Event a) Source #
Suppression of initial (at local time 0) event.
now :: Monad m => b -> SF m a (Event b) Source #
Event source with a single occurrence at time 0. The value of the event is given by the function argument.
takeEvents :: Monad m => Int -> SF m (Event a) (Event a) Source #
Suppress all but the first n events.
:: MonadRandom m | |
=> Time | The time q after which the event should be produced on average |
-> b | Value to produce at time of event |
-> SF m a (Event b) |
(-->) :: Monad m => b -> SF m a b -> SF m a b Source #
Initialization operator (cf. Lustre/Lucid Synchrone).
The output at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.
(>--) :: Monad m => a -> SF m a b -> SF m a b Source #
Input initialization operator.
The input at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.
replaceOnce :: Monad m => a -> SF m a a Source #
dpSwitchB :: (Monad m, Traversable col) => col (SF m a b) -> SF m (a, col b) (Event c) -> (col (SF m a b) -> c -> SF m a (col b)) -> SF m a (col b) Source #
reactimate :: Monad m => m a -> (Bool -> m (DTime, Maybe a)) -> (Bool -> b -> m Bool) -> SF Identity a b -> m () Source #
leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d) #
Any instance of ArrowApply
can be made into an instance of
ArrowChoice
by defining left
= leftApp
.
(^<<) :: Arrow a => (c -> d) -> a b c -> a b d infixr 1 #
Postcomposition with a pure function (right-to-left variant).
(<<^) :: Arrow a => a c d -> (b -> c) -> a b d infixr 1 #
Precomposition with a pure function (right-to-left variant).
class Category a => Arrow (a :: Type -> Type -> Type) where #
The basic arrow class.
Instances should satisfy the following laws:
arr
id =id
arr
(f >>> g) =arr
f >>>arr
gfirst
(arr
f) =arr
(first
f)first
(f >>> g) =first
f >>>first
gfirst
f >>>arr
fst
=arr
fst
>>> ffirst
f >>>arr
(id
*** g) =arr
(id
*** g) >>>first
ffirst
(first
f) >>>arr
assoc
=arr
assoc
>>>first
f
where
assoc ((a,b),c) = (a,(b,c))
The other combinators have sensible default definitions, which may be overridden for efficiency.
Lift a function to an arrow.
first :: a b c -> a (b, d) (c, d) #
Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.
second :: a b c -> a (d, b) (d, c) #
A mirror image of first
.
The default definition may be overridden with a more efficient version if desired.
(***) :: a b c -> a b' c' -> a (b, b') (c, c') infixr 3 #
Split the input between the two argument arrows and combine their output. Note that this is in general not a functor.
The default definition may be overridden with a more efficient version if desired.
(&&&) :: a b c -> a b c' -> a b (c, c') infixr 3 #
Fanout: send the input to both argument arrows and combine their output.
The default definition may be overridden with a more efficient version if desired.
newtype Kleisli (m :: Type -> Type) a b #
Kleisli arrows of a monad.
Kleisli | |
|
Instances
Monad m => Arrow (Kleisli m) | Since: base-2.1 |
MonadPlus m => ArrowZero (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
MonadPlus m => ArrowPlus (Kleisli m) | Since: base-2.1 |
Monad m => ArrowChoice (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
Monad m => ArrowApply (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
MonadFix m => ArrowLoop (Kleisli m) | Beware that for many monads (those for which the Since: base-2.1 |
Defined in Control.Arrow | |
Monad m => Category (Kleisli m :: Type -> Type -> Type) | Since: base-3.0 |
class Arrow a => ArrowChoice (a :: Type -> Type -> Type) where #
Choice, for arrows that support it. This class underlies the
if
and case
constructs in arrow notation.
Instances should satisfy the following laws:
left
(arr
f) =arr
(left
f)left
(f >>> g) =left
f >>>left
gf >>>
arr
Left
=arr
Left
>>>left
fleft
f >>>arr
(id
+++ g) =arr
(id
+++ g) >>>left
fleft
(left
f) >>>arr
assocsum
=arr
assocsum
>>>left
f
where
assocsum (Left (Left x)) = Left x assocsum (Left (Right y)) = Right (Left y) assocsum (Right z) = Right (Right z)
The other combinators have sensible default definitions, which may be overridden for efficiency.
left :: a b c -> a (Either b d) (Either c d) #
Feed marked inputs through the argument arrow, passing the rest through unchanged to the output.
right :: a b c -> a (Either d b) (Either d c) #
A mirror image of left
.
The default definition may be overridden with a more efficient version if desired.
(+++) :: a b c -> a b' c' -> a (Either b b') (Either c c') infixr 2 #
Split the input between the two argument arrows, retagging and merging their outputs. Note that this is in general not a functor.
The default definition may be overridden with a more efficient version if desired.
(|||) :: a b d -> a c d -> a (Either b c) d infixr 2 #
Fanin: Split the input between the two argument arrows and merge their outputs.
The default definition may be overridden with a more efficient version if desired.
Instances
Monad m => ArrowChoice (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
ArrowChoice ((->) :: Type -> Type -> Type) | Since: base-2.1 |
class Arrow a => ArrowApply (a :: Type -> Type -> Type) where #
Some arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws:
first
(arr
(\x ->arr
(\y -> (x,y)))) >>>app
=id
first
(arr
(g >>>)) >>>app
=second
g >>>app
first
(arr
(>>> h)) >>>app
=app
>>> h
Such arrows are equivalent to monads (see ArrowMonad
).
Instances
Monad m => ArrowApply (Kleisli m) | Since: base-2.1 |
Defined in Control.Arrow | |
ArrowApply ((->) :: Type -> Type -> Type) | Since: base-2.1 |
Defined in Control.Arrow |
newtype ArrowMonad (a :: Type -> Type -> Type) b #
The ArrowApply
class is equivalent to Monad
: any monad gives rise
to a Kleisli
arrow, and any instance of ArrowApply
defines a monad.
ArrowMonad (a () b) |
Instances
class Arrow a => ArrowLoop (a :: Type -> Type -> Type) where #
The loop
operator expresses computations in which an output value
is fed back as input, although the computation occurs only once.
It underlies the rec
value recursion construct in arrow notation.
loop
should satisfy the following laws:
- extension
loop
(arr
f) =arr
(\ b ->fst
(fix
(\ (c,d) -> f (b,d))))- left tightening
loop
(first
h >>> f) = h >>>loop
f- right tightening
loop
(f >>>first
h) =loop
f >>> h- sliding
loop
(f >>>arr
(id
*** k)) =loop
(arr
(id
*** k) >>> f)- vanishing
loop
(loop
f) =loop
(arr
unassoc >>> f >>>arr
assoc)- superposing
second
(loop
f) =loop
(arr
assoc >>>second
f >>>arr
unassoc)
where
assoc ((a,b),c) = (a,(b,c)) unassoc (a,(b,c)) = ((a,b),c)
Instances
MonadFix m => ArrowLoop (Kleisli m) | Beware that for many monads (those for which the Since: base-2.1 |
Defined in Control.Arrow | |
ArrowLoop ((->) :: Type -> Type -> Type) | Since: base-2.1 |
Defined in Control.Arrow |
pauseOn :: Show a => (a -> Bool) -> String -> MSF IO a a #
Outputs every input sample, with a given message prefix, when a condition is met, and waits for some input / enter to continue.
traceWhen :: (Monad m, Show a) => (a -> Bool) -> (String -> m ()) -> String -> MSF m a a #
Outputs every input sample, with a given message prefix, using an auxiliary printing function, when a condition is met.
traceWith :: (Monad m, Show a) => (String -> m ()) -> String -> MSF m a a #
Outputs every input sample, with a given message prefix, using an auxiliary printing function.
repeatedly :: Monad m => (a -> a) -> a -> MSF m () a #
Generate outputs using a step-wise generation function and an initial
value. Version of unfold
in which the output and the new accumulator
are the same. Should be equal to f a -> unfold (f >>> dup) a
.
unfold :: Monad m => (a -> (b, a)) -> a -> MSF m () b #
Generate outputs using a step-wise generation function and an initial value.
mealy :: Monad m => (a -> s -> (b, s)) -> s -> MSF m a b #
Applies a transfer function to the input and an accumulator, returning the updated accumulator and output.
accumulateWith :: Monad m => (a -> s -> s) -> s -> MSF m a s #
Applies a function to the input and an accumulator,
outputting the updated accumulator.
Equal to f s0 -> feedback s0 $ arr (uncurry f >>> dup)
.
mappendFrom :: (Monoid n, Monad m) => n -> MSF m n n #
Accumulate the inputs, starting from an initial monoid value.
sumFrom :: (RModule v, Monad m) => v -> MSF m v v #
Sums the inputs, starting from an initial vector.
fifo :: Monad m => MSF m [a] (Maybe a) #
Buffers and returns the elements in FIFO order,
returning Nothing
whenever the buffer is empty.
next :: Monad m => b -> MSF m a b -> MSF m a b #
Preprends a fixed output to an MSF
, shifting the output.
iPost :: Monad m => b -> MSF m a b -> MSF m a b #
Preprends a fixed output to an MSF
. The first input is completely
ignored.
withSideEffect_ :: Monad m => m b -> MSF m a a #
Produces an additional side effect and passes the input unchanged.
withSideEffect :: Monad m => (a -> m b) -> MSF m a a #
Applies a function to produce an additional side effect and passes the input unchanged.
type MStream (m :: Type -> Type) a = MSF m () a #
A stream is an MSF
that produces outputs, while ignoring the input.
It can obtain the values from a monadic context.
type MSink (m :: Type -> Type) a = MSF m a () #
A sink is an MSF
that consumes inputs, while producing no output.
It can consume the values with side effects.
morphS :: (Monad m2, Monad m1) => (forall c. m1 c -> m2 c) -> MSF m1 a b -> MSF m2 a b #
Apply trans-monadic actions (in an arbitrary way).
This is just a convenience function when you have a function to move across
monads, because the signature of morphGS
is a bit complex.
liftTransS :: (MonadTrans t, Monad m, Monad (t m)) => MSF m a b -> MSF (t m) a b #
Lift inner monadic actions in monad stacks.
(>>>^) :: MonadBase m1 m2 => MSF m2 a b -> MSF m1 b c -> MSF m2 a c #
Lift the second MSF
into the monad of the first.
(^>>>) :: MonadBase m1 m2 => MSF m1 a b -> MSF m2 b c -> MSF m2 a c #
Lift the first MSF
into the monad of the second.
liftBaseS :: (Monad m2, MonadBase m1 m2) => MSF m1 a b -> MSF m2 a b #
Lift innermost monadic actions in monad stack (generalisation of
liftIO
).
liftBaseM :: (Monad m2, MonadBase m1 m2) => (a -> m1 b) -> MSF m2 a b #
Monadic lifting from one monad into another
embed :: Monad m => MSF m a b -> [a] -> m [b] #
Apply a monadic stream function to a list.
Because the result is in a monad, it may be necessary to
traverse the whole list to evaluate the value in the results to WHNF.
For example, if the monad is the maybe monad, this may not produce anything
if the MSF
produces Nothing
at any point, so the output stream cannot
consumed progressively.
To explore the output progressively, use liftMSF
and '(>>>)'', together
with some action that consumes/actuates on the output.
This is called runSF
in Liu, Cheng, Hudak, "Causal Commutative Arrows and
Their Optimization"
feedback :: Monad m => c -> MSF m (a, c) (b, c) -> MSF m a b #
Well-formed looped connection of an output component as a future input.
:: Monad m2 | |
=> (forall c. (a1 -> m1 (b1, c)) -> a2 -> m2 (b2, c)) | The natural transformation. |
-> MSF m1 a1 b1 | |
-> MSF m2 a2 b2 |
Generic lifting of a morphism to the level of MSF
s.
Natural transformation to the level of MSF
s.
Mathematical background: The type a -> m (b, c)
is a functor in c
,
and MSF m a b
is its greatest fixpoint, i.e. it is isomorphic to the type
a -> m (b, MSF m a b)
, by definition.
The types m
, a
and b
are parameters of the functor.
Taking a fixpoint is functorial itself, meaning that a morphism
(a natural transformation) of two such functors gives a morphism
(an ordinary function) of their fixpoints.
This is in a sense the most general "abstract" lifting function,
i.e. the most general one that only changes input, output and side effect
types, and doesn't influence control flow.
Other handling functions like exception handling or ListT
broadcasting
necessarily change control flow.
data MSF (m :: Type -> Type) a b #
Stepwise, side-effectful MSF
s without implicit knowledge of time.
MSF
s should be applied to streams or executed indefinitely or until they
terminate. See reactimate
and reactimateB
for details. In general,
calling the value constructor MSF
or the function unMSF
is discouraged.
class (Eq a, Floating a) => VectorSpace v a | v -> a where Source #
zeroVector, (*^), (^+^), dot
zeroVector :: v Source #
(*^) :: a -> v -> v infixr 9 Source #
(^/) :: v -> a -> v infixl 9 Source #
negateVector :: v -> v Source #
(^+^) :: v -> v -> v infixl 6 Source #
(^-^) :: v -> v -> v infixl 6 Source #
Instances
VectorSpace Double Double Source # | |
Defined in FRP.Yampa.VectorSpace zeroVector :: Double Source # (*^) :: Double -> Double -> Double Source # (^/) :: Double -> Double -> Double Source # negateVector :: Double -> Double Source # (^+^) :: Double -> Double -> Double Source # (^-^) :: Double -> Double -> Double Source # dot :: Double -> Double -> Double Source # | |
VectorSpace Float Float Source # | |
Defined in FRP.Yampa.VectorSpace | |
RealFloat a => VectorSpace (Vector3 a) a Source # | |
Defined in FRP.Yampa.Vector3 zeroVector :: Vector3 a Source # (*^) :: a -> Vector3 a -> Vector3 a Source # (^/) :: Vector3 a -> a -> Vector3 a Source # negateVector :: Vector3 a -> Vector3 a Source # (^+^) :: Vector3 a -> Vector3 a -> Vector3 a Source # (^-^) :: Vector3 a -> Vector3 a -> Vector3 a Source # dot :: Vector3 a -> Vector3 a -> a Source # | |
RealFloat a => VectorSpace (Vector2 a) a Source # | |
Defined in FRP.Yampa.Vector2 zeroVector :: Vector2 a Source # (*^) :: a -> Vector2 a -> Vector2 a Source # (^/) :: Vector2 a -> a -> Vector2 a Source # negateVector :: Vector2 a -> Vector2 a Source # (^+^) :: Vector2 a -> Vector2 a -> Vector2 a Source # (^-^) :: Vector2 a -> Vector2 a -> Vector2 a Source # dot :: Vector2 a -> Vector2 a -> a Source # | |
(Eq a, Floating a) => VectorSpace (a, a) a Source # | |
Defined in FRP.Yampa.VectorSpace | |
(Eq a, Floating a) => VectorSpace (a, a, a) a Source # | |
Defined in FRP.Yampa.VectorSpace zeroVector :: (a, a, a) Source # (*^) :: a -> (a, a, a) -> (a, a, a) Source # (^/) :: (a, a, a) -> a -> (a, a, a) Source # negateVector :: (a, a, a) -> (a, a, a) Source # (^+^) :: (a, a, a) -> (a, a, a) -> (a, a, a) Source # (^-^) :: (a, a, a) -> (a, a, a) -> (a, a, a) Source # dot :: (a, a, a) -> (a, a, a) -> a Source # | |
(Eq a, Floating a) => VectorSpace (a, a, a, a) a Source # | |
Defined in FRP.Yampa.VectorSpace zeroVector :: (a, a, a, a) Source # (*^) :: a -> (a, a, a, a) -> (a, a, a, a) Source # (^/) :: (a, a, a, a) -> a -> (a, a, a, a) Source # negateVector :: (a, a, a, a) -> (a, a, a, a) Source # (^+^) :: (a, a, a, a) -> (a, a, a, a) -> (a, a, a, a) Source # (^-^) :: (a, a, a, a) -> (a, a, a, a) -> (a, a, a, a) Source # dot :: (a, a, a, a) -> (a, a, a, a) -> a Source # | |
(Eq a, Floating a) => VectorSpace (a, a, a, a, a) a Source # | |
Defined in FRP.Yampa.VectorSpace zeroVector :: (a, a, a, a, a) Source # (*^) :: a -> (a, a, a, a, a) -> (a, a, a, a, a) Source # (^/) :: (a, a, a, a, a) -> a -> (a, a, a, a, a) Source # negateVector :: (a, a, a, a, a) -> (a, a, a, a, a) Source # (^+^) :: (a, a, a, a, a) -> (a, a, a, a, a) -> (a, a, a, a, a) Source # (^-^) :: (a, a, a, a, a) -> (a, a, a, a, a) -> (a, a, a, a, a) Source # dot :: (a, a, a, a, a) -> (a, a, a, a, a) -> a Source # |