Yoga.Om.Layer

data OmLayer :: Row Type -> Row Type -> Type -> Typedata OmLayer req err a

A layer that requires dependencies (req), may fail with (err), and produces a value (typically Record prov). Each layer has a unique identity used for automatic memoization within a Scope.

Instances

• Functor (OmLayer req err)
• Apply (OmLayer req err)
• Applicative (OmLayer req err)
• Bind (OmLayer req err)
• Monad (OmLayer req err)
• Parallel (ParOmLayer req err) (OmLayer req err)
• (RowToList req reqRL, AllLabelsIn reqRL available isReady, FindReadyDispatch isReady sym (OmLayer req err (Record prov)) tail available allLayersRL foundSym foundLayer rest) => FindReady (Cons sym (OmLayer req err (Record prov)) tail) available allLayersRL foundSym foundLayer rest
• (RowToList prov provRL, HasLabel label provRL hasIt, FindProviderMatch hasIt label sym (Cons sym (OmLayer req err (Record prov)) tail) provider) => FindProvider label (Cons sym (OmLayer req err (Record prov)) tail) provider
• (RowToList req reqRL, FilterScope reqRL filteredReqRL, EmitEdges sym filteredReqRL allLayers edgeDoc, PrintEdgesRL tail allLayers restDoc) => PrintEdgesRL (Cons sym (OmLayer req err (Record prov)) tail) allLayers (Above edgeDoc restDoc)
• (RowToList req reqRL) => FindLayerReqs sym (Cons sym (OmLayer req err (Record prov)) tail) reqRL
• (RowToList req reqRL, FilterScope reqRL filteredReqRL, RowToList prov provRL, FirstProvLabel provRL displayName, HasDirectMissing filteredReqRL allLayers hasMissing, PrintLayerDispatch hasMissing displayName filteredReqRL tail allLayers doc) => PrintEdgesASCII (Cons sym (OmLayer req err (Record prov)) tail) allLayers doc

data ParOmLayer :: Row Type -> Row Type -> Type -> Typedata ParOmLayer req err a

Instances

• Functor (ParOmLayer req err)
• Apply (ParOmLayer req err)
• Applicative (ParOmLayer req err)
• Parallel (ParOmLayer req err) (OmLayer req err)

newtype Scope

A first-class representation of resource lifetime and memoization. Finalizers are registered via acquireRelease and run in reverse order when the scope is closed. Layers are automatically memoized by identity within a scope — the same layer value builds only once.

Instances

• FilterScope (Cons "scope" Scope tail) tail

makeLayer :: forall req err a. Om (Record req) err a -> OmLayer req err a

Create a layer from an Om computation. The layer is automatically memoized within a Scope — the same layer value used in multiple branches of a dependency graph builds only once.

makeScopedLayer :: forall req prov err. Om { scope :: Scope | req } err (Record prov) -> (Record prov -> Aff Unit) -> OmLayer (scope :: Scope | req) err (Record prov)

Create a scoped layer with acquire/release semantics. The release function runs when the enclosing scope closes. The layer requires scope :: Scope in its context.

bracketLayer :: forall req prov resource err. Om { scope :: Scope | req } err resource -> (resource -> Aff Unit) -> (resource -> Om { scope :: Scope | req } err (Record prov)) -> OmLayer (scope :: Scope | req) err (Record prov)

Bracket-style scoped layer: acquire a resource, register its release, then build provisions from it.

acquireRelease :: forall ctx err a. Om { scope :: Scope | ctx } err a -> (a -> Aff Unit) -> Om { scope :: Scope | ctx } err a

Acquire a resource and register its release with the current scope. This is the core scoped resource primitive — the PureScript equivalent of ZIO's ZIO.acquireRelease.

fresh :: forall req err a. OmLayer req err a -> OmLayer req err a

Create a fresh (non-memoized) copy of a layer. The new layer has a unique identity and will always build independently, even within the same scope.

