WAGS.Validation

class GraphIsRenderable (graph :: Graph) 

Asserts that an audio graph is renderable.

Every time that makeScene is called, we assert that the graph is renderable. This means that it can be played by the WebAudio API without any runtime errors. Note that this assertion is a compile time assertion and not a runtime assertion. This means that, when your program is compiled, it is guaranteed to be renderable by the WebAudio API assuming that it is within the memory constraints of a given browser and computer. Usually, these memory limits are not hit unless one has hundreds of active nodes.

Instances

• (NoNodesAreDuplicated graph, AllEdgesPointToNodes graph, NoParallelEdges graph, HasSourceNodes graph, UniqueTerminus graph terminus, NodeIsOutputDevice terminus, AllNodesAreSaturated graph) => GraphIsRenderable graph

class TerminalNode (g :: Graph) (ptr :: Ptr) | g -> ptr

Retrieves the terminal node from an audio grpah. This is almost always a speaker or recording, but if the graph is at an intermediary stage of construction, this could be another top-level node, ie a gain node.

Instances

• (UniqueTerminus g t, GetAudioUnit t u, GetPointer u ptr) => TerminalNode g ptr

class TerminalIdentityEdge (u :: Graph) (prof :: EdgeProfile) | u -> prof

Retrieves the terminal node from an audio grpah as an edge profile - in this case, a single edge into the terminal node.

Instances

• (TerminalNode i ptr) => TerminalIdentityEdge i (SingleEdge ptr)

class LookupNL (accumulator :: NodeList) (ptr :: Ptr) (graph :: NodeList) (node :: NodeList) | accumulator ptr graph -> node

Tail recursive lookup of a node in a node list.

• accumulator: the accumulator for tail recursion that should start at NodeListNil.
• ptr: the pointer of the node we are trying retrieve.
• graph: the list of nodes to iterate over.
• node: a list of nodes that have this pointer.

Instances

• LookupNL accumulator ptr NodeListNil accumulator
• (GetAudioUnit head headAU, GetPointer headAU maybePtr, BinEq maybePtr ptr tf, Gate tf (NodeListCons head NodeListNil) NodeListNil toComp, NodeListKeepSingleton toComp accumulator acc, LookupNL acc ptr tail o) => LookupNL accumulator ptr (NodeListCons head tail) o

class NodeNotInNodeList (node :: Node) (nodeList :: NodeList) 

Assertion that node is not present in nodeList.

Instances

• NodeNotInNodeList node NodeListNil
• (GetAudioUnit node nodeAu, GetAudioUnit head headAu, AudioUnitEq nodeAu headAu False, NodeNotInNodeList node tail) => NodeNotInNodeList node (NodeListCons head tail)

class NoNodesAreDuplicatedInNodeList (nodeList :: NodeList) 

Assertion that there are no duplicate nodes in nodeList.

Instances

• NoNodesAreDuplicatedInNodeList NodeListNil
• (NodeNotInNodeList head tail, NoNodesAreDuplicatedInNodeList tail) => NoNodesAreDuplicatedInNodeList (NodeListCons head tail)

class NoNodesAreDuplicated (graph :: Graph) 

Assertion that there are no duplicate nodes in graph.

Instances

• (GraphToNodeList graph nodeList, NoNodesAreDuplicatedInNodeList nodeList) => NoNodesAreDuplicated graph

class PtrInPtrList (foundPtr :: Type) (ptr :: Ptr) (ptrList :: PtrList) (output :: Type) | foundPtr ptr ptrList -> output

Tail-recursive check that a pointer is in a pointer list.

• foundPtr: an accumulator indicating whether we've found the ptr or not. Starts as False.
• ptr: is this ptr in the pointer list?
• ptrList: a list of pointers
• output: True if the pointer is in the list, False otherwise.

Instances

• PtrInPtrList True a b True
• PtrInPtrList False a PtrListNil False
• (BinEq ptr head foundNode, PtrInPtrList foundNode ptr tail o) => PtrInPtrList False ptr (PtrListCons head tail) o