runLayer :: forall req err a available. CheckAllProvided req available => Record available -> OmLayer req err a -> Om (Record available) err a

Run a layer with a given context, with custom error if requirements aren't met.

runScoped :: forall prov. OmLayer (scope :: Scope) () (Record prov) -> Aff (Record prov)

Build a fully-provided scoped layer, return the provisions. All finalizers run after the provisions are returned. For layers with typed errors, use runScopedWith.

runScopedWith :: forall prov r rl err_ err. RowToList (exception :: Error -> Aff (Record prov) | r) rl => VariantMatchCases rl err_ (Aff (Record prov)) => Union err_ () (exception :: Error | err) => { exception :: Error -> Aff (Record prov) | r } -> OmLayer (scope :: Scope) err (Record prov) -> Aff (Record prov)

Like runScoped but accepts error handlers for layers with typed errors.

withScoped :: forall prov a. OmLayer (scope :: Scope) () (Record prov) -> (Record prov -> Aff a) -> Aff a

Build a fully-provided scoped layer and pass the provisions to a callback. A fresh Scope is created and closed when the callback completes, running all finalizers in reverse order — whether by success, failure, or interruption. For layers with typed errors, use withScopedWith.

withScopedWith :: forall prov a r rl err_ err. RowToList (exception :: Error -> Aff (Record prov) | r) rl => VariantMatchCases rl err_ (Aff (Record prov)) => Union err_ () (exception :: Error | err) => { exception :: Error -> Aff (Record prov) | r } -> OmLayer (scope :: Scope) err (Record prov) -> (Record prov -> Aff a) -> Aff a

Like withScoped but accepts error handlers for layers with typed errors.

scoped :: forall prov a r rl err_ err. RowToList (exception :: Error -> Aff (Record prov) | r) rl => VariantMatchCases rl err_ (Aff (Record prov)) => Union err_ () (exception :: Error | err) => { exception :: Error -> Aff (Record prov) | r } -> OmLayer (scope :: Scope) err (Record prov) -> (Record prov -> Aff a) -> Aff a

combineRequirements :: forall req1 req2 prov1 prov2 err1 err2 provMerged reqMerged reqDeduped errMerged errDeduped _req1 _req2 _err1 _err2. Union req1 req2 reqMerged => Nub reqMerged reqDeduped => Union req1 _req1 reqDeduped => Union req2 _req2 reqDeduped => Union err1 err2 errMerged => Nub errMerged errDeduped => Union err1 _err1 errDeduped => Union err2 _err2 errDeduped => Union prov1 prov2 provMerged => Nub provMerged provMerged => Keys req1 => Keys req2 => OmLayer req1 err1 (Record prov1) -> OmLayer req2 err2 (Record prov2) -> OmLayer reqDeduped errDeduped (Record provMerged)

provide :: forall req prov1 prov2 err1 err2 req2 reqOut errMerged errDeduped _req _prov1 _err1 _err2. Union req _req req => Union prov1 _prov1 prov1 => Union err1 err2 errMerged => Nub errMerged errDeduped => Union err1 _err1 errDeduped => Union err2 _err2 errDeduped => Union prov1 req reqOut => Nub reqOut reqOut => Union req2 _prov1 reqOut => Keys req => Keys prov1 => Keys req2 => OmLayer req2 err2 (Record prov2) -> OmLayer req err1 (Record prov1) -> OmLayer req errDeduped (Record prov2)

Operator alias for Yoga.Om.Layer.provide (left-associative / precedence 9)

recovering :: forall req err rest a (handlersRL :: RowList Type) (handlers :: Row Type) (handled :: Row Type). RowToList handlers handlersRL => VariantMatchCases handlersRL handled (Om (Record req) err Boolean) => Union handled rest (exception :: Error | err) => RetryPolicyM (Om (Record req) err) -> (RetryStatus -> Record handlers) -> OmLayer req err a -> OmLayer req err a