class AudioUnitInAudioUnitList (foundAU :: Type) (audioUnit :: AudioUnit) (audioUnitList :: AudioUnitList) (output :: Type) | foundAU audioUnit audioUnitList -> output

Tail-recursive check that an audio unit is in an audio unit list.

• foundPtr: an accumulator indicating whether we've found the audio unit or not. Starts as False.
• audioUnit: is this audioUnit in the audio unit list?
• audioUnitList: a list of audio units
• output: True if the audio unit is in the list, False otherwise.

Instances

• AudioUnitInAudioUnitList True a b True
• AudioUnitInAudioUnitList False a AudioUnitNil False
• (AudioUnitEq au head foundAU, AudioUnitInAudioUnitList foundAU au tail o) => AudioUnitInAudioUnitList False au (AudioUnitCons head tail) o

class AllPtrsInNodeList (pointers :: PtrList) (nodeList :: NodeList) 

Assertion that all pointers are present in a nodeList.

Instances

• AllPtrsInNodeList PtrListNil haystack
• (LookupNL NodeListNil head haystack (NodeListCons x NodeListNil), AllPtrsInNodeList tail haystack) => AllPtrsInNodeList (PtrListCons head tail) haystack

class GetEdgesAsPtrList (node :: Node) (ptrList :: PtrList) | node -> ptrList

For a given node, get all of its incoming edges as a ptrList.

Instances

• GetEdgesAsPtrList (NodeC x NoEdge) PtrListNil
• GetEdgesAsPtrList (NodeC x (SingleEdge e)) (PtrListCons e PtrListNil)
• GetEdgesAsPtrList (NodeC x (ManyEdges e l)) (PtrListCons e l)

class AllEdgesInNodeList (needles :: NodeList) (haystack :: NodeList) 

For a given set of nodes called needles, assert that all of them are present in at least one incoming edge of the nodes called haystack.

Instances

• AllEdgesInNodeList NodeListNil haystack
• (GetEdgesAsPtrList head ptrList, AllPtrsInNodeList ptrList haystack, AllEdgesInNodeList tail haystack) => AllEdgesInNodeList (NodeListCons head tail) haystack

class AllEdgesPointToNodes (graph :: Graph) 

Assertion that all edges in the graph point to a node in the graph.

Instances

• (GraphToNodeList graph nodeList, AllEdgesInNodeList nodeList nodeList) => AllEdgesPointToNodes graph

class PtrNotInPtrList (ptr :: Ptr) (ptrList :: PtrList) 

Assertion that ptr is not in ptrList.

Instances

• PtrNotInPtrList ptr PtrListNil
• (BinEq ptr head False, PtrNotInPtrList ptr tail) => PtrNotInPtrList ptr (PtrListCons head tail)

class NoPtrsAreDuplicatedInPtrList (ptrList :: PtrList) 

Assertion that not pointers are duplicated in ptrList.

Instances

• NoPtrsAreDuplicatedInPtrList PtrListNil
• (PtrNotInPtrList head tail, NoPtrsAreDuplicatedInPtrList tail) => NoPtrsAreDuplicatedInPtrList (PtrListCons head tail)

class NoParallelEdgesNL (nodeList :: NodeList) 

Assertion that nodeList contains no parallel edges. Parallel edges are two or more edges from node1 to node2 in a list of nodes.

Instances

• NoParallelEdgesNL NodeListNil
• (NoParallelEdgesNL tail) => NoParallelEdgesNL (NodeListCons (NodeC n NoEdge) tail)
• (NoParallelEdgesNL tail) => NoParallelEdgesNL (NodeListCons (NodeC n (SingleEdge e)) tail)
• (NoPtrsAreDuplicatedInPtrList (PtrListCons e l), NoParallelEdgesNL tail) => NoParallelEdgesNL (NodeListCons (NodeC n (ManyEdges e l)) tail)

class NoParallelEdges (graph :: Graph) 

Assertion that graph contains no parallel edges. Parallel edges are two or more edges from node1 to node2 in a list of nodes.

Instances

• (GraphToNodeList graph nodeList, NoParallelEdgesNL nodeList) => NoParallelEdges graph

class SourceNodesNL (accumulator :: NodeList) (nodeList :: NodeList) (output :: NodeList) | accumulator nodeList -> output

Tail-recursive lookup of all nodes in a graph without incoming edges.

• accumulator is the accumulator that will be returned.
• nodeList is the list of nodes that will be searched over.
• output contains all nodes without incoming edges.

Instances

• SourceNodesNL accumulator NodeListNil accumulator
• (SourceNodesNL (NodeListCons (NodeC i NoEdge) accumulator) tail o) => SourceNodesNL accumulator (NodeListCons (NodeC i NoEdge) tail) o
• (SourceNodesNL accumulator tail o) => SourceNodesNL accumulator (NodeListCons (NodeC i (SingleEdge x)) tail) o
• (SourceNodesNL accumulator tail o) => SourceNodesNL accumulator (NodeListCons (NodeC i (ManyEdges x l)) tail) o

class SourceNodes (graph :: Graph) (nodeList :: NodeList) | graph -> nodeList

Lookup of all nodes in graph without incoming edges and return them as nodeList.

Instances

• (GraphToNodeList graph nodeList, SourceNodesNL NodeListNil nodeList sourceNodes) => SourceNodes graph sourceNodes

class HasSourceNodes (graph :: Graph) 

Assertion that a graph has source nodes. Source nodes are nodes without incoming edges.

Instances

• (SourceNodes graph (NodeListCons a b)) => HasSourceNodes graph

class AudioUnitInNodeList (foundNode :: Type) (audioUnit :: AudioUnit) (nodeList :: NodeList) (output :: Type) | foundNode audioUnit nodeList -> output

Tail-recursive lookup of audio unit in node list.

• foundNode: an accumulator indicating whether we've found the node or not. Starts as False.
• audioUnit: is this audioUnit in the node list?
• nodeList: a list of nodes
• output: True if the audio unit is in the list, False otherwise.

Instances

• AudioUnitInNodeList True a b True
• AudioUnitInNodeList False a NodeListNil False
• (GetAudioUnit head headAu, AudioUnitEq au headAu foundNode, AudioUnitInNodeList foundNode au tail o) => AudioUnitInNodeList False au (NodeListCons head tail) o

class RemoveDuplicates (accumulator :: NodeList) (maybeWithDuplicates :: NodeList) (output :: NodeList) | accumulator maybeWithDuplicates -> output

Tail-recursive removal of duplicate nodes from a node list.

• accumulator: the accumulating deduped list. Starts at NodeListNil.
• maybeWithDuplicates: a node list that potentially has duplicates.
• output: the final deduped list

Instances

• RemoveDuplicates accumulator NodeListNil accumulator
• (GetAudioUnit head au, AudioUnitInNodeList False au accumulator tf, Gate tf accumulator (NodeListCons head accumulator) acc, RemoveDuplicates acc tail o) => RemoveDuplicates accumulator (NodeListCons head tail) o

class NodeInNodeList (foundNode :: Type) (node :: Node) (nodeList :: NodeList) (output :: Type) | foundNode node nodeList -> output

Tail-recursive lookup of node in a node list.

• foundNode: an accumulator indicating whether we've found the node or not. Starts as False.
• node: is this node in the node list?
• nodeList: a list of nodes
• output: True if the node is in the list, False otherwise.

Instances

• NodeInNodeList True a b True
• NodeInNodeList False a NodeListNil False
• (GetAudioUnit head headAu, GetAudioUnit node nodeAu, AudioUnitEq nodeAu headAu foundNode, NodeInNodeList foundNode node tail o) => NodeInNodeList False node (NodeListCons head tail) o

class UnvisitedNodes (visited :: NodeList) (accumulator :: NodeList) (candidates :: NodeList) (unvisited :: NodeList) | visited accumulator candidates -> unvisited

Tail-recursive algorithm to find nodes we have not visited yet.