repeating :: forall req err a. RetryPolicyM (Om (Record req) err) -> (RetryStatus -> a -> Om (Record req) err Boolean) -> OmLayer req err a -> OmLayer req err a

wireLayers :: forall layers rl req err prov. RowToList layers rl => TopoWire rl layers (scope :: Scope) () () req err prov => Record layers -> OmLayer req err (Record prov)

wireLayersDebug :: forall layers rl req err prov doc. RowToList layers rl => PrintLayersRL rl doc => Warn (Above (Text "") (Above (Text "%%{init: {\"flowchart\": {\"defaultRenderer\": \"elk\"}} }%%") (Above (Text "flowchart LR") doc))) => TopoWire rl layers (scope :: Scope) () () req err prov => Record layers -> OmLayer req err (Record prov)

class FilterScope :: RowList Type -> RowList Type -> Constraintclass FilterScope (rl :: RowList Type) (out :: RowList Type) | rl -> out

Remove scope :: Scope from a RowList (it's always present, just noise).

Instances

• FilterScope Nil Nil
• FilterScope (Cons "scope" Scope tail) tail
• (FilterScope tail out) => FilterScope (Cons sym ty tail) (Cons sym ty out)

class FindProvider :: Symbol -> RowList Type -> Symbol -> Constraintclass FindProvider (label :: Symbol) (rl :: RowList Type) (provider :: Symbol) | label rl -> provider

Given a label, find which layer in the RowList provides it.

Instances

• FindProvider label Nil NotProvided
• (RowToList prov provRL, HasLabel label provRL hasIt, FindProviderMatch hasIt label sym (Cons sym (OmLayer req err (Record prov)) tail) provider) => FindProvider label (Cons sym (OmLayer req err (Record prov)) tail) provider

class FindProviderMatch :: Boolean -> Symbol -> Symbol -> RowList Type -> Symbol -> Constraintclass FindProviderMatch (hasIt :: Boolean) (label :: Symbol) (sym :: Symbol) (rl :: RowList Type) (provider :: Symbol) | hasIt label sym rl -> provider

Dispatch based on whether the current layer has the label.

Instances

• FindProviderMatch True label sym rl sym
• (FindProvider label tail provider) => FindProviderMatch False label sym (Cons sym ty tail) provider

class HasLabel :: Symbol -> RowList Type -> Boolean -> Constraintclass HasLabel (label :: Symbol) (rl :: RowList Type) (result :: Boolean) | label rl -> result

Check if a RowList contains a given label.

Instances

• HasLabel label Nil False
• HasLabel label (Cons label ty tail) True
• (HasLabel label tail result) => HasLabel label (Cons sym ty tail) result

class EmitEdges :: Symbol -> RowList Type -> RowList Type -> Doc -> Constraintclass EmitEdges (consumer :: Symbol) (reqRL :: RowList Type) (allLayers :: RowList Type) (doc :: Doc) | consumer reqRL allLayers -> doc

Emit D2 edges for one consumer: "provider -> consumer" per requirement.

Instances

• EmitEdges consumer Nil allLayers (Text "")
• (FindProvider label allLayers provider, Append " " provider s0, Append s0 " --> " s1, Append s1 consumer line, EmitEdges consumer tail allLayers restDoc) => EmitEdges consumer (Cons label ty tail) allLayers (Above (Text line) restDoc)

class DashesFor :: Symbol -> Symbol -> Constraintclass DashesFor (sym :: Symbol) (dashes :: Symbol) | sym -> dashes

Map a symbol to same-length dashes (for box borders).

Instances

• DashesFor "" ""
• (Cons head tail sym, DashesFor tail rest, Append "─" rest dashes) => DashesFor sym dashes

class BoxTop :: Symbol -> Symbol -> Constraintclass BoxTop (sym :: Symbol) (result :: Symbol) | sym -> result

Build box parts from a symbol.

Instances

• (DashesFor sym dashes, Append "╭─" dashes s0, Append s0 "─╮" result) => BoxTop sym result

class BoxMid :: Symbol -> Symbol -> Constraintclass BoxMid (sym :: Symbol) (result :: Symbol) | sym -> result

Instances

• (Append "│ " sym s0, Append s0 " │" result) => BoxMid sym result

class BoxBot :: Symbol -> Symbol -> Constraintclass BoxBot (sym :: Symbol) (result :: Symbol) | sym -> result

Instances

• (DashesFor sym dashes, Append "╰─" dashes s0, Append s0 "─╯" result) => BoxBot sym result

class RenderDepChildNode :: Boolean -> Symbol -> Symbol -> Type -> Symbol -> Symbol -> Symbol -> RowList Type -> Doc -> Constraintclass RenderDepChildNode (isNotProvided :: Boolean) (provider :: Symbol) (label :: Symbol) (ty :: Type) (prePrefix :: Symbol) (contPrefix :: Symbol) (branchPrefix :: Symbol) (allLayers :: RowList Type) (doc :: Doc) | isNotProvided provider label ty prePrefix contPrefix branchPrefix allLayers -> doc

Render a single dependency child node (dispatches on provided vs missing).

Instances

• (BoxTop label topLine, BoxMid label midLine, BoxBot label botLine, Append prePrefix topLine topFull, Append branchPrefix midLine midFull, Append contPrefix botLine botFull) => RenderDepChildNode True provider label ty prePrefix contPrefix branchPrefix allLayers (Above (Text topFull) (Above (Beside (Text midFull) (Beside (Text " :: ") (Beside (Quote ty) (Text " <-- ⚠\x00fe0f not provided")))) (Text botFull)))
• (BoxTop label topLine, BoxMid label midLine, BoxBot label botLine, Append prePrefix topLine topFull, Append branchPrefix midLine midFull, Append contPrefix botLine botFull, Append contPrefix " " subTreePrefix, RenderProviderDeps provider subTreePrefix allLayers subDoc) => RenderDepChildNode False provider label ty prePrefix contPrefix branchPrefix allLayers (Above (Text topFull) (Above (Text midFull) (Above (Text botFull) subDoc)))

class IsNotProvided :: Symbol -> Boolean -> Constraintclass IsNotProvided (provider :: Symbol) (result :: Boolean) | provider -> result

Is this provider the NotProvided marker?

Instances

• IsNotProvided NotProvided True
• IsNotProvided other False

class HasDirectMissing :: RowList Type -> RowList Type -> Boolean -> Constraintclass HasDirectMissing (reqRL :: RowList Type) (allLayers :: RowList Type) (result :: Boolean) | reqRL allLayers -> result

Does any requirement in this RowList resolve to NotProvided?

Instances

• HasDirectMissing Nil allLayers False
• (FindProvider label allLayers provider, IsNotProvided provider isMissing, HasDirectMissingOr isMissing tail allLayers result) => HasDirectMissing (Cons label ty tail) allLayers result

class HasDirectMissingOr :: Boolean -> RowList Type -> RowList Type -> Boolean -> Constraintclass HasDirectMissingOr (found :: Boolean) (tail :: RowList Type) (allLayers :: RowList Type) (result :: Boolean) | found tail allLayers -> result

Instances

• HasDirectMissingOr True tail allLayers True
• (HasDirectMissing tail allLayers result) => HasDirectMissingOr False tail allLayers result

class FindLayerReqs :: Symbol -> RowList Type -> RowList Type -> Constraintclass FindLayerReqs (sym :: Symbol) (allLayers :: RowList Type) (reqRL :: RowList Type) | sym allLayers -> reqRL

Look up a layer's requirements by name.

Instances

• (RowToList req reqRL) => FindLayerReqs sym (Cons sym (OmLayer req err (Record prov)) tail) reqRL
• (FindLayerReqs sym tail reqRL) => FindLayerReqs sym (Cons other otherLayer tail) reqRL

class RenderProviderDeps :: Symbol -> Symbol -> RowList Type -> Doc -> Constraintclass RenderProviderDeps (provider :: Symbol) (prefix :: Symbol) (allLayers :: RowList Type) (doc :: Doc) | provider prefix allLayers -> doc

Render a provider's sub-tree (stops at NotProvided or roots).

Instances

• RenderProviderDeps NotProvided prefix allLayers (Text "")
• (FindLayerReqs provider allLayers reqRL, FilterScope reqRL filteredReqRL, RenderDepTree prefix filteredReqRL allLayers doc) => RenderProviderDeps provider prefix allLayers doc

class RenderDepTree :: Symbol -> RowList Type -> RowList Type -> Doc -> Constraintclass RenderDepTree (prefix :: Symbol) (reqRL :: RowList Type) (allLayers :: RowList Type) (doc :: Doc) | prefix reqRL allLayers -> doc

Render a dependency tree with tree connectors.

Instances

• RenderDepTree prefix Nil allLayers (Text "")
• (FindProvider label allLayers provider, IsNotProvided provider isNP, Append prefix "│ " prePrefix, Append prefix " " contPrefix, Append prefix "└───" branchPrefix, RenderDepChildNode isNP provider label ty prePrefix contPrefix branchPrefix allLayers doc) => RenderDepTree prefix (Cons label ty Nil) allLayers doc
• (FindProvider label allLayers provider, IsNotProvided provider isNP, Append prefix "│ " contPrefix, Append prefix "├───" branchPrefix, RenderDepChildNode isNP provider label ty contPrefix contPrefix branchPrefix allLayers childDoc, RenderDepTree prefix tail allLayers restDoc) => RenderDepTree prefix (Cons label ty tail) allLayers (Above childDoc restDoc)

class FirstProvLabel :: RowList Type -> Symbol -> Constraintclass FirstProvLabel (rl :: RowList Type) (label :: Symbol) | rl -> label

Extract the first label from a RowList.

Instances

• FirstProvLabel (Cons label ty tail) label

class PrintLayerDispatch :: Boolean -> Symbol -> RowList Type -> RowList Type -> RowList Type -> Doc -> Constraintclass PrintLayerDispatch (show :: Boolean) (displayName :: Symbol) (filteredReqRL :: RowList Type) (tail :: RowList Type) (allLayers :: RowList Type) (doc :: Doc) | show displayName filteredReqRL tail allLayers -> doc

Dispatch: skip layers without missing deps, render tree for others.

Instances

• (PrintEdgesASCII tail allLayers doc) => PrintLayerDispatch False displayName filteredReqRL tail allLayers doc
• (BoxTop displayName topLine, BoxMid displayName midLine, BoxBot displayName botLine, RenderDepTree " " filteredReqRL allLayers treeDoc, PrintEdgesASCII tail allLayers restDoc) => PrintLayerDispatch True displayName filteredReqRL tail allLayers (Above (Text topLine) (Above (Text midLine) (Above (Text botLine) (Above treeDoc (Above (Text "") restDoc)))))

class PrintLayersRL :: RowList Type -> Doc -> Constraintclass PrintLayersRL (rl :: RowList Type) (doc :: Doc) | rl -> doc

Walk all layers emitting D2 edges (mermaid format for wireLayersDebug).

Instances

• PrintLayersRL Nil (Text "")
• (PrintEdgesRL rl rl doc) => PrintLayersRL rl doc

class PrintEdgesRL :: RowList Type -> RowList Type -> Doc -> Constraintclass PrintEdgesRL (rl :: RowList Type) (allLayers :: RowList Type) (doc :: Doc) | rl allLayers -> doc

Instances

• PrintEdgesRL Nil allLayers (Text "")
• (RowToList req reqRL, FilterScope reqRL filteredReqRL, EmitEdges sym filteredReqRL allLayers edgeDoc, PrintEdgesRL tail allLayers restDoc) => PrintEdgesRL (Cons sym (OmLayer req err (Record prov)) tail) allLayers (Above edgeDoc restDoc)

class PrintLayersASCII :: RowList Type -> Doc -> Constraintclass PrintLayersASCII (rl :: RowList Type) (doc :: Doc) | rl -> doc

Walk all layers emitting ASCII dependency trees (for error messages).

Instances

• PrintLayersASCII Nil (Text "")
• (PrintEdgesASCII rl rl doc) => PrintLayersASCII rl doc

class PrintEdgesASCII :: RowList Type -> RowList Type -> Doc -> Constraintclass PrintEdgesASCII (rl :: RowList Type) (allLayers :: RowList Type) (doc :: Doc) | rl allLayers -> doc

Instances

• PrintEdgesASCII Nil allLayers (Text "")
• (RowToList req reqRL, FilterScope reqRL filteredReqRL, RowToList prov provRL, FirstProvLabel provRL displayName, HasDirectMissing filteredReqRL allLayers hasMissing, PrintLayerDispatch hasMissing displayName filteredReqRL tail allLayers doc) => PrintEdgesASCII (Cons sym (OmLayer req err (Record prov)) tail) allLayers doc

type NotProvided :: Symboltype NotProvided = "???"

Marker symbol for unresolved dependencies.

Instances

• FindProvider label Nil NotProvided
• IsNotProvided NotProvided True
• RenderProviderDeps NotProvided prefix allLayers (Text "")

class CheckAllProvided :: Row Type -> Row Type -> Constraintclass CheckAllProvided (required :: Row Type) (available :: Row Type) 

Check if all required dependencies are provided.

Instances

• (RowToList required reqList, RowToList available availList, CheckAllLabelsExist reqList availList required available) => CheckAllProvided required available

class CheckAllLabelsExist :: RowList Type -> RowList Type -> Row Type -> Row Type -> Constraintclass CheckAllLabelsExist (required :: RowList Type) (available :: RowList Type) (requiredRow :: Row Type) (availableRow :: Row Type) 

Check that all labels in required RowList exist in available RowList.

Instances

• CheckAllLabelsExist Nil available requiredRow availableRow
• (CheckLabelExists label ty available requiredRow availableRow, CheckAllLabelsExist tail available requiredRow availableRow) => CheckAllLabelsExist (Cons label ty tail) available requiredRow availableRow

class CheckLabelExists :: Symbol -> Type -> RowList Type -> Row Type -> Row Type -> Constraintclass CheckLabelExists (label :: Symbol) (ty :: Type) (available :: RowList Type) (requiredRow :: Row Type) (availableRow :: Row Type) 

Check if a single label exists in the available RowList.

Instances

• (TypeEquals ty ty') => CheckLabelExists label ty (Cons label ty' tail) requiredRow availableRow
• (CheckLabelExists label ty tail requiredRow availableRow) => CheckLabelExists label ty (Cons otherLabel otherTy tail) requiredRow availableRow
• (Fail (Above (Text "Missing required dependency!") (Above (Text "") (Above (Text "The first missing field is: ") (Above (Quote label) (Above (Text "") (Above (Text "The layer requires: ") (Above (Quote requiredRow) (Above (Text "") (Above (Text "But you provided: ") (Quote availableRow))))))))))) => CheckLabelExists label ty Nil requiredRow availableRow

class TopoWire :: RowList Type -> Row Type -> Row Type -> Row Type -> Row Type -> Row Type -> Row Type -> Row Type -> Constraintclass TopoWire (remaining :: RowList Type) (layers :: Row Type) (accReq :: Row Type) (accErr :: Row Type) (accProv :: Row Type) (resReq :: Row Type) (resErr :: Row Type) (resProv :: Row Type) | remaining layers accReq accErr accProv -> resReq resErr resProv where

Topologically sort and wire layers. Each iteration finds a layer whose dependencies are already satisfied, processes it, and adds its provisions.

Members

• topoWire :: Proxy remaining -> Record layers -> OmLayer accReq accErr (Record accProv) -> OmLayer resReq resErr (Record resProv)

Instances

• TopoWire Nil layers accReq accErr accProv accReq accErr accProv
• (RowToList layers allLayersRL, RowToList accProv accProvRL, RowToList accReq accReqRL, RowListAppend accProvRL accReqRL availableRL, FindReady remaining availableRL allLayersRL readySym (OmLayer nextReq nextErr (Record nextProv)) rest, IsSymbol readySym, Cons readySym (OmLayer nextReq nextErr (Record nextProv)) _rest layers, Union accProv accReq provReqOut, Nub provReqOut provReqOut, Union nextReq _nextReqRest provReqOut, Keys nextReq, Keys accReq, Keys accProv, Union accErr nextErr errMergedRaw, Nub errMergedRaw errMerged, Union accErr _e1 errMerged, Union nextErr _e2 errMerged, Union accProv nextProv provMerged, Nub provMerged provMerged, TopoWire rest layers accReq errMerged provMerged resReq resErr resProv) => TopoWire remaining layers accReq accErr accProv resReq resErr resProv

class AllLabelsIn :: RowList Type -> RowList Type -> Boolean -> Constraintclass AllLabelsIn (needles :: RowList Type) (haystack :: RowList Type) (result :: Boolean) | needles haystack -> result

Check if ALL labels in needles exist in haystack, returning a Boolean.

Instances

• AllLabelsIn Nil haystack True
• (HasLabel label haystack found, AllLabelsIn tail haystack tailResult, And found tailResult result) => AllLabelsIn (Cons label ty tail) haystack result

class FindReady :: RowList Type -> RowList Type -> RowList Type -> Symbol -> Type -> RowList Type -> Constraintclass FindReady (candidates :: RowList Type) (available :: RowList Type) (allLayersRL :: RowList Type) (sym :: Symbol) (layer :: Type) (rest :: RowList Type) | candidates available allLayersRL -> sym layer rest

Scan candidates for the first layer whose requirements are satisfied.

Instances

• (PrintLayersASCII allLayersRL graphDoc, Fail (Above (Text "") (Above (Text "Dependency not provided!") (Above (Text "") (Above (Text "No remaining layer has all its dependencies satisfied.") (Above (Text "") (Above (Text "Dependency graph:") graphDoc))))))) => FindReady Nil available allLayersRL sym layer rest
• (RowToList req reqRL, AllLabelsIn reqRL available isReady, FindReadyDispatch isReady sym (OmLayer req err (Record prov)) tail available allLayersRL foundSym foundLayer rest) => FindReady (Cons sym (OmLayer req err (Record prov)) tail) available allLayersRL foundSym foundLayer rest

class FindReadyDispatch :: Boolean -> Symbol -> Type -> RowList Type -> RowList Type -> RowList Type -> Symbol -> Type -> RowList Type -> Constraintclass FindReadyDispatch (ready :: Boolean) (sym :: Symbol) (layer :: Type) (tail :: RowList Type) (available :: RowList Type) (allLayersRL :: RowList Type) (foundSym :: Symbol) (foundLayer :: Type) (rest :: RowList Type) | ready sym layer tail available allLayersRL -> foundSym foundLayer rest

Dispatch based on whether a layer is ready (deps satisfied).

Instances

• FindReadyDispatch True sym layer tail available allLayersRL sym layer tail
• (FindReady tail available allLayersRL foundSym foundLayer rest') => FindReadyDispatch False sym layer tail available allLayersRL foundSym foundLayer (Cons sym layer rest')