• visited nodes that we have visited
• accumulator accumulates unvisited nodes
• candidates are nodes that have potentially not been visited yet and will be cross-referenced against visited.
• unvisited is a list of unvisited nodes.

Instances

• UnvisitedNodes visited accumulator NodeListNil accumulator
• (NodeInNodeList False head visited tf, Gate tf accumulator (NodeListCons head accumulator) acc, UnvisitedNodes visited acc tail o) => UnvisitedNodes visited accumulator (NodeListCons head tail) o

class ToVisitSingle (accumulator :: NodeList) (graph :: NodeList) (findMeInAnEdge :: Node) (candidates :: NodeList) | accumulator graph findMeInAnEdge -> candidates

In the node-visiting algorithm, this is a single step where we look for a node in a given list of edges. This step is repeated until all of the nodes have been visited.

• accumulator - the running accumulator of nodes we are visiting
• graph - the entire graph. if we were using an env comonad, this would be the environment
• findMeInAnEdge - this is the node we want to find in edges
• candidates - these are all of the nodes that have findMeInAnEdge as an incoming connection

Instances

• ToVisitSingle accumulator NodeListNil findMeInAnEdge accumulator
• (GetEdgesAsPtrList head edgeList, GetAudioUnit findMeInAnEdge au, GetPointer au ptr, PtrInPtrList False ptr edgeList tf, Gate tf (NodeListCons head accumulator) accumulator acc, ToVisitSingle acc tail findMeInAnEdge o) => ToVisitSingle accumulator (NodeListCons head tail) findMeInAnEdge o

class NodeListAppend (l :: NodeList) (r :: NodeList) (o :: NodeList) | l r -> o

This appends node list l and r to produce the result o.

Instances

• NodeListAppend NodeListNil NodeListNil NodeListNil
• NodeListAppend NodeListNil (NodeListCons x y) (NodeListCons x y)
• NodeListAppend (NodeListCons x y) NodeListNil (NodeListCons x y)
• (NodeListAppend b (NodeListCons c d) o) => NodeListAppend (NodeListCons a b) (NodeListCons c d) (NodeListCons a o)

class PtrListAppend (l :: PtrList) (r :: PtrList) (o :: PtrList) | l r -> o

This appends pointer list l and r to produce the result o.

Instances

• PtrListAppend PtrListNil PtrListNil PtrListNil
• PtrListAppend PtrListNil (PtrListCons x y) (PtrListCons x y)
• PtrListAppend (PtrListCons x y) PtrListNil (PtrListCons x y)
• (PtrListAppend b (PtrListCons c d) o) => PtrListAppend (PtrListCons a b) (PtrListCons c d) (PtrListCons a o)

class AltEdgeProfile (a :: EdgeProfile) (b :: EdgeProfile) (c :: EdgeProfile) | a b -> c

This is the equivalent of Alt for edge profiles. NoEdge always loses.

Instances

• AltEdgeProfile NoEdge b b
• AltEdgeProfile a NoEdge a

class IsNodeListEmpty (nodeList :: NodeList) (tf :: Type) | nodeList -> tf

Asks is nodeList empty and replies with True or False as tf.

Instances

• IsNodeListEmpty NodeListNil True
• IsNodeListEmpty (NodeListCons a b) False

class ToVisit (candidatesAccumulator :: NodeList) (parentlessAccumulator :: NodeList) (graph :: NodeList) (findMeInAnEdge :: NodeList) (candidates :: NodeList) (parentless :: NodeList) | candidatesAccumulator parentlessAccumulator graph findMeInAnEdge -> candidates parentless

In the visiting algorithm, obtains a list of nodes to visit as well as parentless or "sink" nodes.

• candidatesAccumulator an accumulator of candidates to visit
• parentlessAccumulator an accumulator of parentless or "sink" nodes
• graph - the entire graph. if we were using an env comonad, this would be the environment
• findMeInAnEdge - a list of nodes remaining to find in edges. This starts as the whole graph and whittles down to no nodes as the algorithm runs.
• candidates return value of candidates for the next step
• parentless return value of parentless nodes in the graph

Instances

• ToVisit candidatesAccumulator parentlessAccumulator graph NodeListNil candidatesAccumulator parentlessAccumulator
• (ToVisitSingle NodeListNil graph findMeInAnEdge o, IsNodeListEmpty o tf, Gate tf (NodeListCons findMeInAnEdge parentlessAccumulator) parentlessAccumulator pA, NodeListAppend candidatesAccumulator o cA, ToVisit cA pA graph tail ccA ppA) => ToVisit candidatesAccumulator parentlessAccumulator graph (NodeListCons findMeInAnEdge tail) ccA ppA

class TerminusLoop (graph :: NodeList) (visited :: NodeList) (visiting :: NodeList) (accumulator :: NodeList) (output :: NodeList) | graph visited visiting accumulator -> output

The algorithm that finds the terminal nodes of a graph.

• graph - the entire graph. if we were using an env comonad, this would be the environment
• visited - nodes we have visited so far in the aglorithm
• visiting - nodes we are currently visiting in the aglorithm
• accumulator - accumulator for tail-recursion that builds output
• output - terminal nodes of the graph

Instances

• TerminusLoop graph visited NodeListNil accumulator accumulator
• (ToVisit NodeListNil NodeListNil graph (NodeListCons a b) candidatesDup parentless, RemoveDuplicates NodeListNil candidatesDup candidates, UnvisitedNodes visited NodeListNil candidates unvisited, NodeListAppend unvisited visited newVisited, NodeListAppend accumulator parentless newAccumulator, TerminusLoop graph newVisited unvisited newAccumulator o) => TerminusLoop graph visited (NodeListCons a b) accumulator o

class UniqueTerminus (graph :: Graph) (node :: Node) | graph -> node

Assertion that graph has the unique terminus node. Note that, due to the fundep, the assertion also finds the unique terminus if it exists.

Instances

• (SourceNodes graph source, GraphToNodeList graph graphAsNodeList, TerminusLoop graphAsNodeList NodeListNil source NodeListNil terminii, RemoveDuplicates NodeListNil terminii (NodeListCons node NodeListNil)) => UniqueTerminus graph node

class HasUniqueTerminus (graph :: Graph) 

Assertion that graph has a unique terminus.

Instances

• (UniqueTerminus graph node) => HasUniqueTerminus graph

class AllNodesAreSaturatedNL (graph :: NodeList) 

Asserts that all nodes in graph are saturated. "Saturation" for audio nodes is similar to the concept of saturation in types, namely that they have all the information necessary to render. In doing so, it also fails the assertion on degenerate nodes, ie sine-wave oscillators with input (which wouldn't make sense).

Instances

• AllNodesAreSaturatedNL NodeListNil
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TAllpass a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TBandpass a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TConstant a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TConvolver a name) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TDelay a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TDynamicsCompressor a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TGain a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TGain a) (ManyEdges e l)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (THighpass a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (THighshelf a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TLoopBuf a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TLowpass a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TLowshelf a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TMicrophone a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TNotch a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TPeaking a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TPeriodicOsc a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TPlayBuf a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TRecorder a name) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TSawtoothOsc a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TSinOsc a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TSpeaker a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TSpeaker a) (ManyEdges e l)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TSquareOsc a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TStereoPanner a) (SingleEdge e)) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TTriangleOsc a) NoEdge) tail)
• (AllNodesAreSaturatedNL tail) => AllNodesAreSaturatedNL (NodeListCons (NodeC (TWaveShaper a name) (SingleEdge e)) tail)

class AllNodesAreSaturated (graph :: Graph) 

Asserts that all nodes in graph are saturated. This is the same as the node-list algorithm, but for a graph.

Instances

• (GraphToNodeList graph nodeList, AllNodesAreSaturatedNL nodeList) => AllNodesAreSaturated graph

class NodeIsOutputDevice (node :: Node) 

Asserts the node is an output device. Currently, in the web-audio API, this is a loudspeaker or recorder.

Instances

• NodeIsOutputDevice (NodeC (TSpeaker a) x)
• NodeIsOutputDevice (NodeC (TRecorder a name) x)