packages feed

chiasma 0.10.1.0 → 0.10.2.0

raw patch · 7 files changed

+42/−38 lines, 7 filesdep ~attoparsecdep ~basedep ~compositionPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: attoparsec, base, composition, lens, parsers, polysemy-conc, polysemy-log, polysemy-process, polysemy-time, prelate, prettyprinter, prettyprinter-ansi-terminal, random, typed-process, uuid

API changes (from Hackage documentation)

- Chiasma.Codec.Data: [$sel:paneHeight:Pane] :: Pane -> Int
- Chiasma.Codec.Data: [$sel:paneId:Pane] :: Pane -> PaneId
- Chiasma.Codec.Data: [$sel:paneLeft:Pane] :: Pane -> Int
- Chiasma.Codec.Data: [$sel:paneTop:Pane] :: Pane -> Int
- Chiasma.Codec.Data: [$sel:paneWidth:Pane] :: Pane -> Int
- Chiasma.Codec.Data: [$sel:sessionId:Session] :: Session -> SessionId
- Chiasma.Codec.Data: [$sel:sessionName:Session] :: Session -> Text
- Chiasma.Codec.Data: [$sel:windowHeight:Window] :: Window -> Int
- Chiasma.Codec.Data: [$sel:windowId:Window] :: Window -> WindowId
- Chiasma.Codec.Data: [$sel:windowWidth:Window] :: Window -> Int
- Chiasma.Codec.Data.Client: [$sel:clientControlMode:Client] :: Client -> Bool
- Chiasma.Codec.Data.Client: [$sel:clientName:Client] :: Client -> ClientId
- Chiasma.Codec.Data.Client: [$sel:sessionId:Client] :: Client -> SessionId
- Chiasma.Codec.Data.Client: instance GHC.Generics.Generic Chiasma.Codec.Data.Client.Client
- Chiasma.Codec.Data.Client: instance GHC.Show.Show Chiasma.Codec.Data.Client.Client
- Chiasma.Codec.Data.Pane: [$sel:paneHeight:Pane] :: Pane -> Int
- Chiasma.Codec.Data.Pane: [$sel:paneId:Pane] :: Pane -> PaneId
- Chiasma.Codec.Data.Pane: [$sel:paneLeft:Pane] :: Pane -> Int
- Chiasma.Codec.Data.Pane: [$sel:paneTop:Pane] :: Pane -> Int
- Chiasma.Codec.Data.Pane: [$sel:paneWidth:Pane] :: Pane -> Int
- Chiasma.Codec.Data.Pane: instance GHC.Generics.Generic Chiasma.Codec.Data.Pane.Pane
- Chiasma.Codec.Data.Pane: instance GHC.Show.Show Chiasma.Codec.Data.Pane.Pane
- Chiasma.Codec.Data.PaneCoords: [$sel:paneId:PaneCoords] :: PaneCoords -> PaneId
- Chiasma.Codec.Data.PaneCoords: [$sel:sessionId:PaneCoords] :: PaneCoords -> SessionId
- Chiasma.Codec.Data.PaneCoords: [$sel:windowId:PaneCoords] :: PaneCoords -> WindowId
- Chiasma.Codec.Data.PaneCoords: instance GHC.Generics.Generic Chiasma.Codec.Data.PaneCoords.PaneCoords
- Chiasma.Codec.Data.PaneCoords: instance GHC.Show.Show Chiasma.Codec.Data.PaneCoords.PaneCoords
- Chiasma.Codec.Data.PaneMode: [$sel:paneId:PaneMode] :: PaneMode -> PaneId
- Chiasma.Codec.Data.PaneMode: [$sel:paneMode:PaneMode] :: PaneMode -> Text
- Chiasma.Codec.Data.PaneMode: instance GHC.Generics.Generic Chiasma.Codec.Data.PaneMode.PaneMode
- Chiasma.Codec.Data.PaneMode: instance GHC.Show.Show Chiasma.Codec.Data.PaneMode.PaneMode
- Chiasma.Codec.Data.PanePid: [$sel:paneId:PanePid] :: PanePid -> PaneId
- Chiasma.Codec.Data.PanePid: [$sel:panePid:PanePid] :: PanePid -> Int
- Chiasma.Codec.Data.PanePid: instance GHC.Generics.Generic Chiasma.Codec.Data.PanePid.PanePid
- Chiasma.Codec.Data.PanePid: instance GHC.Show.Show Chiasma.Codec.Data.PanePid.PanePid
- Chiasma.Codec.Data.Session: [$sel:sessionId:Session] :: Session -> SessionId
- Chiasma.Codec.Data.Session: [$sel:sessionName:Session] :: Session -> Text
- Chiasma.Codec.Data.Session: instance GHC.Generics.Generic Chiasma.Codec.Data.Session.Session
- Chiasma.Codec.Data.Session: instance GHC.Show.Show Chiasma.Codec.Data.Session.Session
- Chiasma.Codec.Data.Window: [$sel:windowHeight:Window] :: Window -> Int
- Chiasma.Codec.Data.Window: [$sel:windowId:Window] :: Window -> WindowId
- Chiasma.Codec.Data.Window: [$sel:windowWidth:Window] :: Window -> Int
- Chiasma.Codec.Data.Window: instance GHC.Generics.Generic Chiasma.Codec.Data.Window.Window
- Chiasma.Codec.Data.Window: instance GHC.Show.Show Chiasma.Codec.Data.Window.Window
- Chiasma.Codec.Decode: instance Chiasma.Codec.Decode.TmuxPrimDecode a => Chiasma.Codec.Decode.TmuxDataDecode (GHC.Generics.K1 c a)
- Chiasma.Codec.Decode: instance forall k (f :: k -> *) (g :: k -> *). (Chiasma.Codec.Decode.TmuxDataDecode f, Chiasma.Codec.Decode.TmuxDataDecode g) => Chiasma.Codec.Decode.TmuxDataDecode (f GHC.Generics.:*: g)
- Chiasma.Codec.Decode: instance forall k (f :: k -> *) i (c :: GHC.Generics.Meta). Chiasma.Codec.Decode.TmuxDataDecode f => Chiasma.Codec.Decode.TmuxDataDecode (GHC.Generics.M1 i c f)
- Chiasma.Codec.Query: instance forall k (f :: k -> *) (c :: GHC.Generics.Meta). Chiasma.Codec.Query.TmuxDataQuery f => Chiasma.Codec.Query.TmuxDataQuery (GHC.Generics.C1 c f)
- Chiasma.Codec.Query: instance forall k (f :: k -> *) (c :: GHC.Generics.Meta). Chiasma.Codec.Query.TmuxDataQuery f => Chiasma.Codec.Query.TmuxDataQuery (GHC.Generics.D1 c f)
- Chiasma.Codec.Query: instance forall k (f :: k -> *) (g :: k -> *). (Chiasma.Codec.Query.TmuxDataQuery f, Chiasma.Codec.Query.TmuxDataQuery g) => Chiasma.Codec.Query.TmuxDataQuery (f GHC.Generics.:*: g)
- Chiasma.Codec.Query: instance forall k (s :: GHC.Generics.Meta) (f :: k -> *). GHC.Generics.Selector s => Chiasma.Codec.Query.TmuxDataQuery (GHC.Generics.S1 s f)
- Chiasma.Data.Axis: instance Data.Data.Data Chiasma.Data.Axis.Axis
- Chiasma.Data.Axis: instance Data.Default.Class.Default Chiasma.Data.Axis.Axis
- Chiasma.Data.Axis: instance GHC.Show.Show Chiasma.Data.Axis.Axis
- Chiasma.Data.CapturePaneParams: [$sel:alternate:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:endLine:CapturePaneParams] :: CapturePaneParams -> Maybe CaptureLine
- Chiasma.Data.CapturePaneParams: [$sel:escapeSequences:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:incomplete:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:joinWrapped:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:octal:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:output:CapturePaneParams] :: CapturePaneParams -> Maybe CaptureOutput
- Chiasma.Data.CapturePaneParams: [$sel:quiet:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:startLine:CapturePaneParams] :: CapturePaneParams -> Maybe CaptureLine
- Chiasma.Data.CapturePaneParams: [$sel:stripBlank:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:stripTrailingWs:CapturePaneParams] :: CapturePaneParams -> Bool
- Chiasma.Data.CapturePaneParams: [$sel:target:CapturePaneParams] :: CapturePaneParams -> Target
- Chiasma.Data.CapturePaneParams: instance Data.Default.Class.Default Chiasma.Data.CapturePaneParams.CapturePaneParams
- Chiasma.Data.CapturePaneParams: instance GHC.Show.Show Chiasma.Data.CapturePaneParams.CaptureLine
- Chiasma.Data.CapturePaneParams: instance GHC.Show.Show Chiasma.Data.CapturePaneParams.CaptureOutput
- Chiasma.Data.CapturePaneParams: instance GHC.Show.Show Chiasma.Data.CapturePaneParams.CapturePaneParams
- Chiasma.Data.Cmd: instance GHC.Show.Show Chiasma.Data.Cmd.Cmd
- Chiasma.Data.Cmd: instance GHC.Show.Show Chiasma.Data.Cmd.CmdArgs
- Chiasma.Data.Cmd: instance GHC.Show.Show Chiasma.Data.Cmd.CmdName
- Chiasma.Data.Cmd: instance GHC.Show.Show Chiasma.Data.Cmd.Cmds
- Chiasma.Data.CodecError: instance GHC.Show.Show Chiasma.Data.CodecError.CodecError
- Chiasma.Data.CopyModeParams: [$sel:exitBottom:CopyModeParams] :: CopyModeParams -> Bool
- Chiasma.Data.CopyModeParams: [$sel:mouseDrag:CopyModeParams] :: CopyModeParams -> Bool
- Chiasma.Data.CopyModeParams: [$sel:scrollUp:CopyModeParams] :: CopyModeParams -> Bool
- Chiasma.Data.CopyModeParams: [$sel:target:CopyModeParams] :: CopyModeParams -> Target
- Chiasma.Data.CopyModeParams: instance Data.Default.Class.Default Chiasma.Data.CopyModeParams.CopyModeParams
- Chiasma.Data.CopyModeParams: instance GHC.Show.Show Chiasma.Data.CopyModeParams.CopyModeParams
- Chiasma.Data.DecodeError: [$sel:failure:DecodeError] :: DecodeError -> DecodeFailure
- Chiasma.Data.DecodeError: [$sel:output:DecodeError] :: DecodeError -> [Text]
- Chiasma.Data.DecodeError: instance GHC.Show.Show Chiasma.Data.DecodeError.DecodeError
- Chiasma.Data.DecodeError: instance GHC.Show.Show Chiasma.Data.DecodeError.DecodeFailure
- Chiasma.Data.Direction: instance GHC.Show.Show Chiasma.Data.Direction.Direction
- Chiasma.Data.Event: instance GHC.Show.Show Chiasma.Data.Event.Event
- Chiasma.Data.Ident: instance Data.Data.Data Chiasma.Data.Ident.Ident
- Chiasma.Data.Ident: instance Data.Default.Class.Default Chiasma.Data.Ident.Ident
- Chiasma.Data.Ident: instance Data.String.IsString Chiasma.Data.Ident.Ident
- Chiasma.Data.Ident: instance GHC.Generics.Generic Chiasma.Data.Ident.Ident
- Chiasma.Data.Ident: instance GHC.Show.Show Chiasma.Data.Ident.Ident
- Chiasma.Data.KillPaneParams: [$sel:allbut:KillPaneParams] :: KillPaneParams -> Bool
- Chiasma.Data.KillPaneParams: [$sel:target:KillPaneParams] :: KillPaneParams -> Target
- Chiasma.Data.KillPaneParams: instance Data.Default.Class.Default Chiasma.Data.KillPaneParams.KillPaneParams
- Chiasma.Data.KillPaneParams: instance GHC.Show.Show Chiasma.Data.KillPaneParams.KillPaneParams
- Chiasma.Data.LayoutError: [$sel:unLayoutError:LayoutError] :: LayoutError -> Text
- Chiasma.Data.LayoutError: instance Data.String.IsString Chiasma.Data.LayoutError.LayoutError
- Chiasma.Data.LayoutError: instance GHC.Generics.Generic Chiasma.Data.LayoutError.LayoutError
- Chiasma.Data.LayoutError: instance GHC.Show.Show Chiasma.Data.LayoutError.LayoutError
- Chiasma.Data.PaneSelection: instance Data.Default.Class.Default Chiasma.Data.PaneSelection.PaneSelection
- Chiasma.Data.PaneSelection: instance GHC.Show.Show Chiasma.Data.PaneSelection.PaneSelection
- Chiasma.Data.PipePaneParams: [$sel:command:PipePaneParams] :: PipePaneParams -> Maybe Text
- Chiasma.Data.PipePaneParams: [$sel:input:PipePaneParams] :: PipePaneParams -> Bool
- Chiasma.Data.PipePaneParams: [$sel:onlyNew:PipePaneParams] :: PipePaneParams -> Bool
- Chiasma.Data.PipePaneParams: [$sel:output:PipePaneParams] :: PipePaneParams -> Bool
- Chiasma.Data.PipePaneParams: [$sel:target:PipePaneParams] :: PipePaneParams -> Target
- Chiasma.Data.PipePaneParams: instance Data.Default.Class.Default Chiasma.Data.PipePaneParams.PipePaneParams
- Chiasma.Data.PipePaneParams: instance GHC.Show.Show Chiasma.Data.PipePaneParams.PipePaneParams
- Chiasma.Data.ProcessError: instance GHC.Show.Show Chiasma.Data.ProcessError.ProcessError
- Chiasma.Data.RenderError: instance GHC.Show.Show Chiasma.Data.RenderError.RenderError
- Chiasma.Data.ResizePaneParams: [$sel:absolute:ResizePaneParams] :: ResizePaneParams -> Maybe ResizeAbsolute
- Chiasma.Data.ResizePaneParams: [$sel:adjustment:ResizePaneParams] :: ResizePaneParams -> Maybe Adjustment
- Chiasma.Data.ResizePaneParams: [$sel:mouse:ResizePaneParams] :: ResizePaneParams -> Bool
- Chiasma.Data.ResizePaneParams: [$sel:target:ResizePaneParams] :: ResizePaneParams -> Target
- Chiasma.Data.ResizePaneParams: [$sel:zoom:ResizePaneParams] :: ResizePaneParams -> Bool
- Chiasma.Data.ResizePaneParams: instance Data.Default.Class.Default Chiasma.Data.ResizePaneParams.ResizePaneParams
- Chiasma.Data.ResizePaneParams: instance GHC.Show.Show Chiasma.Data.ResizePaneParams.Adjustment
- Chiasma.Data.ResizePaneParams: instance GHC.Show.Show Chiasma.Data.ResizePaneParams.ResizeAbsolute
- Chiasma.Data.ResizePaneParams: instance GHC.Show.Show Chiasma.Data.ResizePaneParams.ResizePaneParams
- Chiasma.Data.SelectParams: [$sel:input:SelectParams] :: SelectParams -> Maybe SelectInput
- Chiasma.Data.SelectParams: [$sel:last:SelectParams] :: SelectParams -> Bool
- Chiasma.Data.SelectParams: [$sel:mark:SelectParams] :: SelectParams -> Maybe SelectMark
- Chiasma.Data.SelectParams: [$sel:neighbor:SelectParams] :: SelectParams -> Maybe Direction
- Chiasma.Data.SelectParams: [$sel:target:SelectParams] :: SelectParams -> Target
- Chiasma.Data.SelectParams: [$sel:title:SelectParams] :: SelectParams -> Maybe Text
- Chiasma.Data.SelectParams: instance Data.Default.Class.Default Chiasma.Data.SelectParams.SelectParams
- Chiasma.Data.SelectParams: instance GHC.Show.Show Chiasma.Data.SelectParams.SelectInput
- Chiasma.Data.SelectParams: instance GHC.Show.Show Chiasma.Data.SelectParams.SelectMark
- Chiasma.Data.SelectParams: instance GHC.Show.Show Chiasma.Data.SelectParams.SelectParams
- Chiasma.Data.SelectWindowParams: [$sel:last:SelectWindowParams] :: SelectWindowParams -> Bool
- Chiasma.Data.SelectWindowParams: [$sel:next:SelectWindowParams] :: SelectWindowParams -> Bool
- Chiasma.Data.SelectWindowParams: [$sel:previous:SelectWindowParams] :: SelectWindowParams -> Bool
- Chiasma.Data.SelectWindowParams: [$sel:target:SelectWindowParams] :: SelectWindowParams -> Target
- Chiasma.Data.SelectWindowParams: [$sel:toggle:SelectWindowParams] :: SelectWindowParams -> Bool
- Chiasma.Data.SelectWindowParams: instance Data.Default.Class.Default Chiasma.Data.SelectWindowParams.SelectWindowParams
- Chiasma.Data.SelectWindowParams: instance GHC.Show.Show Chiasma.Data.SelectWindowParams.SelectWindowParams
- Chiasma.Data.SendKeysParams: [$sel:copyMode:SendKeysParams] :: SendKeysParams -> Bool
- Chiasma.Data.SendKeysParams: [$sel:enter:SendKeysParams] :: SendKeysParams -> Bool
- Chiasma.Data.SendKeysParams: [$sel:hex:SendKeysParams] :: SendKeysParams -> Bool
- Chiasma.Data.SendKeysParams: [$sel:keys:SendKeysParams] :: SendKeysParams -> [Key]
- Chiasma.Data.SendKeysParams: [$sel:literal:SendKeysParams] :: SendKeysParams -> Bool
- Chiasma.Data.SendKeysParams: [$sel:mouse:SendKeysParams] :: SendKeysParams -> Bool
- Chiasma.Data.SendKeysParams: [$sel:repeat:SendKeysParams] :: SendKeysParams -> Maybe Int
- Chiasma.Data.SendKeysParams: [$sel:reset:SendKeysParams] :: SendKeysParams -> Bool
- Chiasma.Data.SendKeysParams: [$sel:target:SendKeysParams] :: SendKeysParams -> Target
- Chiasma.Data.SendKeysParams: instance Data.Default.Class.Default Chiasma.Data.SendKeysParams.SendKeysParams
- Chiasma.Data.SendKeysParams: instance Data.String.IsString Chiasma.Data.SendKeysParams.Key
- Chiasma.Data.SendKeysParams: instance GHC.Show.Show Chiasma.Data.SendKeysParams.Key
- Chiasma.Data.SendKeysParams: instance GHC.Show.Show Chiasma.Data.SendKeysParams.SendKeysParams
- Chiasma.Data.SessionGroupId: [$sel:unSessionGroupId:SessionGroupId] :: SessionGroupId -> Text
- Chiasma.Data.SessionGroupId: instance Data.String.IsString Chiasma.Data.SessionGroupId.SessionGroupId
- Chiasma.Data.SessionGroupId: instance GHC.Generics.Generic Chiasma.Data.SessionGroupId.SessionGroupId
- Chiasma.Data.SessionGroupId: instance GHC.Show.Show Chiasma.Data.SessionGroupId.SessionGroupId
- Chiasma.Data.SessionParams: [$sel:attach:SessionParams] :: SessionParams -> Bool
- Chiasma.Data.SessionParams: [$sel:command:SessionParams] :: SessionParams -> Maybe Text
- Chiasma.Data.SessionParams: [$sel:cwd:SessionParams] :: SessionParams -> Maybe (Path Abs Dir)
- Chiasma.Data.SessionParams: [$sel:defaultSize:SessionParams] :: SessionParams -> Bool
- Chiasma.Data.SessionParams: [$sel:detach:SessionParams] :: SessionParams -> Bool
- Chiasma.Data.SessionParams: [$sel:environment:SessionParams] :: SessionParams -> Map Text Text
- Chiasma.Data.SessionParams: [$sel:exitClient:SessionParams] :: SessionParams -> Bool
- Chiasma.Data.SessionParams: [$sel:height:SessionParams] :: SessionParams -> Maybe Int
- Chiasma.Data.SessionParams: [$sel:name:SessionParams] :: SessionParams -> Maybe Ident
- Chiasma.Data.SessionParams: [$sel:printInfo:SessionParams] :: SessionParams -> Bool
- Chiasma.Data.SessionParams: [$sel:target:SessionParams] :: SessionParams -> Maybe SessionGroupId
- Chiasma.Data.SessionParams: [$sel:width:SessionParams] :: SessionParams -> Maybe Int
- Chiasma.Data.SessionParams: [$sel:windowName:SessionParams] :: SessionParams -> Maybe Ident
- Chiasma.Data.SessionParams: instance Data.Default.Class.Default Chiasma.Data.SessionParams.SessionParams
- Chiasma.Data.SessionParams: instance GHC.Show.Show Chiasma.Data.SessionParams.SessionParams
- Chiasma.Data.SplitParams: [$sel:axis:JoinPaneParams] :: JoinPaneParams -> Maybe Axis
- Chiasma.Data.SplitParams: [$sel:axis:SplitWindowParams] :: SplitWindowParams -> Maybe Axis
- Chiasma.Data.SplitParams: [$sel:before:JoinPaneParams] :: JoinPaneParams -> Bool
- Chiasma.Data.SplitParams: [$sel:before:SplitWindowParams] :: SplitWindowParams -> Bool
- Chiasma.Data.SplitParams: [$sel:detach:JoinPaneParams] :: JoinPaneParams -> Bool
- Chiasma.Data.SplitParams: [$sel:fullSize:SplitWindowParams] :: SplitWindowParams -> Bool
- Chiasma.Data.SplitParams: [$sel:readStdin:SplitWindowParams] :: SplitWindowParams -> Bool
- Chiasma.Data.SplitParams: [$sel:size:JoinPaneParams] :: JoinPaneParams -> Maybe SplitSize
- Chiasma.Data.SplitParams: [$sel:size:SplitWindowParams] :: SplitWindowParams -> Maybe SplitSize
- Chiasma.Data.SplitParams: [$sel:source:JoinPaneParams] :: JoinPaneParams -> Maybe Target
- Chiasma.Data.SplitParams: [$sel:target:JoinPaneParams] :: JoinPaneParams -> Target
- Chiasma.Data.SplitParams: instance Data.Default.Class.Default Chiasma.Data.SplitParams.JoinPaneParams
- Chiasma.Data.SplitParams: instance Data.Default.Class.Default Chiasma.Data.SplitParams.SplitWindowParams
- Chiasma.Data.SplitParams: instance GHC.Show.Show Chiasma.Data.SplitParams.JoinPaneParams
- Chiasma.Data.SplitParams: instance GHC.Show.Show Chiasma.Data.SplitParams.SplitSize
- Chiasma.Data.SplitParams: instance GHC.Show.Show Chiasma.Data.SplitParams.SplitWindowParams
- Chiasma.Data.Target: instance Data.Default.Class.Default Chiasma.Data.Target.Target
- Chiasma.Data.Target: instance GHC.Show.Show Chiasma.Data.Target.Target
- Chiasma.Data.TmuxCommand: instance GHC.Base.Functor Chiasma.Data.TmuxCommand.TmuxCommand
- Chiasma.Data.TmuxCommand: instance GHC.Show.Show (Chiasma.Data.TmuxCommand.TmuxCommand a)
- Chiasma.Data.TmuxError: instance GHC.Show.Show Chiasma.Data.TmuxError.TmuxError
- Chiasma.Data.TmuxId: [$sel:unClientId:ClientId] :: ClientId -> Text
- Chiasma.Data.TmuxId: [$sel:unTmuxIdPrefix:TmuxIdPrefix] :: TmuxIdPrefix a -> Text
- Chiasma.Data.TmuxId: instance Data.Data.Data Chiasma.Data.TmuxId.PaneId
- Chiasma.Data.TmuxId: instance Data.String.IsString Chiasma.Data.TmuxId.ClientId
- Chiasma.Data.TmuxId: instance GHC.Generics.Generic Chiasma.Data.TmuxId.ClientId
- Chiasma.Data.TmuxId: instance GHC.Generics.Generic Chiasma.Data.TmuxId.PaneId
- Chiasma.Data.TmuxId: instance GHC.Generics.Generic Chiasma.Data.TmuxId.SessionId
- Chiasma.Data.TmuxId: instance GHC.Generics.Generic Chiasma.Data.TmuxId.WindowId
- Chiasma.Data.TmuxId: instance GHC.Num.Num Chiasma.Data.TmuxId.PaneId
- Chiasma.Data.TmuxId: instance GHC.Num.Num Chiasma.Data.TmuxId.SessionId
- Chiasma.Data.TmuxId: instance GHC.Num.Num Chiasma.Data.TmuxId.WindowId
- Chiasma.Data.TmuxId: instance GHC.Show.Show Chiasma.Data.TmuxId.ClientId
- Chiasma.Data.TmuxId: instance GHC.Show.Show Chiasma.Data.TmuxId.PaneId
- Chiasma.Data.TmuxId: instance GHC.Show.Show Chiasma.Data.TmuxId.SessionId
- Chiasma.Data.TmuxId: instance GHC.Show.Show Chiasma.Data.TmuxId.WindowId
- Chiasma.Data.TmuxId: instance forall k (a :: k). Data.String.IsString (Chiasma.Data.TmuxId.TmuxIdPrefix a)
- Chiasma.Data.TmuxId: instance forall k (a :: k). GHC.Generics.Generic (Chiasma.Data.TmuxId.TmuxIdPrefix a)
- Chiasma.Data.TmuxId: instance forall k (a :: k). GHC.Show.Show (Chiasma.Data.TmuxId.TmuxIdPrefix a)
- Chiasma.Data.TmuxNative: [$sel:executable:TmuxNative] :: TmuxNative -> Path Abs File
- Chiasma.Data.TmuxNative: [$sel:tmuxServerSocket:TmuxNative] :: TmuxNative -> Maybe (Path Abs File)
- Chiasma.Data.TmuxNative: instance GHC.Show.Show Chiasma.Data.TmuxNative.TmuxNative
- Chiasma.Data.TmuxOutputBlock: instance GHC.Show.Show Chiasma.Data.TmuxOutputBlock.End
- Chiasma.Data.TmuxOutputBlock: instance GHC.Show.Show Chiasma.Data.TmuxOutputBlock.TmuxOutputBlock
- Chiasma.Data.TmuxQuery: [$sel:unTmuxQuery:TmuxQuery] :: TmuxQuery -> Text
- Chiasma.Data.TmuxQuery: instance Data.String.IsString Chiasma.Data.TmuxQuery.TmuxQuery
- Chiasma.Data.TmuxQuery: instance GHC.Base.Monoid Chiasma.Data.TmuxQuery.TmuxQuery
- Chiasma.Data.TmuxQuery: instance GHC.Base.Semigroup Chiasma.Data.TmuxQuery.TmuxQuery
- Chiasma.Data.TmuxQuery: instance GHC.Generics.Generic Chiasma.Data.TmuxQuery.TmuxQuery
- Chiasma.Data.TmuxQuery: instance GHC.Show.Show Chiasma.Data.TmuxQuery.TmuxQuery
- Chiasma.Data.TmuxRequest: [$sel:args:TmuxRequest] :: TmuxRequest -> [Text]
- Chiasma.Data.TmuxRequest: [$sel:cmd:TmuxRequest] :: TmuxRequest -> Text
- Chiasma.Data.TmuxRequest: [$sel:query:TmuxRequest] :: TmuxRequest -> Maybe TmuxQuery
- Chiasma.Data.TmuxRequest: instance GHC.Show.Show Chiasma.Data.TmuxRequest.TmuxRequest
- Chiasma.Data.TmuxResponse: [$sel:unTmuxResponse:TmuxResponse] :: TmuxResponse -> [Text]
- Chiasma.Data.TmuxResponse: instance GHC.Base.Monoid Chiasma.Data.TmuxResponse.TmuxResponse
- Chiasma.Data.TmuxResponse: instance GHC.Base.Semigroup Chiasma.Data.TmuxResponse.TmuxResponse
- Chiasma.Data.TmuxResponse: instance GHC.Show.Show Chiasma.Data.TmuxResponse.TmuxResponse
- Chiasma.Data.View: [$sel:id:View] :: View a -> Maybe a
- Chiasma.Data.View: [$sel:ident:View] :: View a -> Ident
- Chiasma.Data.View: instance GHC.Generics.Generic (Chiasma.Data.View.View a)
- Chiasma.Data.View: instance GHC.Show.Show a => GHC.Show.Show (Chiasma.Data.View.View a)
- Chiasma.Data.Views: [$sel:_log:Views] :: Views -> [Doc AnsiStyle]
- Chiasma.Data.Views: [$sel:_panes:Views] :: Views -> [View PaneId]
- Chiasma.Data.Views: [$sel:_sessions:Views] :: Views -> [View SessionId]
- Chiasma.Data.Views: [$sel:_windows:Views] :: Views -> [View WindowId]
- Chiasma.Data.Views: instance Data.Default.Class.Default Chiasma.Data.Views.Views
- Chiasma.Data.Views: instance GHC.Generics.Generic Chiasma.Data.Views.Views
- Chiasma.Data.Views: instance GHC.Show.Show Chiasma.Data.Views.Views
- Chiasma.Data.Views: instance GHC.Show.Show Chiasma.Data.Views.ViewsError
- Chiasma.Data.WindowParams: [$sel:after:WindowParams] :: WindowParams -> Bool
- Chiasma.Data.WindowParams: [$sel:command:WindowParams] :: WindowParams -> Maybe Text
- Chiasma.Data.WindowParams: [$sel:cwd:WindowParams] :: WindowParams -> Maybe (Path Abs Dir)
- Chiasma.Data.WindowParams: [$sel:detach:WindowParams] :: WindowParams -> Bool
- Chiasma.Data.WindowParams: [$sel:environment:WindowParams] :: WindowParams -> Map Text Text
- Chiasma.Data.WindowParams: [$sel:killExisting:WindowParams] :: WindowParams -> Bool
- Chiasma.Data.WindowParams: [$sel:name:WindowParams] :: WindowParams -> Maybe Ident
- Chiasma.Data.WindowParams: [$sel:printInfo:WindowParams] :: WindowParams -> Bool
- Chiasma.Data.WindowParams: [$sel:target:WindowParams] :: WindowParams -> Target
- Chiasma.Data.WindowParams: instance Data.Default.Class.Default Chiasma.Data.WindowParams.WindowParams
- Chiasma.Data.WindowParams: instance GHC.Show.Show Chiasma.Data.WindowParams.WindowParams
- Chiasma.Data.WindowSelection: instance Data.Default.Class.Default Chiasma.Data.WindowSelection.WindowSelection
- Chiasma.Data.WindowSelection: instance GHC.Show.Show Chiasma.Data.WindowSelection.WindowSelection
- Chiasma.Data.WindowState: [$sel:wsLayout:WindowState] :: WindowState -> RenderableTree
- Chiasma.Data.WindowState: [$sel:wsNativeRefPane:WindowState] :: WindowState -> Pane
- Chiasma.Data.WindowState: [$sel:wsNativeWindow:WindowState] :: WindowState -> Window
- Chiasma.Data.WindowState: [$sel:wsReferencePane:WindowState] :: WindowState -> PaneId
- Chiasma.Data.WindowState: [$sel:wsWindowIdent:WindowState] :: WindowState -> Ident
- Chiasma.Data.WindowState: instance GHC.Show.Show Chiasma.Data.WindowState.WindowState
- Chiasma.Data.WithPaneId: [$sel:pane:WithPaneId] :: WithPaneId a -> a
- Chiasma.Data.WithPaneId: [$sel:paneId:WithPaneId] :: WithPaneId a -> PaneId
- Chiasma.Data.WithPaneId: instance GHC.Generics.Generic (Chiasma.Data.WithPaneId.WithPaneId a)
- Chiasma.Data.WithPaneId: instance GHC.Show.Show a => GHC.Show.Show (Chiasma.Data.WithPaneId.WithPaneId a)
- Chiasma.Lens.Tree: [$sel:litTree:LeafIndexTree] :: LeafIndexTree l p -> Tree l p
- Chiasma.Lens.Tree: [$sel:nitTree:NodeIndexTree] :: NodeIndexTree l p -> Tree l p
- Chiasma.Lens.Tree: instance (Data.Data.Data l, Data.Data.Data p) => Control.Lens.Plated.Plated (Chiasma.Lens.Tree.LeafIndexTree l p)
- Chiasma.Lens.Tree: instance (Data.Data.Data l, Data.Data.Data p) => Control.Lens.Plated.Plated (Chiasma.Lens.Tree.NodeIndexTree l p)
- Chiasma.Lens.Tree: instance (GHC.Show.Show l, GHC.Show.Show p) => GHC.Show.Show (Chiasma.Lens.Tree.LeafIndexTree l p)
- Chiasma.Lens.Tree: instance (GHC.Show.Show l, GHC.Show.Show p) => GHC.Show.Show (Chiasma.Lens.Tree.NodeIndexTree l p)
- Chiasma.Ui.Data.Measure: [$sel:_axis:MLayout] :: MLayout -> Axis
- Chiasma.Ui.Data.Measure: [$sel:_lMainPosition:MLayout] :: MLayout -> Int
- Chiasma.Ui.Data.Measure: [$sel:_lOffPosition:MLayout] :: MLayout -> Int
- Chiasma.Ui.Data.Measure: [$sel:_mainPosition:MPane] :: MPane -> Int
- Chiasma.Ui.Data.Measure: [$sel:_offPosition:MPane] :: MPane -> Int
- Chiasma.Ui.Data.Measure: [$sel:_paneId:MPane] :: MPane -> PaneId
- Chiasma.Ui.Data.Measure: [$sel:_reference:MLayout] :: MLayout -> PaneId
- Chiasma.Ui.Data.Measure: [$sel:_size:Measured] :: Measured a -> Int
- Chiasma.Ui.Data.Measure: [$sel:_view:Measured] :: Measured a -> a
- Chiasma.Ui.Data.Measure: instance GHC.Show.Show Chiasma.Ui.Data.Measure.MLayout
- Chiasma.Ui.Data.Measure: instance GHC.Show.Show Chiasma.Ui.Data.Measure.MPane
- Chiasma.Ui.Data.Measure: instance GHC.Show.Show a => GHC.Show.Show (Chiasma.Ui.Data.Measure.Measured a)
- Chiasma.Ui.Data.RenderableTree: [$sel:_axis:RLayout] :: RLayout -> Axis
- Chiasma.Ui.Data.RenderableTree: [$sel:_geometry:Renderable] :: Renderable a -> ViewGeometry
- Chiasma.Ui.Data.RenderableTree: [$sel:_id:RPane] :: RPane -> PaneId
- Chiasma.Ui.Data.RenderableTree: [$sel:_left:RPane] :: RPane -> Int
- Chiasma.Ui.Data.RenderableTree: [$sel:_ref:RLayout] :: RLayout -> RPane
- Chiasma.Ui.Data.RenderableTree: [$sel:_state:Renderable] :: Renderable a -> ViewState
- Chiasma.Ui.Data.RenderableTree: [$sel:_top:RPane] :: RPane -> Int
- Chiasma.Ui.Data.RenderableTree: [$sel:_view:Renderable] :: Renderable a -> a
- Chiasma.Ui.Data.RenderableTree: instance GHC.Show.Show Chiasma.Ui.Data.RenderableTree.RLayout
- Chiasma.Ui.Data.RenderableTree: instance GHC.Show.Show Chiasma.Ui.Data.RenderableTree.RPane
- Chiasma.Ui.Data.RenderableTree: instance GHC.Show.Show a => GHC.Show.Show (Chiasma.Ui.Data.RenderableTree.Renderable a)
- Chiasma.Ui.Data.Tree: [$sel:_forest:Tree] :: Tree f l p -> f (Node f l p)
- Chiasma.Ui.Data.Tree: [$sel:_leafData:Sub] :: Node f l p -> p
- Chiasma.Ui.Data.Tree: [$sel:_subTree:Sub] :: Node f l p -> Tree f l p
- Chiasma.Ui.Data.Tree: [$sel:_treeData:Tree] :: Tree f l p -> l
- Chiasma.Ui.Data.Tree: instance (Data.Foldable.Foldable f, Prettyprinter.Internal.Pretty l, Prettyprinter.Internal.Pretty p) => Prettyprinter.Internal.Pretty (Chiasma.Ui.Data.Tree.Node f l p)
- Chiasma.Ui.Data.Tree: instance (Data.Foldable.Foldable f, Prettyprinter.Internal.Pretty l, Prettyprinter.Internal.Pretty p) => Prettyprinter.Internal.Pretty (Chiasma.Ui.Data.Tree.Tree f l p)
- Chiasma.Ui.Data.Tree: instance (GHC.Classes.Eq l, GHC.Classes.Eq (Chiasma.Ui.Data.Tree.Node GHC.Base.NonEmpty l p)) => GHC.Classes.Eq (Chiasma.Ui.Data.Tree.Tree GHC.Base.NonEmpty l p)
- Chiasma.Ui.Data.Tree: instance (GHC.Classes.Eq l, GHC.Classes.Eq p) => GHC.Classes.Eq (Chiasma.Ui.Data.Tree.Node GHC.Base.NonEmpty l p)
- Chiasma.Ui.Data.Tree: instance (GHC.Show.Show l, GHC.Show.Show (Chiasma.Ui.Data.Tree.Node GHC.Base.NonEmpty l p)) => GHC.Show.Show (Chiasma.Ui.Data.Tree.Tree GHC.Base.NonEmpty l p)
- Chiasma.Ui.Data.Tree: instance (GHC.Show.Show l, GHC.Show.Show (Chiasma.Ui.Data.Tree.Node [] l p)) => GHC.Show.Show (Chiasma.Ui.Data.Tree.Tree [] l p)
- Chiasma.Ui.Data.Tree: instance (GHC.Show.Show l, GHC.Show.Show p) => GHC.Show.Show (Chiasma.Ui.Data.Tree.Node GHC.Base.NonEmpty l p)
- Chiasma.Ui.Data.Tree: instance (GHC.Show.Show l, GHC.Show.Show p) => GHC.Show.Show (Chiasma.Ui.Data.Tree.Node [] l p)
- Chiasma.Ui.Data.TreeModError: instance GHC.Show.Show Chiasma.Ui.Data.TreeModError.TreeModError
- Chiasma.Ui.Data.View: [$sel:axis:Layout] :: Layout -> Axis
- Chiasma.Ui.Data.View: [$sel:cwd:Pane] :: Pane -> Maybe Text
- Chiasma.Ui.Data.View: [$sel:extra:View] :: View a -> a
- Chiasma.Ui.Data.View: [$sel:geometry:View] :: View a -> ViewGeometry
- Chiasma.Ui.Data.View: [$sel:ident:View] :: View a -> Ident
- Chiasma.Ui.Data.View: [$sel:leafData:TreeNode] :: TreeSub l p -> p
- Chiasma.Ui.Data.View: [$sel:open:Pane] :: Pane -> Bool
- Chiasma.Ui.Data.View: [$sel:pin:Pane] :: Pane -> Bool
- Chiasma.Ui.Data.View: [$sel:state:View] :: View a -> ViewState
- Chiasma.Ui.Data.View: [$sel:subTree:TreeNode] :: TreeSub l p -> Tree l p
- Chiasma.Ui.Data.View: [$sel:treeData:Tree] :: Tree l p -> l
- Chiasma.Ui.Data.View: [$sel:treeSubs:Tree] :: Tree l p -> [TreeSub l p]
- Chiasma.Ui.Data.View: instance (Data.Data.Data l, Data.Data.Data p) => Control.Lens.Plated.Plated (Chiasma.Ui.Data.View.Tree l p)
- Chiasma.Ui.Data.View: instance (Data.Data.Data l, Data.Data.Data p) => Data.Data.Data (Chiasma.Ui.Data.View.TreeSub l p)
- Chiasma.Ui.Data.View: instance (Data.Data.Data p, Data.Data.Data l) => Data.Data.Data (Chiasma.Ui.Data.View.Tree l p)
- Chiasma.Ui.Data.View: instance (GHC.Show.Show l, GHC.Show.Show p) => GHC.Show.Show (Chiasma.Ui.Data.View.Tree l p)
- Chiasma.Ui.Data.View: instance (GHC.Show.Show l, GHC.Show.Show p) => GHC.Show.Show (Chiasma.Ui.Data.View.TreeSub l p)
- Chiasma.Ui.Data.View: instance Data.Data.Data Chiasma.Ui.Data.View.Layout
- Chiasma.Ui.Data.View: instance Data.Data.Data Chiasma.Ui.Data.View.Pane
- Chiasma.Ui.Data.View: instance Data.Data.Data a => Data.Data.Data (Chiasma.Ui.Data.View.View a)
- Chiasma.Ui.Data.View: instance Data.Default.Class.Default Chiasma.Ui.Data.View.Layout
- Chiasma.Ui.Data.View: instance Data.Default.Class.Default Chiasma.Ui.Data.View.Pane
- Chiasma.Ui.Data.View: instance Data.Default.Class.Default a => Data.Default.Class.Default (Chiasma.Ui.Data.View.View a)
- Chiasma.Ui.Data.View: instance GHC.Generics.Generic (Chiasma.Ui.Data.View.Tree l p)
- Chiasma.Ui.Data.View: instance GHC.Generics.Generic (Chiasma.Ui.Data.View.TreeSub l p)
- Chiasma.Ui.Data.View: instance GHC.Generics.Generic (Chiasma.Ui.Data.View.View a)
- Chiasma.Ui.Data.View: instance GHC.Generics.Generic Chiasma.Ui.Data.View.Layout
- Chiasma.Ui.Data.View: instance GHC.Generics.Generic Chiasma.Ui.Data.View.Pane
- Chiasma.Ui.Data.View: instance GHC.Show.Show Chiasma.Ui.Data.View.Layout
- Chiasma.Ui.Data.View: instance GHC.Show.Show Chiasma.Ui.Data.View.Pane
- Chiasma.Ui.Data.View: instance GHC.Show.Show a => GHC.Show.Show (Chiasma.Ui.Data.View.View a)
- Chiasma.Ui.Data.ViewGeometry: [$sel:fixedSize:ViewGeometry] :: ViewGeometry -> Maybe Float
- Chiasma.Ui.Data.ViewGeometry: [$sel:maxSize:ViewGeometry] :: ViewGeometry -> Maybe Float
- Chiasma.Ui.Data.ViewGeometry: [$sel:minSize:ViewGeometry] :: ViewGeometry -> Maybe Float
- Chiasma.Ui.Data.ViewGeometry: [$sel:minimizedSize:ViewGeometry] :: ViewGeometry -> Maybe Float
- Chiasma.Ui.Data.ViewGeometry: [$sel:position:ViewGeometry] :: ViewGeometry -> Maybe Float
- Chiasma.Ui.Data.ViewGeometry: [$sel:weight:ViewGeometry] :: ViewGeometry -> Maybe Float
- Chiasma.Ui.Data.ViewGeometry: instance Data.Data.Data Chiasma.Ui.Data.ViewGeometry.ViewGeometry
- Chiasma.Ui.Data.ViewGeometry: instance Data.Default.Class.Default Chiasma.Ui.Data.ViewGeometry.ViewGeometry
- Chiasma.Ui.Data.ViewGeometry: instance GHC.Generics.Generic Chiasma.Ui.Data.ViewGeometry.ViewGeometry
- Chiasma.Ui.Data.ViewGeometry: instance GHC.Show.Show Chiasma.Ui.Data.ViewGeometry.ViewGeometry
- Chiasma.Ui.Data.ViewState: [$sel:minimized:ViewState] :: ViewState -> Bool
- Chiasma.Ui.Data.ViewState: instance Data.Data.Data Chiasma.Ui.Data.ViewState.ViewState
- Chiasma.Ui.Data.ViewState: instance Data.Default.Class.Default Chiasma.Ui.Data.ViewState.ViewState
- Chiasma.Ui.Data.ViewState: instance GHC.Generics.Generic Chiasma.Ui.Data.ViewState.ViewState
- Chiasma.Ui.Data.ViewState: instance GHC.Show.Show Chiasma.Ui.Data.ViewState.ViewState
- Chiasma.Ui.Measure.Balance: [$sel:balanceMax:Balance] :: Balance -> NonEmpty (Maybe Float)
- Chiasma.Ui.Measure.Balance: [$sel:balanceMin:Balance] :: Balance -> NonEmpty Float
- Chiasma.Ui.Measure.Balance: [$sel:balanceMinimized:Balance] :: Balance -> NonEmpty Bool
- Chiasma.Ui.Measure.Balance: [$sel:balanceTotal:Balance] :: Balance -> Float
- Chiasma.Ui.Measure.Balance: [$sel:balanceWeights:Balance] :: Balance -> NonEmpty Float
- Chiasma.Ui.ViewTree: instance GHC.Base.Applicative Chiasma.Ui.ViewTree.ToggleResult
- Chiasma.Ui.ViewTree: instance GHC.Base.Functor Chiasma.Ui.ViewTree.ToggleResult
- Chiasma.Ui.ViewTree: instance GHC.Base.Monad Chiasma.Ui.ViewTree.ToggleResult
- Chiasma.Ui.ViewTree: instance GHC.Base.Monoid (Chiasma.Ui.ViewTree.ToggleResult a)
- Chiasma.Ui.ViewTree: instance GHC.Base.Monoid Chiasma.Ui.ViewTree.ToggleStatus
- Chiasma.Ui.ViewTree: instance GHC.Base.Semigroup (Chiasma.Ui.ViewTree.ToggleResult a)
- Chiasma.Ui.ViewTree: instance GHC.Base.Semigroup Chiasma.Ui.ViewTree.ToggleStatus
- Chiasma.Ui.ViewTree: instance GHC.Show.Show Chiasma.Ui.ViewTree.ToggleStatus
- Chiasma.Ui.ViewTree: instance GHC.Show.Show a => GHC.Show.Show (Chiasma.Ui.ViewTree.ToggleResult a)
+ Chiasma.Codec: ($dmdecode) :: (TmuxCodec a, Generic a, TmuxDataDecode (Rep a)) => Text -> Either DecodeError a
+ Chiasma.Codec: ($dmquery) :: (TmuxCodec a, TmuxDataQuery (Rep a)) => TmuxQuery
+ Chiasma.Codec.Data: [paneHeight] :: Pane -> Int
+ Chiasma.Codec.Data: [paneId] :: Pane -> PaneId
+ Chiasma.Codec.Data: [paneLeft] :: Pane -> Int
+ Chiasma.Codec.Data: [paneTop] :: Pane -> Int
+ Chiasma.Codec.Data: [paneWidth] :: Pane -> Int
+ Chiasma.Codec.Data: [sessionId] :: Session -> SessionId
+ Chiasma.Codec.Data: [sessionName] :: Session -> Text
+ Chiasma.Codec.Data: [windowHeight] :: Window -> Int
+ Chiasma.Codec.Data: [windowId] :: Window -> WindowId
+ Chiasma.Codec.Data: [windowWidth] :: Window -> Int
+ Chiasma.Codec.Data.Client: [clientControlMode] :: Client -> Bool
+ Chiasma.Codec.Data.Client: [clientName] :: Client -> ClientId
+ Chiasma.Codec.Data.Client: [sessionId] :: Client -> SessionId
+ Chiasma.Codec.Data.Client: instance GHC.Internal.Generics.Generic Chiasma.Codec.Data.Client.Client
+ Chiasma.Codec.Data.Client: instance GHC.Internal.Show.Show Chiasma.Codec.Data.Client.Client
+ Chiasma.Codec.Data.Pane: [paneHeight] :: Pane -> Int
+ Chiasma.Codec.Data.Pane: [paneId] :: Pane -> PaneId
+ Chiasma.Codec.Data.Pane: [paneLeft] :: Pane -> Int
+ Chiasma.Codec.Data.Pane: [paneTop] :: Pane -> Int
+ Chiasma.Codec.Data.Pane: [paneWidth] :: Pane -> Int
+ Chiasma.Codec.Data.Pane: instance GHC.Internal.Generics.Generic Chiasma.Codec.Data.Pane.Pane
+ Chiasma.Codec.Data.Pane: instance GHC.Internal.Show.Show Chiasma.Codec.Data.Pane.Pane
+ Chiasma.Codec.Data.PaneCoords: [paneId] :: PaneCoords -> PaneId
+ Chiasma.Codec.Data.PaneCoords: [sessionId] :: PaneCoords -> SessionId
+ Chiasma.Codec.Data.PaneCoords: [windowId] :: PaneCoords -> WindowId
+ Chiasma.Codec.Data.PaneCoords: instance GHC.Internal.Generics.Generic Chiasma.Codec.Data.PaneCoords.PaneCoords
+ Chiasma.Codec.Data.PaneCoords: instance GHC.Internal.Show.Show Chiasma.Codec.Data.PaneCoords.PaneCoords
+ Chiasma.Codec.Data.PaneMode: [paneId] :: PaneMode -> PaneId
+ Chiasma.Codec.Data.PaneMode: [paneMode] :: PaneMode -> Text
+ Chiasma.Codec.Data.PaneMode: instance GHC.Internal.Generics.Generic Chiasma.Codec.Data.PaneMode.PaneMode
+ Chiasma.Codec.Data.PaneMode: instance GHC.Internal.Show.Show Chiasma.Codec.Data.PaneMode.PaneMode
+ Chiasma.Codec.Data.PanePid: [paneId] :: PanePid -> PaneId
+ Chiasma.Codec.Data.PanePid: [panePid] :: PanePid -> Int
+ Chiasma.Codec.Data.PanePid: instance GHC.Internal.Generics.Generic Chiasma.Codec.Data.PanePid.PanePid
+ Chiasma.Codec.Data.PanePid: instance GHC.Internal.Show.Show Chiasma.Codec.Data.PanePid.PanePid
+ Chiasma.Codec.Data.Session: [sessionId] :: Session -> SessionId
+ Chiasma.Codec.Data.Session: [sessionName] :: Session -> Text
+ Chiasma.Codec.Data.Session: instance GHC.Internal.Generics.Generic Chiasma.Codec.Data.Session.Session
+ Chiasma.Codec.Data.Session: instance GHC.Internal.Show.Show Chiasma.Codec.Data.Session.Session
+ Chiasma.Codec.Data.Window: [windowHeight] :: Window -> Int
+ Chiasma.Codec.Data.Window: [windowId] :: Window -> WindowId
+ Chiasma.Codec.Data.Window: [windowWidth] :: Window -> Int
+ Chiasma.Codec.Data.Window: instance GHC.Internal.Generics.Generic Chiasma.Codec.Data.Window.Window
+ Chiasma.Codec.Data.Window: instance GHC.Internal.Show.Show Chiasma.Codec.Data.Window.Window
+ Chiasma.Codec.Decode: instance Chiasma.Codec.Decode.TmuxPrimDecode a => Chiasma.Codec.Decode.TmuxDataDecode (GHC.Internal.Generics.K1 c a)
+ Chiasma.Codec.Decode: instance forall k (f :: k -> *) (g :: k -> *). (Chiasma.Codec.Decode.TmuxDataDecode f, Chiasma.Codec.Decode.TmuxDataDecode g) => Chiasma.Codec.Decode.TmuxDataDecode (f GHC.Internal.Generics.:*: g)
+ Chiasma.Codec.Decode: instance forall k (f :: k -> *) i (c :: GHC.Internal.Generics.Meta). Chiasma.Codec.Decode.TmuxDataDecode f => Chiasma.Codec.Decode.TmuxDataDecode (GHC.Internal.Generics.M1 i c f)
+ Chiasma.Codec.Query: instance forall k (f :: k -> *) (c :: GHC.Internal.Generics.Meta). Chiasma.Codec.Query.TmuxDataQuery f => Chiasma.Codec.Query.TmuxDataQuery (GHC.Internal.Generics.C1 c f)
+ Chiasma.Codec.Query: instance forall k (f :: k -> *) (c :: GHC.Internal.Generics.Meta). Chiasma.Codec.Query.TmuxDataQuery f => Chiasma.Codec.Query.TmuxDataQuery (GHC.Internal.Generics.D1 c f)
+ Chiasma.Codec.Query: instance forall k (f :: k -> *) (g :: k -> *). (Chiasma.Codec.Query.TmuxDataQuery f, Chiasma.Codec.Query.TmuxDataQuery g) => Chiasma.Codec.Query.TmuxDataQuery (f GHC.Internal.Generics.:*: g)
+ Chiasma.Codec.Query: instance forall k (s :: GHC.Internal.Generics.Meta) (f :: k -> *). GHC.Internal.Generics.Selector s => Chiasma.Codec.Query.TmuxDataQuery (GHC.Internal.Generics.S1 s f)
+ Chiasma.Data.Axis: instance Data.Default.Internal.Default Chiasma.Data.Axis.Axis
+ Chiasma.Data.Axis: instance GHC.Internal.Data.Data.Data Chiasma.Data.Axis.Axis
+ Chiasma.Data.Axis: instance GHC.Internal.Show.Show Chiasma.Data.Axis.Axis
+ Chiasma.Data.CapturePaneParams: [alternate] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [endLine] :: CapturePaneParams -> Maybe CaptureLine
+ Chiasma.Data.CapturePaneParams: [escapeSequences] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [incomplete] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [joinWrapped] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [octal] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [output] :: CapturePaneParams -> Maybe CaptureOutput
+ Chiasma.Data.CapturePaneParams: [quiet] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [startLine] :: CapturePaneParams -> Maybe CaptureLine
+ Chiasma.Data.CapturePaneParams: [stripBlank] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [stripTrailingWs] :: CapturePaneParams -> Bool
+ Chiasma.Data.CapturePaneParams: [target] :: CapturePaneParams -> Target
+ Chiasma.Data.CapturePaneParams: instance Data.Default.Internal.Default Chiasma.Data.CapturePaneParams.CapturePaneParams
+ Chiasma.Data.CapturePaneParams: instance GHC.Internal.Show.Show Chiasma.Data.CapturePaneParams.CaptureLine
+ Chiasma.Data.CapturePaneParams: instance GHC.Internal.Show.Show Chiasma.Data.CapturePaneParams.CaptureOutput
+ Chiasma.Data.CapturePaneParams: instance GHC.Internal.Show.Show Chiasma.Data.CapturePaneParams.CapturePaneParams
+ Chiasma.Data.Cmd: instance GHC.Internal.Show.Show Chiasma.Data.Cmd.Cmd
+ Chiasma.Data.Cmd: instance GHC.Internal.Show.Show Chiasma.Data.Cmd.CmdArgs
+ Chiasma.Data.Cmd: instance GHC.Internal.Show.Show Chiasma.Data.Cmd.CmdName
+ Chiasma.Data.Cmd: instance GHC.Internal.Show.Show Chiasma.Data.Cmd.Cmds
+ Chiasma.Data.CodecError: instance GHC.Internal.Show.Show Chiasma.Data.CodecError.CodecError
+ Chiasma.Data.CopyModeParams: [exitBottom] :: CopyModeParams -> Bool
+ Chiasma.Data.CopyModeParams: [mouseDrag] :: CopyModeParams -> Bool
+ Chiasma.Data.CopyModeParams: [scrollUp] :: CopyModeParams -> Bool
+ Chiasma.Data.CopyModeParams: [target] :: CopyModeParams -> Target
+ Chiasma.Data.CopyModeParams: instance Data.Default.Internal.Default Chiasma.Data.CopyModeParams.CopyModeParams
+ Chiasma.Data.CopyModeParams: instance GHC.Internal.Show.Show Chiasma.Data.CopyModeParams.CopyModeParams
+ Chiasma.Data.DecodeError: [failure] :: DecodeError -> DecodeFailure
+ Chiasma.Data.DecodeError: [output] :: DecodeError -> [Text]
+ Chiasma.Data.DecodeError: instance GHC.Internal.Show.Show Chiasma.Data.DecodeError.DecodeError
+ Chiasma.Data.DecodeError: instance GHC.Internal.Show.Show Chiasma.Data.DecodeError.DecodeFailure
+ Chiasma.Data.Direction: instance GHC.Internal.Show.Show Chiasma.Data.Direction.Direction
+ Chiasma.Data.Event: instance GHC.Internal.Show.Show Chiasma.Data.Event.Event
+ Chiasma.Data.Ident: instance Data.Default.Internal.Default Chiasma.Data.Ident.Ident
+ Chiasma.Data.Ident: instance GHC.Internal.Data.Data.Data Chiasma.Data.Ident.Ident
+ Chiasma.Data.Ident: instance GHC.Internal.Data.String.IsString Chiasma.Data.Ident.Ident
+ Chiasma.Data.Ident: instance GHC.Internal.Generics.Generic Chiasma.Data.Ident.Ident
+ Chiasma.Data.Ident: instance GHC.Internal.Show.Show Chiasma.Data.Ident.Ident
+ Chiasma.Data.KillPaneParams: [allbut] :: KillPaneParams -> Bool
+ Chiasma.Data.KillPaneParams: [target] :: KillPaneParams -> Target
+ Chiasma.Data.KillPaneParams: instance Data.Default.Internal.Default Chiasma.Data.KillPaneParams.KillPaneParams
+ Chiasma.Data.KillPaneParams: instance GHC.Internal.Show.Show Chiasma.Data.KillPaneParams.KillPaneParams
+ Chiasma.Data.LayoutError: [unLayoutError] :: LayoutError -> Text
+ Chiasma.Data.LayoutError: instance GHC.Internal.Data.String.IsString Chiasma.Data.LayoutError.LayoutError
+ Chiasma.Data.LayoutError: instance GHC.Internal.Generics.Generic Chiasma.Data.LayoutError.LayoutError
+ Chiasma.Data.LayoutError: instance GHC.Internal.Show.Show Chiasma.Data.LayoutError.LayoutError
+ Chiasma.Data.PaneSelection: instance Data.Default.Internal.Default Chiasma.Data.PaneSelection.PaneSelection
+ Chiasma.Data.PaneSelection: instance GHC.Internal.Show.Show Chiasma.Data.PaneSelection.PaneSelection
+ Chiasma.Data.PipePaneParams: [command] :: PipePaneParams -> Maybe Text
+ Chiasma.Data.PipePaneParams: [input] :: PipePaneParams -> Bool
+ Chiasma.Data.PipePaneParams: [onlyNew] :: PipePaneParams -> Bool
+ Chiasma.Data.PipePaneParams: [output] :: PipePaneParams -> Bool
+ Chiasma.Data.PipePaneParams: [target] :: PipePaneParams -> Target
+ Chiasma.Data.PipePaneParams: instance Data.Default.Internal.Default Chiasma.Data.PipePaneParams.PipePaneParams
+ Chiasma.Data.PipePaneParams: instance GHC.Internal.Show.Show Chiasma.Data.PipePaneParams.PipePaneParams
+ Chiasma.Data.ProcessError: instance GHC.Internal.Show.Show Chiasma.Data.ProcessError.ProcessError
+ Chiasma.Data.RenderError: instance GHC.Internal.Show.Show Chiasma.Data.RenderError.RenderError
+ Chiasma.Data.ResizePaneParams: [absolute] :: ResizePaneParams -> Maybe ResizeAbsolute
+ Chiasma.Data.ResizePaneParams: [adjustment] :: ResizePaneParams -> Maybe Adjustment
+ Chiasma.Data.ResizePaneParams: [mouse] :: ResizePaneParams -> Bool
+ Chiasma.Data.ResizePaneParams: [target] :: ResizePaneParams -> Target
+ Chiasma.Data.ResizePaneParams: [zoom] :: ResizePaneParams -> Bool
+ Chiasma.Data.ResizePaneParams: instance Data.Default.Internal.Default Chiasma.Data.ResizePaneParams.ResizePaneParams
+ Chiasma.Data.ResizePaneParams: instance GHC.Internal.Show.Show Chiasma.Data.ResizePaneParams.Adjustment
+ Chiasma.Data.ResizePaneParams: instance GHC.Internal.Show.Show Chiasma.Data.ResizePaneParams.ResizeAbsolute
+ Chiasma.Data.ResizePaneParams: instance GHC.Internal.Show.Show Chiasma.Data.ResizePaneParams.ResizePaneParams
+ Chiasma.Data.SelectParams: [input] :: SelectParams -> Maybe SelectInput
+ Chiasma.Data.SelectParams: [last] :: SelectParams -> Bool
+ Chiasma.Data.SelectParams: [mark] :: SelectParams -> Maybe SelectMark
+ Chiasma.Data.SelectParams: [neighbor] :: SelectParams -> Maybe Direction
+ Chiasma.Data.SelectParams: [target] :: SelectParams -> Target
+ Chiasma.Data.SelectParams: [title] :: SelectParams -> Maybe Text
+ Chiasma.Data.SelectParams: instance Data.Default.Internal.Default Chiasma.Data.SelectParams.SelectParams
+ Chiasma.Data.SelectParams: instance GHC.Internal.Show.Show Chiasma.Data.SelectParams.SelectInput
+ Chiasma.Data.SelectParams: instance GHC.Internal.Show.Show Chiasma.Data.SelectParams.SelectMark
+ Chiasma.Data.SelectParams: instance GHC.Internal.Show.Show Chiasma.Data.SelectParams.SelectParams
+ Chiasma.Data.SelectWindowParams: [last] :: SelectWindowParams -> Bool
+ Chiasma.Data.SelectWindowParams: [next] :: SelectWindowParams -> Bool
+ Chiasma.Data.SelectWindowParams: [previous] :: SelectWindowParams -> Bool
+ Chiasma.Data.SelectWindowParams: [target] :: SelectWindowParams -> Target
+ Chiasma.Data.SelectWindowParams: [toggle] :: SelectWindowParams -> Bool
+ Chiasma.Data.SelectWindowParams: instance Data.Default.Internal.Default Chiasma.Data.SelectWindowParams.SelectWindowParams
+ Chiasma.Data.SelectWindowParams: instance GHC.Internal.Show.Show Chiasma.Data.SelectWindowParams.SelectWindowParams
+ Chiasma.Data.SendKeysParams: [copyMode] :: SendKeysParams -> Bool
+ Chiasma.Data.SendKeysParams: [enter] :: SendKeysParams -> Bool
+ Chiasma.Data.SendKeysParams: [hex] :: SendKeysParams -> Bool
+ Chiasma.Data.SendKeysParams: [keys] :: SendKeysParams -> [Key]
+ Chiasma.Data.SendKeysParams: [literal] :: SendKeysParams -> Bool
+ Chiasma.Data.SendKeysParams: [mouse] :: SendKeysParams -> Bool
+ Chiasma.Data.SendKeysParams: [repeat] :: SendKeysParams -> Maybe Int
+ Chiasma.Data.SendKeysParams: [reset] :: SendKeysParams -> Bool
+ Chiasma.Data.SendKeysParams: [target] :: SendKeysParams -> Target
+ Chiasma.Data.SendKeysParams: instance Data.Default.Internal.Default Chiasma.Data.SendKeysParams.SendKeysParams
+ Chiasma.Data.SendKeysParams: instance GHC.Internal.Data.String.IsString Chiasma.Data.SendKeysParams.Key
+ Chiasma.Data.SendKeysParams: instance GHC.Internal.Show.Show Chiasma.Data.SendKeysParams.Key
+ Chiasma.Data.SendKeysParams: instance GHC.Internal.Show.Show Chiasma.Data.SendKeysParams.SendKeysParams
+ Chiasma.Data.SessionGroupId: [unSessionGroupId] :: SessionGroupId -> Text
+ Chiasma.Data.SessionGroupId: instance GHC.Internal.Data.String.IsString Chiasma.Data.SessionGroupId.SessionGroupId
+ Chiasma.Data.SessionGroupId: instance GHC.Internal.Generics.Generic Chiasma.Data.SessionGroupId.SessionGroupId
+ Chiasma.Data.SessionGroupId: instance GHC.Internal.Show.Show Chiasma.Data.SessionGroupId.SessionGroupId
+ Chiasma.Data.SessionParams: [attach] :: SessionParams -> Bool
+ Chiasma.Data.SessionParams: [command] :: SessionParams -> Maybe Text
+ Chiasma.Data.SessionParams: [cwd] :: SessionParams -> Maybe (Path Abs Dir)
+ Chiasma.Data.SessionParams: [defaultSize] :: SessionParams -> Bool
+ Chiasma.Data.SessionParams: [detach] :: SessionParams -> Bool
+ Chiasma.Data.SessionParams: [environment] :: SessionParams -> Map Text Text
+ Chiasma.Data.SessionParams: [exitClient] :: SessionParams -> Bool
+ Chiasma.Data.SessionParams: [height] :: SessionParams -> Maybe Int
+ Chiasma.Data.SessionParams: [name] :: SessionParams -> Maybe Ident
+ Chiasma.Data.SessionParams: [printInfo] :: SessionParams -> Bool
+ Chiasma.Data.SessionParams: [target] :: SessionParams -> Maybe SessionGroupId
+ Chiasma.Data.SessionParams: [width] :: SessionParams -> Maybe Int
+ Chiasma.Data.SessionParams: [windowName] :: SessionParams -> Maybe Ident
+ Chiasma.Data.SessionParams: instance Data.Default.Internal.Default Chiasma.Data.SessionParams.SessionParams
+ Chiasma.Data.SessionParams: instance GHC.Internal.Show.Show Chiasma.Data.SessionParams.SessionParams
+ Chiasma.Data.SplitParams: [axis] :: JoinPaneParams -> Maybe Axis
+ Chiasma.Data.SplitParams: [before] :: JoinPaneParams -> Bool
+ Chiasma.Data.SplitParams: [detach] :: JoinPaneParams -> Bool
+ Chiasma.Data.SplitParams: [fullSize] :: SplitWindowParams -> Bool
+ Chiasma.Data.SplitParams: [readStdin] :: SplitWindowParams -> Bool
+ Chiasma.Data.SplitParams: [size] :: JoinPaneParams -> Maybe SplitSize
+ Chiasma.Data.SplitParams: [source] :: JoinPaneParams -> Maybe Target
+ Chiasma.Data.SplitParams: [target] :: JoinPaneParams -> Target
+ Chiasma.Data.SplitParams: instance Data.Default.Internal.Default Chiasma.Data.SplitParams.JoinPaneParams
+ Chiasma.Data.SplitParams: instance Data.Default.Internal.Default Chiasma.Data.SplitParams.SplitWindowParams
+ Chiasma.Data.SplitParams: instance GHC.Internal.Show.Show Chiasma.Data.SplitParams.JoinPaneParams
+ Chiasma.Data.SplitParams: instance GHC.Internal.Show.Show Chiasma.Data.SplitParams.SplitSize
+ Chiasma.Data.SplitParams: instance GHC.Internal.Show.Show Chiasma.Data.SplitParams.SplitWindowParams
+ Chiasma.Data.Target: instance Data.Default.Internal.Default Chiasma.Data.Target.Target
+ Chiasma.Data.Target: instance GHC.Internal.Show.Show Chiasma.Data.Target.Target
+ Chiasma.Data.TmuxCommand: instance GHC.Internal.Base.Functor Chiasma.Data.TmuxCommand.TmuxCommand
+ Chiasma.Data.TmuxCommand: instance GHC.Internal.Show.Show (Chiasma.Data.TmuxCommand.TmuxCommand a)
+ Chiasma.Data.TmuxError: instance GHC.Internal.Show.Show Chiasma.Data.TmuxError.TmuxError
+ Chiasma.Data.TmuxId: [unClientId] :: ClientId -> Text
+ Chiasma.Data.TmuxId: [unTmuxIdPrefix] :: TmuxIdPrefix (a :: k) -> Text
+ Chiasma.Data.TmuxId: instance GHC.Internal.Data.Data.Data Chiasma.Data.TmuxId.PaneId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Data.String.IsString Chiasma.Data.TmuxId.ClientId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Generics.Generic Chiasma.Data.TmuxId.ClientId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Generics.Generic Chiasma.Data.TmuxId.PaneId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Generics.Generic Chiasma.Data.TmuxId.SessionId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Generics.Generic Chiasma.Data.TmuxId.WindowId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Num.Num Chiasma.Data.TmuxId.PaneId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Num.Num Chiasma.Data.TmuxId.SessionId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Num.Num Chiasma.Data.TmuxId.WindowId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Show.Show Chiasma.Data.TmuxId.ClientId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Show.Show Chiasma.Data.TmuxId.PaneId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Show.Show Chiasma.Data.TmuxId.SessionId
+ Chiasma.Data.TmuxId: instance GHC.Internal.Show.Show Chiasma.Data.TmuxId.WindowId
+ Chiasma.Data.TmuxId: instance forall k (a :: k). GHC.Internal.Data.String.IsString (Chiasma.Data.TmuxId.TmuxIdPrefix a)
+ Chiasma.Data.TmuxId: instance forall k (a :: k). GHC.Internal.Generics.Generic (Chiasma.Data.TmuxId.TmuxIdPrefix a)
+ Chiasma.Data.TmuxId: instance forall k (a :: k). GHC.Internal.Show.Show (Chiasma.Data.TmuxId.TmuxIdPrefix a)
+ Chiasma.Data.TmuxNative: [executable] :: TmuxNative -> Path Abs File
+ Chiasma.Data.TmuxNative: [tmuxServerSocket] :: TmuxNative -> Maybe (Path Abs File)
+ Chiasma.Data.TmuxNative: instance GHC.Internal.Show.Show Chiasma.Data.TmuxNative.TmuxNative
+ Chiasma.Data.TmuxOutputBlock: instance GHC.Internal.Show.Show Chiasma.Data.TmuxOutputBlock.End
+ Chiasma.Data.TmuxOutputBlock: instance GHC.Internal.Show.Show Chiasma.Data.TmuxOutputBlock.TmuxOutputBlock
+ Chiasma.Data.TmuxQuery: [unTmuxQuery] :: TmuxQuery -> Text
+ Chiasma.Data.TmuxQuery: instance GHC.Internal.Base.Monoid Chiasma.Data.TmuxQuery.TmuxQuery
+ Chiasma.Data.TmuxQuery: instance GHC.Internal.Base.Semigroup Chiasma.Data.TmuxQuery.TmuxQuery
+ Chiasma.Data.TmuxQuery: instance GHC.Internal.Data.String.IsString Chiasma.Data.TmuxQuery.TmuxQuery
+ Chiasma.Data.TmuxQuery: instance GHC.Internal.Generics.Generic Chiasma.Data.TmuxQuery.TmuxQuery
+ Chiasma.Data.TmuxQuery: instance GHC.Internal.Show.Show Chiasma.Data.TmuxQuery.TmuxQuery
+ Chiasma.Data.TmuxRequest: [args] :: TmuxRequest -> [Text]
+ Chiasma.Data.TmuxRequest: [cmd] :: TmuxRequest -> Text
+ Chiasma.Data.TmuxRequest: [query] :: TmuxRequest -> Maybe TmuxQuery
+ Chiasma.Data.TmuxRequest: instance GHC.Internal.Show.Show Chiasma.Data.TmuxRequest.TmuxRequest
+ Chiasma.Data.TmuxResponse: [unTmuxResponse] :: TmuxResponse -> [Text]
+ Chiasma.Data.TmuxResponse: instance GHC.Internal.Base.Monoid Chiasma.Data.TmuxResponse.TmuxResponse
+ Chiasma.Data.TmuxResponse: instance GHC.Internal.Base.Semigroup Chiasma.Data.TmuxResponse.TmuxResponse
+ Chiasma.Data.TmuxResponse: instance GHC.Internal.Show.Show Chiasma.Data.TmuxResponse.TmuxResponse
+ Chiasma.Data.View: [id] :: View a -> Maybe a
+ Chiasma.Data.View: [ident] :: View a -> Ident
+ Chiasma.Data.View: instance GHC.Internal.Generics.Generic (Chiasma.Data.View.View a)
+ Chiasma.Data.View: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Chiasma.Data.View.View a)
+ Chiasma.Data.Views: [_log] :: Views -> [Doc AnsiStyle]
+ Chiasma.Data.Views: [_panes] :: Views -> [View PaneId]
+ Chiasma.Data.Views: [_sessions] :: Views -> [View SessionId]
+ Chiasma.Data.Views: [_windows] :: Views -> [View WindowId]
+ Chiasma.Data.Views: instance Data.Default.Internal.Default Chiasma.Data.Views.Views
+ Chiasma.Data.Views: instance GHC.Internal.Generics.Generic Chiasma.Data.Views.Views
+ Chiasma.Data.Views: instance GHC.Internal.Show.Show Chiasma.Data.Views.Views
+ Chiasma.Data.Views: instance GHC.Internal.Show.Show Chiasma.Data.Views.ViewsError
+ Chiasma.Data.WindowParams: [after] :: WindowParams -> Bool
+ Chiasma.Data.WindowParams: [command] :: WindowParams -> Maybe Text
+ Chiasma.Data.WindowParams: [cwd] :: WindowParams -> Maybe (Path Abs Dir)
+ Chiasma.Data.WindowParams: [detach] :: WindowParams -> Bool
+ Chiasma.Data.WindowParams: [environment] :: WindowParams -> Map Text Text
+ Chiasma.Data.WindowParams: [killExisting] :: WindowParams -> Bool
+ Chiasma.Data.WindowParams: [name] :: WindowParams -> Maybe Ident
+ Chiasma.Data.WindowParams: [printInfo] :: WindowParams -> Bool
+ Chiasma.Data.WindowParams: [target] :: WindowParams -> Target
+ Chiasma.Data.WindowParams: instance Data.Default.Internal.Default Chiasma.Data.WindowParams.WindowParams
+ Chiasma.Data.WindowParams: instance GHC.Internal.Show.Show Chiasma.Data.WindowParams.WindowParams
+ Chiasma.Data.WindowSelection: instance Data.Default.Internal.Default Chiasma.Data.WindowSelection.WindowSelection
+ Chiasma.Data.WindowSelection: instance GHC.Internal.Show.Show Chiasma.Data.WindowSelection.WindowSelection
+ Chiasma.Data.WindowState: [wsLayout] :: WindowState -> RenderableTree
+ Chiasma.Data.WindowState: [wsNativeRefPane] :: WindowState -> Pane
+ Chiasma.Data.WindowState: [wsNativeWindow] :: WindowState -> Window
+ Chiasma.Data.WindowState: [wsReferencePane] :: WindowState -> PaneId
+ Chiasma.Data.WindowState: [wsWindowIdent] :: WindowState -> Ident
+ Chiasma.Data.WindowState: instance GHC.Internal.Show.Show Chiasma.Data.WindowState.WindowState
+ Chiasma.Data.WithPaneId: [paneId] :: WithPaneId a -> PaneId
+ Chiasma.Data.WithPaneId: [pane] :: WithPaneId a -> a
+ Chiasma.Data.WithPaneId: instance GHC.Internal.Generics.Generic (Chiasma.Data.WithPaneId.WithPaneId a)
+ Chiasma.Data.WithPaneId: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Chiasma.Data.WithPaneId.WithPaneId a)
+ Chiasma.Lens.Tree: [litTree] :: LeafIndexTree l p -> Tree l p
+ Chiasma.Lens.Tree: [nitTree] :: NodeIndexTree l p -> Tree l p
+ Chiasma.Lens.Tree: instance (GHC.Internal.Data.Data.Data l, GHC.Internal.Data.Data.Data p) => Control.Lens.Plated.Plated (Chiasma.Lens.Tree.LeafIndexTree l p)
+ Chiasma.Lens.Tree: instance (GHC.Internal.Data.Data.Data l, GHC.Internal.Data.Data.Data p) => Control.Lens.Plated.Plated (Chiasma.Lens.Tree.NodeIndexTree l p)
+ Chiasma.Lens.Tree: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show p) => GHC.Internal.Show.Show (Chiasma.Lens.Tree.LeafIndexTree l p)
+ Chiasma.Lens.Tree: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show p) => GHC.Internal.Show.Show (Chiasma.Lens.Tree.NodeIndexTree l p)
+ Chiasma.Ui.Data.Measure: [_axis] :: MLayout -> Axis
+ Chiasma.Ui.Data.Measure: [_lMainPosition] :: MLayout -> Int
+ Chiasma.Ui.Data.Measure: [_lOffPosition] :: MLayout -> Int
+ Chiasma.Ui.Data.Measure: [_mainPosition] :: MPane -> Int
+ Chiasma.Ui.Data.Measure: [_offPosition] :: MPane -> Int
+ Chiasma.Ui.Data.Measure: [_paneId] :: MPane -> PaneId
+ Chiasma.Ui.Data.Measure: [_reference] :: MLayout -> PaneId
+ Chiasma.Ui.Data.Measure: [_size] :: Measured a -> Int
+ Chiasma.Ui.Data.Measure: [_view] :: Measured a -> a
+ Chiasma.Ui.Data.Measure: instance GHC.Internal.Show.Show Chiasma.Ui.Data.Measure.MLayout
+ Chiasma.Ui.Data.Measure: instance GHC.Internal.Show.Show Chiasma.Ui.Data.Measure.MPane
+ Chiasma.Ui.Data.Measure: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Chiasma.Ui.Data.Measure.Measured a)
+ Chiasma.Ui.Data.RenderableTree: [_axis] :: RLayout -> Axis
+ Chiasma.Ui.Data.RenderableTree: [_geometry] :: Renderable a -> ViewGeometry
+ Chiasma.Ui.Data.RenderableTree: [_id] :: RPane -> PaneId
+ Chiasma.Ui.Data.RenderableTree: [_left] :: RPane -> Int
+ Chiasma.Ui.Data.RenderableTree: [_ref] :: RLayout -> RPane
+ Chiasma.Ui.Data.RenderableTree: [_state] :: Renderable a -> ViewState
+ Chiasma.Ui.Data.RenderableTree: [_top] :: RPane -> Int
+ Chiasma.Ui.Data.RenderableTree: [_view] :: Renderable a -> a
+ Chiasma.Ui.Data.RenderableTree: instance GHC.Internal.Show.Show Chiasma.Ui.Data.RenderableTree.RLayout
+ Chiasma.Ui.Data.RenderableTree: instance GHC.Internal.Show.Show Chiasma.Ui.Data.RenderableTree.RPane
+ Chiasma.Ui.Data.RenderableTree: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Chiasma.Ui.Data.RenderableTree.Renderable a)
+ Chiasma.Ui.Data.Tree: [_forest] :: Tree (f :: Type -> Type) l p -> f (Node f l p)
+ Chiasma.Ui.Data.Tree: [_leafData] :: Node (f :: Type -> Type) l p -> p
+ Chiasma.Ui.Data.Tree: [_subTree] :: Node (f :: Type -> Type) l p -> Tree f l p
+ Chiasma.Ui.Data.Tree: [_treeData] :: Tree (f :: Type -> Type) l p -> l
+ Chiasma.Ui.Data.Tree: instance (GHC.Classes.Eq l, GHC.Classes.Eq (Chiasma.Ui.Data.Tree.Node GHC.Internal.Base.NonEmpty l p)) => GHC.Classes.Eq (Chiasma.Ui.Data.Tree.Tree GHC.Internal.Base.NonEmpty l p)
+ Chiasma.Ui.Data.Tree: instance (GHC.Classes.Eq l, GHC.Classes.Eq p) => GHC.Classes.Eq (Chiasma.Ui.Data.Tree.Node GHC.Internal.Base.NonEmpty l p)
+ Chiasma.Ui.Data.Tree: instance (GHC.Internal.Data.Foldable.Foldable f, Prettyprinter.Internal.Pretty l, Prettyprinter.Internal.Pretty p) => Prettyprinter.Internal.Pretty (Chiasma.Ui.Data.Tree.Node f l p)
+ Chiasma.Ui.Data.Tree: instance (GHC.Internal.Data.Foldable.Foldable f, Prettyprinter.Internal.Pretty l, Prettyprinter.Internal.Pretty p) => Prettyprinter.Internal.Pretty (Chiasma.Ui.Data.Tree.Tree f l p)
+ Chiasma.Ui.Data.Tree: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show (Chiasma.Ui.Data.Tree.Node GHC.Internal.Base.NonEmpty l p)) => GHC.Internal.Show.Show (Chiasma.Ui.Data.Tree.Tree GHC.Internal.Base.NonEmpty l p)
+ Chiasma.Ui.Data.Tree: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show (Chiasma.Ui.Data.Tree.Node [] l p)) => GHC.Internal.Show.Show (Chiasma.Ui.Data.Tree.Tree [] l p)
+ Chiasma.Ui.Data.Tree: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show p) => GHC.Internal.Show.Show (Chiasma.Ui.Data.Tree.Node GHC.Internal.Base.NonEmpty l p)
+ Chiasma.Ui.Data.Tree: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show p) => GHC.Internal.Show.Show (Chiasma.Ui.Data.Tree.Node [] l p)
+ Chiasma.Ui.Data.TreeModError: instance GHC.Internal.Show.Show Chiasma.Ui.Data.TreeModError.TreeModError
+ Chiasma.Ui.Data.View: [axis] :: Layout -> Axis
+ Chiasma.Ui.Data.View: [cwd] :: Pane -> Maybe Text
+ Chiasma.Ui.Data.View: [extra] :: View a -> a
+ Chiasma.Ui.Data.View: [geometry] :: View a -> ViewGeometry
+ Chiasma.Ui.Data.View: [ident] :: View a -> Ident
+ Chiasma.Ui.Data.View: [leafData] :: TreeSub l p -> p
+ Chiasma.Ui.Data.View: [open] :: Pane -> Bool
+ Chiasma.Ui.Data.View: [pin] :: Pane -> Bool
+ Chiasma.Ui.Data.View: [state] :: View a -> ViewState
+ Chiasma.Ui.Data.View: [subTree] :: TreeSub l p -> Tree l p
+ Chiasma.Ui.Data.View: [treeData] :: Tree l p -> l
+ Chiasma.Ui.Data.View: [treeSubs] :: Tree l p -> [TreeSub l p]
+ Chiasma.Ui.Data.View: instance (GHC.Internal.Data.Data.Data l, GHC.Internal.Data.Data.Data p) => Control.Lens.Plated.Plated (Chiasma.Ui.Data.View.Tree l p)
+ Chiasma.Ui.Data.View: instance (GHC.Internal.Data.Data.Data l, GHC.Internal.Data.Data.Data p) => GHC.Internal.Data.Data.Data (Chiasma.Ui.Data.View.TreeSub l p)
+ Chiasma.Ui.Data.View: instance (GHC.Internal.Data.Data.Data p, GHC.Internal.Data.Data.Data l) => GHC.Internal.Data.Data.Data (Chiasma.Ui.Data.View.Tree l p)
+ Chiasma.Ui.Data.View: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show p) => GHC.Internal.Show.Show (Chiasma.Ui.Data.View.Tree l p)
+ Chiasma.Ui.Data.View: instance (GHC.Internal.Show.Show l, GHC.Internal.Show.Show p) => GHC.Internal.Show.Show (Chiasma.Ui.Data.View.TreeSub l p)
+ Chiasma.Ui.Data.View: instance Data.Default.Internal.Default Chiasma.Ui.Data.View.Layout
+ Chiasma.Ui.Data.View: instance Data.Default.Internal.Default Chiasma.Ui.Data.View.Pane
+ Chiasma.Ui.Data.View: instance Data.Default.Internal.Default a => Data.Default.Internal.Default (Chiasma.Ui.Data.View.View a)
+ Chiasma.Ui.Data.View: instance GHC.Internal.Base.Functor (Chiasma.Ui.Data.View.Tree l)
+ Chiasma.Ui.Data.View: instance GHC.Internal.Base.Functor (Chiasma.Ui.Data.View.TreeSub l)
+ Chiasma.Ui.Data.View: instance GHC.Internal.Data.Data.Data Chiasma.Ui.Data.View.Layout
+ Chiasma.Ui.Data.View: instance GHC.Internal.Data.Data.Data Chiasma.Ui.Data.View.Pane
+ Chiasma.Ui.Data.View: instance GHC.Internal.Data.Data.Data a => GHC.Internal.Data.Data.Data (Chiasma.Ui.Data.View.View a)
+ Chiasma.Ui.Data.View: instance GHC.Internal.Generics.Generic (Chiasma.Ui.Data.View.Tree l p)
+ Chiasma.Ui.Data.View: instance GHC.Internal.Generics.Generic (Chiasma.Ui.Data.View.TreeSub l p)
+ Chiasma.Ui.Data.View: instance GHC.Internal.Generics.Generic (Chiasma.Ui.Data.View.View a)
+ Chiasma.Ui.Data.View: instance GHC.Internal.Generics.Generic Chiasma.Ui.Data.View.Layout
+ Chiasma.Ui.Data.View: instance GHC.Internal.Generics.Generic Chiasma.Ui.Data.View.Pane
+ Chiasma.Ui.Data.View: instance GHC.Internal.Show.Show Chiasma.Ui.Data.View.Layout
+ Chiasma.Ui.Data.View: instance GHC.Internal.Show.Show Chiasma.Ui.Data.View.Pane
+ Chiasma.Ui.Data.View: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Chiasma.Ui.Data.View.View a)
+ Chiasma.Ui.Data.ViewGeometry: [fixedSize] :: ViewGeometry -> Maybe Float
+ Chiasma.Ui.Data.ViewGeometry: [maxSize] :: ViewGeometry -> Maybe Float
+ Chiasma.Ui.Data.ViewGeometry: [minSize] :: ViewGeometry -> Maybe Float
+ Chiasma.Ui.Data.ViewGeometry: [minimizedSize] :: ViewGeometry -> Maybe Float
+ Chiasma.Ui.Data.ViewGeometry: [position] :: ViewGeometry -> Maybe Float
+ Chiasma.Ui.Data.ViewGeometry: [weight] :: ViewGeometry -> Maybe Float
+ Chiasma.Ui.Data.ViewGeometry: instance Data.Default.Internal.Default Chiasma.Ui.Data.ViewGeometry.ViewGeometry
+ Chiasma.Ui.Data.ViewGeometry: instance GHC.Internal.Data.Data.Data Chiasma.Ui.Data.ViewGeometry.ViewGeometry
+ Chiasma.Ui.Data.ViewGeometry: instance GHC.Internal.Generics.Generic Chiasma.Ui.Data.ViewGeometry.ViewGeometry
+ Chiasma.Ui.Data.ViewGeometry: instance GHC.Internal.Show.Show Chiasma.Ui.Data.ViewGeometry.ViewGeometry
+ Chiasma.Ui.Data.ViewState: [minimized] :: ViewState -> Bool
+ Chiasma.Ui.Data.ViewState: instance Data.Default.Internal.Default Chiasma.Ui.Data.ViewState.ViewState
+ Chiasma.Ui.Data.ViewState: instance GHC.Internal.Data.Data.Data Chiasma.Ui.Data.ViewState.ViewState
+ Chiasma.Ui.Data.ViewState: instance GHC.Internal.Generics.Generic Chiasma.Ui.Data.ViewState.ViewState
+ Chiasma.Ui.Data.ViewState: instance GHC.Internal.Show.Show Chiasma.Ui.Data.ViewState.ViewState
+ Chiasma.Ui.Measure.Balance: [balanceMax] :: Balance -> NonEmpty (Maybe Float)
+ Chiasma.Ui.Measure.Balance: [balanceMin] :: Balance -> NonEmpty Float
+ Chiasma.Ui.Measure.Balance: [balanceMinimized] :: Balance -> NonEmpty Bool
+ Chiasma.Ui.Measure.Balance: [balanceTotal] :: Balance -> Float
+ Chiasma.Ui.Measure.Balance: [balanceWeights] :: Balance -> NonEmpty Float
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Base.Applicative Chiasma.Ui.ViewTree.ToggleResult
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Base.Functor Chiasma.Ui.ViewTree.ToggleResult
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Base.Monad Chiasma.Ui.ViewTree.ToggleResult
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Base.Monoid (Chiasma.Ui.ViewTree.ToggleResult a)
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Base.Monoid Chiasma.Ui.ViewTree.ToggleStatus
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Base.Semigroup (Chiasma.Ui.ViewTree.ToggleResult a)
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Base.Semigroup Chiasma.Ui.ViewTree.ToggleStatus
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Show.Show Chiasma.Ui.ViewTree.ToggleStatus
+ Chiasma.Ui.ViewTree: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Chiasma.Ui.ViewTree.ToggleResult a)
- Chiasma: data Codec (command :: Type -> Type) (i :: Type) (o :: Type) :: Effect
+ Chiasma: data Codec (command :: Type -> Type) i o (a :: Type -> Type) b
- Chiasma: data TmuxApi (command :: Type -> Type) :: Effect
+ Chiasma: data TmuxApi (command :: Type -> Type) (a :: Type -> Type) b
- Chiasma: type NativeCodec command = Codec command TmuxRequest TmuxResponse
+ Chiasma: type NativeCodec (command :: Type -> Type) = Codec command TmuxRequest TmuxResponse
- Chiasma: type NativeCodecE command = NativeCodec command !! CodecError
+ Chiasma: type NativeCodecE (command :: Type -> Type) = NativeCodec command !! CodecError
- Chiasma.Codec: decode :: (TmuxCodec a, Generic a) => TmuxDataDecode (Rep a) => Text -> Either DecodeError a
+ Chiasma.Codec: decode :: TmuxCodec a => Text -> Either DecodeError a
- Chiasma.Codec: genDecode :: Generic a => TmuxDataDecode (Rep a) => Text -> Either DecodeError a
+ Chiasma.Codec: genDecode :: (Generic a, TmuxDataDecode (Rep a)) => Text -> Either DecodeError a
- Chiasma.Codec: query :: (TmuxCodec a, TmuxDataQuery (Rep a)) => TmuxQuery
+ Chiasma.Codec: query :: TmuxCodec a => TmuxQuery
- Chiasma.Codec.Decode: class TmuxDataDecode f
+ Chiasma.Codec.Decode: class TmuxDataDecode (f :: k -> Type)
- Chiasma.Codec.Decode: dataDecode :: TmuxDataDecode f => [Text] -> Either DecodeFailure ([Text], f a)
+ Chiasma.Codec.Decode: dataDecode :: forall (a :: k). TmuxDataDecode f => [Text] -> Either DecodeFailure ([Text], f a)
- Chiasma.Codec.Query: class TmuxDataQuery f
+ Chiasma.Codec.Query: class TmuxDataQuery (f :: k)
- Chiasma.Command.Pane: capturePane :: Member Tmux r => PaneId -> Sem r [Text]
+ Chiasma.Command.Pane: capturePane :: forall (r :: EffectRow). Member Tmux r => PaneId -> Sem r [Text]
- Chiasma.Command.Pane: closePane :: Member Tmux r => PaneId -> Sem r ()
+ Chiasma.Command.Pane: closePane :: forall (r :: EffectRow). Member Tmux r => PaneId -> Sem r ()
- Chiasma.Command.Pane: copyMode :: Member Tmux r => PaneId -> Sem r ()
+ Chiasma.Command.Pane: copyMode :: forall (r :: EffectRow). Member Tmux r => PaneId -> Sem r ()
- Chiasma.Command.Pane: firstWindowPane :: Member (TmuxPanes a) r => WindowId -> Sem r a
+ Chiasma.Command.Pane: firstWindowPane :: forall a (r :: EffectRow). Member (TmuxPanes a) r => WindowId -> Sem r a
- Chiasma.Command.Pane: isPaneIdOpen :: Member (TmuxPanes Pane) r => PaneId -> Sem r Bool
+ Chiasma.Command.Pane: isPaneIdOpen :: forall (r :: EffectRow). Member (TmuxPanes Pane) r => PaneId -> Sem r Bool
- Chiasma.Command.Pane: isPaneOpen :: Member (TmuxPanes Pane) r => View PaneId -> Sem r Bool
+ Chiasma.Command.Pane: isPaneOpen :: forall (r :: EffectRow). Member (TmuxPanes Pane) r => View PaneId -> Sem r Bool
- Chiasma.Command.Pane: movePane :: Member Tmux r => PaneId -> PaneId -> Axis -> Sem r ()
+ Chiasma.Command.Pane: movePane :: forall (r :: EffectRow). Member Tmux r => PaneId -> PaneId -> Axis -> Sem r ()
- Chiasma.Command.Pane: pane :: Member (TmuxPanes a) r => PaneId -> Sem r (Maybe a)
+ Chiasma.Command.Pane: pane :: forall a (r :: EffectRow). Member (TmuxPanes a) r => PaneId -> Sem r (Maybe a)
- Chiasma.Command.Pane: paneMode :: Member (TmuxPanes PaneMode) r => PaneId -> Sem r (Maybe PaneMode)
+ Chiasma.Command.Pane: paneMode :: forall (r :: EffectRow). Member (TmuxPanes PaneMode) r => PaneId -> Sem r (Maybe PaneMode)
- Chiasma.Command.Pane: panes :: Member (TmuxPanes a) r => Sem r [a]
+ Chiasma.Command.Pane: panes :: forall a (r :: EffectRow). Member (TmuxPanes a) r => Sem r [a]
- Chiasma.Command.Pane: pipePane :: Member Tmux r => PaneId -> Text -> Sem r ()
+ Chiasma.Command.Pane: pipePane :: forall (r :: EffectRow). Member Tmux r => PaneId -> Text -> Sem r ()
- Chiasma.Command.Pane: quitCopyMode :: Member Tmux r => Member (TmuxPanes PaneMode) r => PaneId -> Sem r ()
+ Chiasma.Command.Pane: quitCopyMode :: forall (r :: EffectRow). (Member Tmux r, Member (TmuxPanes PaneMode) r) => PaneId -> Sem r ()
- Chiasma.Command.Pane: resizePane :: Member Tmux r => PaneId -> Axis -> Int -> Sem r ()
+ Chiasma.Command.Pane: resizePane :: forall (r :: EffectRow). Member Tmux r => PaneId -> Axis -> Int -> Sem r ()
- Chiasma.Command.Pane: selectPane :: Member Tmux r => PaneId -> Sem r ()
+ Chiasma.Command.Pane: selectPane :: forall (r :: EffectRow). Member Tmux r => PaneId -> Sem r ()
- Chiasma.Command.Pane: sendKeys :: Member Tmux r => PaneId -> [Key] -> Sem r ()
+ Chiasma.Command.Pane: sendKeys :: forall (r :: EffectRow). Member Tmux r => PaneId -> [Key] -> Sem r ()
- Chiasma.Command.Pane: windowPanes :: Member (TmuxPanes a) r => WindowId -> Sem r [a]
+ Chiasma.Command.Pane: windowPanes :: forall a (r :: EffectRow). Member (TmuxPanes a) r => WindowId -> Sem r [a]
- Chiasma.Command.Session: doesSessionExist :: Member Tmux r => SessionId -> Sem r Bool
+ Chiasma.Command.Session: doesSessionExist :: forall (r :: EffectRow). Member Tmux r => SessionId -> Sem r Bool
- Chiasma.Command.Session: existingSessionId :: Member Tmux r => SessionId -> Sem r (Maybe SessionId)
+ Chiasma.Command.Session: existingSessionId :: forall (r :: EffectRow). Member Tmux r => SessionId -> Sem r (Maybe SessionId)
- Chiasma.Command.Session: newSession :: Member Tmux r => Ident -> Sem r Session
+ Chiasma.Command.Session: newSession :: forall (r :: EffectRow). Member Tmux r => Ident -> Sem r Session
- Chiasma.Command.Session: sessions :: Member Tmux r => Sem r [Session]
+ Chiasma.Command.Session: sessions :: forall (r :: EffectRow). Member Tmux r => Sem r [Session]
- Chiasma.Command.Session: switchClient :: Members [Tmux, Stop TmuxError] r => SessionId -> SessionId -> Sem r ()
+ Chiasma.Command.Session: switchClient :: forall (r :: EffectRow). Members '[Tmux, Stop TmuxError] r => SessionId -> SessionId -> Sem r ()
- Chiasma.Command.Window: doesWindowExist :: Member Tmux r => WindowId -> Sem r Bool
+ Chiasma.Command.Window: doesWindowExist :: forall (r :: EffectRow). Member Tmux r => WindowId -> Sem r Bool
- Chiasma.Command.Window: newSessionWindow :: Members [Tmux, Stop LayoutError] r => SessionId -> Sem r Window
+ Chiasma.Command.Window: newSessionWindow :: forall (r :: EffectRow). Members '[Tmux, Stop LayoutError] r => SessionId -> Sem r Window
- Chiasma.Command.Window: newWindow :: Member Tmux r => SessionId -> Ident -> Sem r Window
+ Chiasma.Command.Window: newWindow :: forall (r :: EffectRow). Member Tmux r => SessionId -> Ident -> Sem r Window
- Chiasma.Command.Window: sessionWindows :: Member Tmux r => SessionId -> Sem r [Window]
+ Chiasma.Command.Window: sessionWindows :: forall (r :: EffectRow). Member Tmux r => SessionId -> Sem r [Window]
- Chiasma.Command.Window: splitWindow :: Member Tmux r => WindowId -> Sem r Pane
+ Chiasma.Command.Window: splitWindow :: forall (r :: EffectRow). Member Tmux r => WindowId -> Sem r Pane
- Chiasma.Command.Window: splitWindowInDir :: Member Tmux r => Path Abs Dir -> WindowId -> Sem r Pane
+ Chiasma.Command.Window: splitWindowInDir :: forall (r :: EffectRow). Member Tmux r => Path Abs Dir -> WindowId -> Sem r Pane
- Chiasma.Command.Window: window :: Member Tmux r => WindowId -> Sem r (Maybe Window)
+ Chiasma.Command.Window: window :: forall (r :: EffectRow). Member Tmux r => WindowId -> Sem r (Maybe Window)
- Chiasma.Command.Window: windows :: Member Tmux r => Sem r [Window]
+ Chiasma.Command.Window: windows :: forall (r :: EffectRow). Member Tmux r => Sem r [Window]
- Chiasma.Data.Ident: sameIdent :: Identifiable a => Identifiable b => a -> b -> Bool
+ Chiasma.Data.Ident: sameIdent :: (Identifiable a, Identifiable b) => a -> b -> Bool
- Chiasma.Data.Panes: [Find] :: PaneId -> Panes p (Maybe p)
+ Chiasma.Data.Panes: [Find] :: forall p. PaneId -> Panes p (Maybe p)
- Chiasma.Data.Panes: [First] :: PaneSelection -> Panes p p
+ Chiasma.Data.Panes: [First] :: forall p. PaneSelection -> Panes p p
- Chiasma.Data.Panes: [Get] :: PaneId -> Panes p p
+ Chiasma.Data.Panes: [Get] :: forall p. PaneId -> Panes p p
- Chiasma.Data.Panes: [List] :: PaneSelection -> Panes p [p]
+ Chiasma.Data.Panes: [List] :: forall p. PaneSelection -> Panes p [p]
- Chiasma.Data.Panes: [One] :: PaneSelection -> Panes p p
+ Chiasma.Data.Panes: [One] :: forall p. PaneSelection -> Panes p p
- Chiasma.Data.Panes: data Panes (p :: Type) (a :: Type) :: Type
+ Chiasma.Data.Panes: data Panes p a
- Chiasma.Data.Panes: decode :: forall p a. TmuxCodec p => TmuxResponse -> Panes p a -> Either DecodeError a
+ Chiasma.Data.Panes: decode :: TmuxCodec p => TmuxResponse -> Panes p a -> Either DecodeError a
- Chiasma.Data.Panes: encode :: forall p a. TmuxCodec p => Panes p a -> TmuxRequest
+ Chiasma.Data.Panes: encode :: TmuxCodec p => Panes p a -> TmuxRequest
- Chiasma.Data.Panes: query :: forall p a. TmuxCodec p => Panes p a -> TmuxQuery
+ Chiasma.Data.Panes: query :: TmuxCodec p => Panes p a -> TmuxQuery
- Chiasma.Data.Panes: type TmuxPanes p = TmuxApi (Panes p)
+ Chiasma.Data.Panes: type TmuxPanes p = TmuxApi Panes p
- Chiasma.Data.ReceiveEvent: data ReceiveEvent :: Type -> Type
+ Chiasma.Data.ReceiveEvent: data ReceiveEvent a
- Chiasma.Data.TmuxCommand: [Fmap] :: (a -> b) -> TmuxCommand a -> TmuxCommand b
+ Chiasma.Data.TmuxCommand: [Fmap] :: forall a1 a. (a1 -> a) -> TmuxCommand a1 -> TmuxCommand a
- Chiasma.Data.TmuxCommand: data TmuxCommand :: Type -> Type
+ Chiasma.Data.TmuxCommand: data TmuxCommand a
- Chiasma.Data.TmuxCommand: query :: forall a. TmuxCommand a -> Maybe TmuxQuery
+ Chiasma.Data.TmuxCommand: query :: TmuxCommand a -> Maybe TmuxQuery
- Chiasma.Data.TmuxId: TmuxIdPrefix :: Text -> TmuxIdPrefix a
+ Chiasma.Data.TmuxId: TmuxIdPrefix :: Text -> TmuxIdPrefix (a :: k)
- Chiasma.Data.TmuxId: newtype TmuxIdPrefix a
+ Chiasma.Data.TmuxId: newtype TmuxIdPrefix (a :: k)
- Chiasma.Data.Views: class HasViews c_a16BP
+ Chiasma.Data.Views: class HasViews c
- Chiasma.Data.Views: log :: HasViews c_a16BP => Lens' c_a16BP [Doc AnsiStyle]
+ Chiasma.Data.Views: log :: HasViews c => Lens' c [Doc AnsiStyle]
- Chiasma.Data.Views: panes :: HasViews c_a16BP => Lens' c_a16BP [View PaneId]
+ Chiasma.Data.Views: panes :: HasViews c => Lens' c [View PaneId]
- Chiasma.Data.Views: sessions :: HasViews c_a16BP => Lens' c_a16BP [View SessionId]
+ Chiasma.Data.Views: sessions :: HasViews c => Lens' c [View SessionId]
- Chiasma.Data.Views: views :: HasViews c_a16BP => Lens' c_a16BP Views
+ Chiasma.Data.Views: views :: HasViews c => Lens' c Views
- Chiasma.Data.Views: windows :: HasViews c_a16BP => Lens' c_a16BP [View WindowId]
+ Chiasma.Data.Views: windows :: HasViews c => Lens' c [View WindowId]
- Chiasma.Effect.Codec: [Encode] :: command a -> Codec command i o m i
+ Chiasma.Effect.Codec: [Encode] :: forall (command :: Type -> Type) a1 i o (a :: Type -> Type). command a1 -> Codec command i o a i
- Chiasma.Effect.Codec: [WithCodec] :: command a -> (i -> m o) -> Codec command i o m a
+ Chiasma.Effect.Codec: [WithCodec] :: forall (command :: Type -> Type) b i (a :: Type -> Type) o. command b -> (i -> a o) -> Codec command i o a b
- Chiasma.Effect.Codec: data Codec (command :: Type -> Type) (i :: Type) (o :: Type) :: Effect
+ Chiasma.Effect.Codec: data Codec (command :: Type -> Type) i o (a :: Type -> Type) b
- Chiasma.Effect.Codec: encode :: forall command_a1ol7 i_a1ol9 o_a1ola r_a1onv a_X0. Member (Codec command_a1ol7 i_a1ol9 o_a1ola) r_a1onv => command_a1ol7 a_X0 -> Sem r_a1onv i_a1ol9
+ Chiasma.Effect.Codec: encode :: forall command i o (r :: EffectRow) a. Member (Codec command i o) r => command a -> Sem r i
- Chiasma.Effect.Codec: type NativeCodec command = Codec command TmuxRequest TmuxResponse
+ Chiasma.Effect.Codec: type NativeCodec (command :: Type -> Type) = Codec command TmuxRequest TmuxResponse
- Chiasma.Effect.Codec: type NativeCodecE command = NativeCodec command !! CodecError
+ Chiasma.Effect.Codec: type NativeCodecE (command :: Type -> Type) = NativeCodec command !! CodecError
- Chiasma.Effect.Codec: withCodec :: forall command_a1ol2 i_a1ol4 o_a1ol6 r_a1ons a_a1ol3. Member (Codec command_a1ol2 i_a1ol4 o_a1ol6) r_a1ons => command_a1ol2 a_a1ol3 -> (i_a1ol4 -> Sem r_a1ons o_a1ol6) -> Sem r_a1ons a_a1ol3
+ Chiasma.Effect.Codec: withCodec :: forall command i o (r :: EffectRow) a. Member (Codec command i o) r => command a -> (i -> Sem r o) -> Sem r a
- Chiasma.Effect.TmuxApi: [Schedule] :: command a -> TmuxApi command m ()
+ Chiasma.Effect.TmuxApi: [Schedule] :: forall (command :: Type -> Type) a1 (a :: Type -> Type). command a1 -> TmuxApi command a ()
- Chiasma.Effect.TmuxApi: [Send] :: command a -> TmuxApi command m a
+ Chiasma.Effect.TmuxApi: [Send] :: forall (command :: Type -> Type) b (a :: Type -> Type). command b -> TmuxApi command a b
- Chiasma.Effect.TmuxApi: data TmuxApi (command :: Type -> Type) :: Effect
+ Chiasma.Effect.TmuxApi: data TmuxApi (command :: Type -> Type) (a :: Type -> Type) b
- Chiasma.Effect.TmuxApi: schedule :: forall command_a1nzb r_a1nAL a_X0. Member (TmuxApi command_a1nzb) r_a1nAL => command_a1nzb a_X0 -> Sem r_a1nAL ()
+ Chiasma.Effect.TmuxApi: schedule :: forall command (r :: EffectRow) a. Member (TmuxApi command) r => command a -> Sem r ()
- Chiasma.Effect.TmuxApi: send :: forall command_a1nz8 r_a1nAJ a_a1nz9. Member (TmuxApi command_a1nz8) r_a1nAJ => command_a1nz8 a_a1nz9 -> Sem r_a1nAJ a_a1nz9
+ Chiasma.Effect.TmuxApi: send :: forall command (r :: EffectRow) a. Member (TmuxApi command) r => command a -> Sem r a
- Chiasma.Effect.TmuxClient: [Schedule] :: i -> TmuxClient i o m ()
+ Chiasma.Effect.TmuxClient: [Schedule] :: forall i o (a :: Type -> Type). i -> TmuxClient i o a ()
- Chiasma.Effect.TmuxClient: [Send] :: i -> TmuxClient i o m o
+ Chiasma.Effect.TmuxClient: [Send] :: forall i o (a :: Type -> Type). i -> TmuxClient i o a o
- Chiasma.Effect.TmuxClient: data TmuxClient (i :: Type) (o :: Type) :: Effect
+ Chiasma.Effect.TmuxClient: data TmuxClient i o (a :: Type -> Type) b
- Chiasma.Effect.TmuxClient: flush :: Member (TmuxClient e d) r => InterpreterFor (TmuxClient e d) r
+ Chiasma.Effect.TmuxClient: flush :: forall e d (r :: EffectRow). Member (TmuxClient e d) r => InterpreterFor (TmuxClient e d) r
- Chiasma.Effect.TmuxClient: schedule :: forall i_a19I5 o_a19I6 r_a19JS. Member (TmuxClient i_a19I5 o_a19I6) r_a19JS => i_a19I5 -> Sem r_a19JS ()
+ Chiasma.Effect.TmuxClient: schedule :: forall i o (r :: EffectRow). Member (TmuxClient i o) r => i -> Sem r ()
- Chiasma.Effect.TmuxClient: send :: forall i_a19I2 o_a19I3 r_a19JQ. Member (TmuxClient i_a19I2 o_a19I3) r_a19JQ => i_a19I2 -> Sem r_a19JQ o_a19I3
+ Chiasma.Effect.TmuxClient: send :: forall i o (r :: EffectRow). Member (TmuxClient i o) r => i -> Sem r o
- Chiasma.Effect.TmuxClient: type ScopedTmux i o = Scoped_ (TmuxClient i o)
+ Chiasma.Effect.TmuxClient: type ScopedTmux i o = Scoped_ TmuxClient i o
- Chiasma.Event: listen :: forall enc dec err t d r. Show err => Member (Codec ReceiveEvent enc dec !! err) r => Members [Scoped_ (TmuxClient enc dec) !! TmuxError, Events Event, Time t d, Log] r => Sem r ()
+ Chiasma.Event: listen :: forall enc dec err t d (r :: EffectRow). (Show err, Member (Codec ReceiveEvent enc dec !! err) r, Members '[Scoped_ (TmuxClient enc dec) !! TmuxError, Events Event, Time t d, Log] r) => Sem r ()
- Chiasma.Event: listenLoop :: forall err t d r. Show err => Members [TmuxApi ReceiveEvent !! err, Events Event, Time t d, Log] r => Sem r ()
+ Chiasma.Event: listenLoop :: forall err t d (r :: EffectRow). (Show err, Members '[TmuxApi ReceiveEvent !! err, Events Event, Time t d, Log] r) => Sem r ()
- Chiasma.Event: receiveEvent :: forall r. Members [TmuxApi ReceiveEvent, Events Event] r => Sem r ()
+ Chiasma.Event: receiveEvent :: forall (r :: EffectRow). Members '[TmuxApi ReceiveEvent, Events Event] r => Sem r ()
- Chiasma.Event: withTmuxEvents :: Show err => Member (Codec ReceiveEvent enc dec !! err) r => Member (Scoped_ (TmuxClient enc dec) !! TmuxError) r => Members [Events Event, Time t d, Log, Race, Async, Resource] r => Sem r a -> Sem r a
+ Chiasma.Event: withTmuxEvents :: forall err enc dec (r :: EffectRow) t d a. (Show err, Member (Codec ReceiveEvent enc dec !! err) r, Member (Scoped_ (TmuxClient enc dec) !! TmuxError) r, Members '[Events Event, Time t d, Log, Race, Async, Resource] r) => Sem r a -> Sem r a
- Chiasma.Interpreter.Codec: interpretCodecNative :: (forall x. cmd x -> TmuxRequest) -> (forall x. TmuxResponse -> cmd x -> Either DecodeError x) -> InterpreterFor (Codec cmd TmuxRequest TmuxResponse !! CodecError) r
+ Chiasma.Interpreter.Codec: interpretCodecNative :: forall cmd (r :: [Effect]). (forall x. () => cmd x -> TmuxRequest) -> (forall x. () => TmuxResponse -> cmd x -> Either DecodeError x) -> InterpreterFor (Codec cmd TmuxRequest TmuxResponse !! CodecError) r
- Chiasma.Interpreter.Codec: interpretCodecPanes :: TmuxCodec p => InterpreterFor (Codec (Panes p) TmuxRequest TmuxResponse !! CodecError) r
+ Chiasma.Interpreter.Codec: interpretCodecPanes :: forall p (r :: [Effect]). TmuxCodec p => InterpreterFor (Codec (Panes p) TmuxRequest TmuxResponse !! CodecError) r
- Chiasma.Interpreter.Codec: interpretCodecPure :: (forall a. command a -> Sem r (Either Text a)) -> InterpreterFor (Codec command () decode !! Text) r
+ Chiasma.Interpreter.Codec: interpretCodecPure :: forall command (r :: [Effect]) decode. (forall a. () => command a -> Sem r (Either Text a)) -> InterpreterFor (Codec command () decode !! Text) r
- Chiasma.Interpreter.Codec: interpretCodecTmuxCommand :: InterpreterFor (Codec TmuxCommand TmuxRequest TmuxResponse !! CodecError) r
+ Chiasma.Interpreter.Codec: interpretCodecTmuxCommand :: forall (r :: [Effect]) a. Sem ((Codec TmuxCommand TmuxRequest TmuxResponse !! CodecError) ': r) a -> Sem r a
- Chiasma.Interpreter.ProcessOutput: interpretProcessOutputTmuxBlock :: forall p r. Member (Embed IO) r => InterpreterFor (ProcessOutput p (Either Text TmuxOutputBlock)) r
+ Chiasma.Interpreter.ProcessOutput: interpretProcessOutputTmuxBlock :: forall (p :: OutputPipe) (r :: EffectRow). Member (Embed IO) r => InterpreterFor (ProcessOutput p (Either Text TmuxOutputBlock)) r
- Chiasma.Interpreter.ProcessOutput: parseResult :: Member (AtomicState (Maybe ParseCont)) r => ParseResult -> Sem r ([Either Text TmuxOutputBlock], ByteString)
+ Chiasma.Interpreter.ProcessOutput: parseResult :: forall (r :: EffectRow). Member (AtomicState (Maybe ParseCont) :: (Type -> Type) -> Type -> Type) r => ParseResult -> Sem r ([Either Text TmuxOutputBlock], ByteString)
- Chiasma.Interpreter.Pure: interpretTmuxPure :: (forall a. command a -> Sem r (Either Text a)) -> InterpretersFor [Scoped_ (TmuxClient () ()) !! TmuxError, Codec command () () !! Text] r
+ Chiasma.Interpreter.Pure: interpretTmuxPure :: forall command (r :: [Effect]). (forall a. () => command a -> Sem r (Either Text a)) -> InterpretersFor '[Scoped_ (TmuxClient () ()) !! TmuxError, Codec command () () !! Text] r
- Chiasma.Interpreter.TmuxApi: class InterpretApis (commands :: [Type -> Type]) err i o r
+ Chiasma.Interpreter.TmuxApi: class InterpretApis (commands :: [Type -> Type]) err i o (r :: [Type -> Type -> Type -> Type])
- Chiasma.Interpreter.TmuxApi: class RestopApis (commands :: [Type -> Type]) err i o r
+ Chiasma.Interpreter.TmuxApi: class RestopApis (commands :: [Type -> Type]) (err :: k) i o (r :: [Type -> Type -> Type -> Type])
- Chiasma.Interpreter.TmuxApi: data TmuxApiEffect :: Type -> (Type -> Type) -> Exp Effect
+ Chiasma.Interpreter.TmuxApi: data TmuxApiEffect a (b :: Type -> Type) (c :: Effect)
- Chiasma.Interpreter.TmuxApi: flush :: Member (TmuxApi c) r => InterpreterFor (TmuxApi c) r
+ Chiasma.Interpreter.TmuxApi: flush :: forall (c :: Type -> Type) (r :: EffectRow). Member (TmuxApi c) r => InterpreterFor (TmuxApi c) r
- Chiasma.Interpreter.TmuxApi: interpretApis :: InterpretApis commands err i o r => InterpretersFor (TmuxApis commands err) (TmuxClient i o : r)
+ Chiasma.Interpreter.TmuxApi: interpretApis :: InterpretApis commands err i o r => InterpretersFor (TmuxApis commands err) (TmuxClient i o ': r)
- Chiasma.Interpreter.TmuxApi: interpretTmuxApi :: forall command i o err r. Members [TmuxClient i o, Codec command i o !! err] r => InterpreterFor (TmuxApi command !! err) r
+ Chiasma.Interpreter.TmuxApi: interpretTmuxApi :: forall (command :: Type -> Type) i o err (r :: EffectRow). Members '[TmuxClient i o, Codec command i o !! err] r => InterpreterFor (TmuxApi command !! err) r
- Chiasma.Interpreter.TmuxApi: restopApis :: RestopApis commands err i o r => InterpretersFor (TmuxApi <$> commands) (TmuxClient i o : r)
+ Chiasma.Interpreter.TmuxApi: restopApis :: RestopApis commands err i o r => InterpretersFor (TmuxApi <$> commands) (TmuxClient i o ': r)
- Chiasma.Interpreter.TmuxApi: type InterpretApisNative commands r = InterpretApis commands CodecError TmuxRequest TmuxResponse r
+ Chiasma.Interpreter.TmuxApi: type InterpretApisNative (commands :: [Type -> Type]) (r :: [Type -> Type -> Type -> Type]) = InterpretApis commands CodecError TmuxRequest TmuxResponse r
- Chiasma.Interpreter.TmuxApi: type RestopApisNative commands r = RestopApis commands CodecError TmuxRequest TmuxResponse r
+ Chiasma.Interpreter.TmuxApi: type RestopApisNative (commands :: [Type -> Type]) (r :: [Type -> Type -> Type -> Type]) = RestopApis commands CodecError TmuxRequest TmuxResponse r
- Chiasma.Interpreter.TmuxApi: type family TmuxApis (commands :: [Type -> Type]) (err :: Type) :: EffectRow
+ Chiasma.Interpreter.TmuxApi: type family TmuxApis (commands :: [Type -> Type]) err :: EffectRow
- Chiasma.Interpreter.TmuxClient: flush :: Members [TmuxProc, AtomicState (Seq TmuxRequest), Log, Stop TmuxError] r => Sem r ()
+ Chiasma.Interpreter.TmuxClient: flush :: forall (r :: EffectRow). Members '[TmuxProc, AtomicState (Seq TmuxRequest) :: (Type -> Type) -> Type -> Type, Log, Stop TmuxError] r => Sem r ()
- Chiasma.Interpreter.TmuxClient: interpretProcessTmux :: Member (Scoped_ (SystemProcess !! SystemProcessError) !! SystemProcessScopeError) r => Members [Resource, Race, Async, Embed IO] r => InterpreterFor (Scoped_ TmuxProc !! ProcessError) r
+ Chiasma.Interpreter.TmuxClient: interpretProcessTmux :: forall (r :: EffectRow). (Member (Scoped_ (SystemProcess !! SystemProcessError) !! SystemProcessScopeError) r, Members '[Resource, Race, Async, Embed IO] r) => InterpreterFor (Scoped_ TmuxProc !! ProcessError) r
- Chiasma.Interpreter.TmuxClient: interpretSystemProcessTmux :: Members [Reader TmuxNative, Resource, Race, Async, Embed IO] r => InterpreterFor (Scoped_ (SystemProcess !! SystemProcessError) !! SystemProcessScopeError) r
+ Chiasma.Interpreter.TmuxClient: interpretSystemProcessTmux :: forall (r :: EffectRow). Members '[Reader TmuxNative, Resource, Race, Async, Embed IO] r => InterpreterFor (Scoped_ (SystemProcess !! SystemProcessError) !! SystemProcessScopeError) r
- Chiasma.Interpreter.TmuxClient: interpretTmuxClientNull :: InterpreterFor (Scoped_ (TmuxClient i ()) !! TmuxError) r
+ Chiasma.Interpreter.TmuxClient: interpretTmuxClientNull :: forall i (r :: [Effect]) a. Sem ((Scoped_ (TmuxClient i ()) !! TmuxError) ': r) a -> Sem r a
- Chiasma.Interpreter.TmuxClient: interpretTmuxFailing :: TmuxError -> InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
+ Chiasma.Interpreter.TmuxClient: interpretTmuxFailing :: forall (r :: [Effect]). TmuxError -> InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
- Chiasma.Interpreter.TmuxClient: interpretTmuxNative :: forall r. Members [Reader TmuxNative, Log, Resource, Race, Async, Embed IO] r => InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
+ Chiasma.Interpreter.TmuxClient: interpretTmuxNative :: forall (r :: EffectRow). Members '[Reader TmuxNative, Log, Resource, Race, Async, Embed IO] r => InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
- Chiasma.Interpreter.TmuxClient: interpretTmuxNativeEnv :: Members [Error TmuxError, Log, Resource, Race, Async, Embed IO] r => Maybe (Path Abs File) -> InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
+ Chiasma.Interpreter.TmuxClient: interpretTmuxNativeEnv :: forall (r :: EffectRow). Members '[Error TmuxError :: (Type -> Type) -> Type -> Type, Log, Resource, Race, Async, Embed IO] r => Maybe (Path Abs File) -> InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
- Chiasma.Interpreter.TmuxClient: interpretTmuxNativeEnvGraceful :: Members [Log, Resource, Race, Async, Embed IO] r => Maybe (Path Abs File) -> InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
+ Chiasma.Interpreter.TmuxClient: interpretTmuxNativeEnvGraceful :: forall (r :: EffectRow). Members '[Log, Resource, Race, Async, Embed IO] r => Maybe (Path Abs File) -> InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
- Chiasma.Interpreter.TmuxClient: interpretTmuxProcessBuffered :: Members [AtomicState (Seq TmuxRequest), Scoped_ TmuxProc !! ProcessError, Log, Embed IO] r => InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
+ Chiasma.Interpreter.TmuxClient: interpretTmuxProcessBuffered :: forall (r :: EffectRow). Members '[AtomicState (Seq TmuxRequest) :: (Type -> Type) -> Type -> Type, Scoped_ TmuxProc !! ProcessError, Log, Embed IO] r => InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
- Chiasma.Interpreter.TmuxClient: interpretTmuxWithProcess :: Members [Scoped_ TmuxProc !! ProcessError, Log, Embed IO] r => InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
+ Chiasma.Interpreter.TmuxClient: interpretTmuxWithProcess :: forall (r :: EffectRow). Members '[Scoped_ TmuxProc !! ProcessError, Log, Embed IO] r => InterpreterFor (Scoped_ (TmuxClient TmuxRequest TmuxResponse) !! TmuxError) r
- Chiasma.Interpreter.TmuxClient: runReaderTmuxNativeEnv :: Members [Error TmuxError, Embed IO] r => Maybe (Path Abs File) -> InterpreterFor (Reader TmuxNative) r
+ Chiasma.Interpreter.TmuxClient: runReaderTmuxNativeEnv :: forall (r :: EffectRow). Members '[Error TmuxError :: (Type -> Type) -> Type -> Type, Embed IO] r => Maybe (Path Abs File) -> InterpreterFor (Reader TmuxNative) r
- Chiasma.Interpreter.TmuxClient: tmuxRequest :: Members [Process ByteString (Either Text TmuxOutputBlock), Log, Stop TmuxError] r => TmuxRequest -> Sem r TmuxResponse
+ Chiasma.Interpreter.TmuxClient: tmuxRequest :: forall (r :: EffectRow). Members '[Process ByteString (Either Text TmuxOutputBlock), Log, Stop TmuxError] r => TmuxRequest -> Sem r TmuxResponse
- Chiasma.Interpreter.TmuxClient: tmuxSession :: forall r a. Members [Scoped_ TmuxProc !! ProcessError, AtomicState (Seq TmuxRequest), Log, Stop TmuxError] r => Sem (TmuxProc : r) a -> Sem r a
+ Chiasma.Interpreter.TmuxClient: tmuxSession :: forall (r :: EffectRow) a. Members '[Scoped_ TmuxProc !! ProcessError, AtomicState (Seq TmuxRequest) :: (Type -> Type) -> Type -> Type, Log, Stop TmuxError] r => Sem (TmuxProc ': r) a -> Sem r a
- Chiasma.Interpreter.TmuxClient: type TmuxProc = Process ByteString (Either Text TmuxOutputBlock)
+ Chiasma.Interpreter.TmuxClient: type TmuxProc = Process ByteString Either Text TmuxOutputBlock
- Chiasma.Interpreter.TmuxClient: type TmuxQueues = ProcessQueues (Either Text TmuxOutputBlock) Text
+ Chiasma.Interpreter.TmuxClient: type TmuxQueues = ProcessQueues Either Text TmuxOutputBlock Text
- Chiasma.Interpreter.TmuxClient: withTmuxNativeEnv :: Member (Embed IO) r => Maybe (Path Abs File) -> (Maybe TmuxNative -> Sem r a) -> Sem r a
+ Chiasma.Interpreter.TmuxClient: withTmuxNativeEnv :: forall (r :: EffectRow) a. Member (Embed IO) r => Maybe (Path Abs File) -> (Maybe TmuxNative -> Sem r a) -> Sem r a
- Chiasma.Lens.Tree: _litTree :: HasLeafIndexTree c_a1Q7g l_a1Q1O p_a1Q1P => Lens' c_a1Q7g (Tree l_a1Q1O p_a1Q1P)
+ Chiasma.Lens.Tree: _litTree :: HasLeafIndexTree c l p => Lens' c (Tree l p)
- Chiasma.Lens.Tree: _nitTree :: HasNodeIndexTree c_a1Q1G l_a1PYR p_a1PYS => Lens' c_a1Q1G (Tree l_a1PYR p_a1PYS)
+ Chiasma.Lens.Tree: _nitTree :: HasNodeIndexTree c l p => Lens' c (Tree l p)
- Chiasma.Lens.Tree: class HasLeafIndexTree c_a1Q7g l_a1Q1O p_a1Q1P | c_a1Q7g -> l_a1Q1O p_a1Q1P
+ Chiasma.Lens.Tree: class HasLeafIndexTree c l p | c -> l p
- Chiasma.Lens.Tree: class HasNodeIndexTree c_a1Q1G l_a1PYR p_a1PYS | c_a1Q1G -> l_a1PYR p_a1PYS
+ Chiasma.Lens.Tree: class HasNodeIndexTree c l p | c -> l p
- Chiasma.Lens.Tree: leafByIdent :: forall l p. Identifiable p => Data l => Data p => Ident -> Tree l p -> Maybe p
+ Chiasma.Lens.Tree: leafByIdent :: forall l p. (Identifiable p, Data l, Data p) => Ident -> Tree l p -> Maybe p
- Chiasma.Lens.Tree: leafDataTraversal :: Traversal' (Tree l p) p
+ Chiasma.Lens.Tree: leafDataTraversal :: forall l p f. Applicative f => (p -> f p) -> Tree l p -> f (Tree l p)
- Chiasma.Lens.Tree: leafIndexTree :: HasLeafIndexTree c_a1Q7g l_a1Q1O p_a1Q1P => Lens' c_a1Q7g (LeafIndexTree l_a1Q1O p_a1Q1P)
+ Chiasma.Lens.Tree: leafIndexTree :: HasLeafIndexTree c l p => Lens' c (LeafIndexTree l p)
- Chiasma.Lens.Tree: leavesByIdent :: forall l p. Identifiable p => Data l => Data p => Ident -> Tree l p -> [p]
+ Chiasma.Lens.Tree: leavesByIdent :: forall l p. (Identifiable p, Data l, Data p) => Ident -> Tree l p -> [p]
- Chiasma.Lens.Tree: leavesByIdentRecursive :: forall l p. Identifiable p => Data l => Data p => Ident -> Fold (LeafIndexTree l p) p
+ Chiasma.Lens.Tree: leavesByIdentRecursive :: forall l p. (Identifiable p, Data l, Data p) => Ident -> Fold (LeafIndexTree l p) p
- Chiasma.Lens.Tree: leavesIdent :: forall l p. Identifiable p => Data l => Data p => Ident -> Fold (Tree l p) p
+ Chiasma.Lens.Tree: leavesIdent :: forall l p. (Identifiable p, Data l, Data p) => Ident -> Fold (Tree l p) p
- Chiasma.Lens.Tree: nodeByIdent :: forall l p. Identifiable l => Data l => Data p => Ident -> Tree l p -> Maybe l
+ Chiasma.Lens.Tree: nodeByIdent :: (Identifiable l, Data l, Data p) => Ident -> Tree l p -> Maybe l
- Chiasma.Lens.Tree: nodeIndexTree :: HasNodeIndexTree c_a1Q1G l_a1PYR p_a1PYS => Lens' c_a1Q1G (NodeIndexTree l_a1PYR p_a1PYS)
+ Chiasma.Lens.Tree: nodeIndexTree :: HasNodeIndexTree c l p => Lens' c (NodeIndexTree l p)
- Chiasma.Lens.Tree: nodeTraversal :: Traversal' (Tree l p) l
+ Chiasma.Lens.Tree: nodeTraversal :: forall l p f. Applicative f => (l -> f l) -> Tree l p -> f (Tree l p)
- Chiasma.Lens.Tree: nodesByIdent :: forall l p. Identifiable l => Data l => Data p => Ident -> Tree l p -> [l]
+ Chiasma.Lens.Tree: nodesByIdent :: (Identifiable l, Data l, Data p) => Ident -> Tree l p -> [l]
- Chiasma.Lens.Tree: nodesIdent :: forall l p. Identifiable l => Data l => Data p => Ident -> Fold (Tree l p) l
+ Chiasma.Lens.Tree: nodesIdent :: (Identifiable l, Data l, Data p) => Ident -> Fold (Tree l p) l
- Chiasma.Pack: packPane :: Members [AtomicState Views, Tmux] r => PaneId -> Axis -> PaneId -> Sem r ()
+ Chiasma.Pack: packPane :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => PaneId -> Axis -> PaneId -> Sem r ()
- Chiasma.Pack: packTree :: Members [AtomicState Views, Tmux] r => MeasureTree -> Sem r ()
+ Chiasma.Pack: packTree :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => MeasureTree -> Sem r ()
- Chiasma.Pack: packWindow :: Members [AtomicState Views, Tmux] r => WindowState -> Sem r ()
+ Chiasma.Pack: packWindow :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => WindowState -> Sem r ()
- Chiasma.Pack: positionView :: Members [AtomicState Views, Tmux] r => Axis -> PaneId -> MeasureTreeSub -> Sem r ()
+ Chiasma.Pack: positionView :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Axis -> PaneId -> MeasureTreeSub -> Sem r ()
- Chiasma.Pack: resizeView :: Members [AtomicState Views, Tmux] r => Axis -> MeasureTreeSub -> Sem r ()
+ Chiasma.Pack: resizeView :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Axis -> MeasureTreeSub -> Sem r ()
- Chiasma.Pane: addPane :: Member (AtomicState Views) r => Ident -> Sem r (View PaneId)
+ Chiasma.Pane: addPane :: forall (r :: EffectRow). Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Ident -> Sem r (View PaneId)
- Chiasma.Render: render :: Members [TmuxPanes Pane !! CodecError, AtomicState Views, Tmux !! CodecError, Stop RenderError] r => Path Abs Dir -> Ident -> Ident -> ViewTree -> Sem r ()
+ Chiasma.Render: render :: forall (r :: EffectRow). Members '[TmuxPanes Pane !! CodecError, AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux !! CodecError, Stop RenderError] r => Path Abs Dir -> Ident -> Ident -> ViewTree -> Sem r ()
- Chiasma.Render: renderTree :: Members [TmuxPanes Pane, AtomicState Views, Tmux] r => Ident -> Window -> RenderableTree -> Sem r ()
+ Chiasma.Render: renderTree :: forall (r :: EffectRow). Members '[TmuxPanes Pane, AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Ident -> Window -> RenderableTree -> Sem r ()
- Chiasma.Session: ensureSession :: Members [AtomicState Views, Tmux, Stop LayoutError] r => View SessionId -> View WindowId -> Sem r (SessionId, Maybe WindowId)
+ Chiasma.Session: ensureSession :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux, Stop LayoutError] r => View SessionId -> View WindowId -> Sem r (SessionId, Maybe WindowId)
- Chiasma.Session: findOrCreateSession :: Member (AtomicState Views) r => Ident -> Sem r (View SessionId)
+ Chiasma.Session: findOrCreateSession :: forall (r :: EffectRow). Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Ident -> Sem r (View SessionId)
- Chiasma.Session: spawnSession :: Members [AtomicState Views, Tmux, Stop LayoutError] r => View SessionId -> View WindowId -> Sem r (SessionId, WindowId)
+ Chiasma.Session: spawnSession :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux, Stop LayoutError] r => View SessionId -> View WindowId -> Sem r (SessionId, WindowId)
- Chiasma.Tmux: insertAfter :: forall left e r a. KnownList left => Sem (left ++ r) a -> Sem (left ++ (e : r)) a
+ Chiasma.Tmux: insertAfter :: forall (left :: [Effect]) (e :: Effect) (r :: [Effect]) a. KnownList left => Sem (left ++ r) a -> Sem (left ++ (e ': r)) a
- Chiasma.Tmux: withPanes :: forall p err i o r. Members [ScopedTmux i o, Codec (Panes p) i o !! err] r => InterpreterFor (TmuxPanes p !! err) r
+ Chiasma.Tmux: withPanes :: forall p err i o (r :: EffectRow). Members '[ScopedTmux i o, Codec (Panes p) i o !! err] r => InterpreterFor (TmuxPanes p !! err) r
- Chiasma.Tmux: withPanes_ :: forall p err i o r. Members [ScopedTmux i o, Codec (Panes p) i o !! err, Stop err] r => InterpreterFor (TmuxPanes p) r
+ Chiasma.Tmux: withPanes_ :: forall p err i o (r :: EffectRow). Members '[ScopedTmux i o, Codec (Panes p) i o !! err, Stop err] r => InterpreterFor (TmuxPanes p) r
- Chiasma.Tmux: withTmux :: forall command err i o r. Members [ScopedTmux i o, Codec command i o !! err] r => InterpreterFor (TmuxApi command !! err) r
+ Chiasma.Tmux: withTmux :: forall (command :: Type -> Type) err i o (r :: EffectRow). Members '[ScopedTmux i o, Codec command i o !! err] r => InterpreterFor (TmuxApi command !! err) r
- Chiasma.Tmux: withTmuxApis :: forall commands err i o r. KnownList (TmuxApis commands err) => InterpretApis commands err i o r => Member (ScopedTmux i o) r => InterpretersFor (TmuxApis commands err) r
+ Chiasma.Tmux: withTmuxApis :: forall (commands :: [Type -> Type]) err i o (r :: [(Type -> Type) -> Type -> Type]). (KnownList (TmuxApis commands err), InterpretApis commands err i o r, Member (ScopedTmux i o) r) => InterpretersFor (TmuxApis commands err) r
- Chiasma.Tmux: withTmuxApis' :: forall commands err i o r a. InterpretApis commands err i o r => Member (ScopedTmux i o) r => Sem (TmuxApis commands err ++ (TmuxClient i o : r)) a -> Sem r a
+ Chiasma.Tmux: withTmuxApis' :: forall (commands :: [Type -> Type]) err i o (r :: [(Type -> Type) -> Type -> Type]) a. (InterpretApis commands err i o r, Member (ScopedTmux i o) r) => Sem (TmuxApis commands err ++ (TmuxClient i o ': r)) a -> Sem r a
- Chiasma.Tmux: withTmuxApis_ :: forall commands err i o apis r. apis ~ (TmuxApi <$> commands) => KnownList apis => RestopApis commands err i o r => Member (ScopedTmux i o) r => InterpretersFor apis r
+ Chiasma.Tmux: withTmuxApis_ :: forall {k} (commands :: [Type -> Type]) (err :: k) i o (apis :: [(Type -> Type) -> Type -> Type]) (r :: [(Type -> Type) -> Type -> Type]). (apis ~ (TmuxApi <$> commands), KnownList apis, RestopApis commands err i o r, Member (ScopedTmux i o) r) => InterpretersFor apis r
- Chiasma.Tmux: withTmux_ :: forall command err i o r. Members [ScopedTmux i o, Codec command i o !! err, Stop err] r => InterpreterFor (TmuxApi command) r
+ Chiasma.Tmux: withTmux_ :: forall (command :: Type -> Type) err i o (r :: EffectRow). Members '[ScopedTmux i o, Codec command i o !! err, Stop err] r => InterpreterFor (TmuxApi command) r
- Chiasma.TmuxNative: withPanesNative :: forall p r. Members [NativeTmux, NativeCodecE (Panes p)] r => InterpreterFor (TmuxPanes p !! CodecError) r
+ Chiasma.TmuxNative: withPanesNative :: forall p (r :: EffectRow). Members '[NativeTmux, NativeCodecE (Panes p)] r => InterpreterFor (TmuxPanes p !! CodecError) r
- Chiasma.TmuxNative: withPanesNative_ :: forall p r. Members [NativeTmux, NativeCodecE (Panes p), Stop CodecError] r => InterpreterFor (TmuxPanes p) r
+ Chiasma.TmuxNative: withPanesNative_ :: forall p (r :: EffectRow). Members '[NativeTmux, NativeCodecE (Panes p), Stop CodecError] r => InterpreterFor (TmuxPanes p) r
- Chiasma.TmuxNative: withTmuxApisNative :: forall commands r. KnownList (TmuxApis commands CodecError) => InterpretApisNative commands r => Member NativeTmux r => InterpretersFor (TmuxApis commands CodecError) r
+ Chiasma.TmuxNative: withTmuxApisNative :: forall (commands :: [Type -> Type]) (r :: [(Type -> Type) -> Type -> Type]). (KnownList (TmuxApis commands CodecError), InterpretApisNative commands r, Member NativeTmux r) => InterpretersFor (TmuxApis commands CodecError) r
- Chiasma.TmuxNative: withTmuxApisNative' :: forall commands r a. InterpretApisNative commands r => Member NativeTmux r => Sem (TmuxApis commands CodecError ++ (TmuxClient TmuxRequest TmuxResponse : r)) a -> Sem r a
+ Chiasma.TmuxNative: withTmuxApisNative' :: forall (commands :: [Type -> Type]) (r :: [(Type -> Type) -> Type -> Type]) a. (InterpretApisNative commands r, Member NativeTmux r) => Sem (TmuxApis commands CodecError ++ (TmuxClient TmuxRequest TmuxResponse ': r)) a -> Sem r a
- Chiasma.TmuxNative: withTmuxApisNative_ :: forall commands r. KnownList (TmuxApi <$> commands) => RestopApisNative commands r => Member NativeTmux r => InterpretersFor (TmuxApi <$> commands) r
+ Chiasma.TmuxNative: withTmuxApisNative_ :: forall (commands :: [Type -> Type]) (r :: [(Type -> Type) -> Type -> Type]). (KnownList (TmuxApi <$> commands), RestopApisNative commands r, Member NativeTmux r) => InterpretersFor (TmuxApi <$> commands) r
- Chiasma.TmuxNative: withTmuxNative :: forall command r. Members [NativeTmux, NativeCodecE command] r => InterpreterFor (TmuxApi command !! CodecError) r
+ Chiasma.TmuxNative: withTmuxNative :: forall (command :: Type -> Type) (r :: EffectRow). Members '[NativeTmux, NativeCodecE command] r => InterpreterFor (TmuxApi command !! CodecError) r
- Chiasma.TmuxNative: withTmuxNative_ :: forall command r. Members [NativeTmux, NativeCodecE command, Stop CodecError] r => InterpreterFor (TmuxApi command) r
+ Chiasma.TmuxNative: withTmuxNative_ :: forall (command :: Type -> Type) (r :: EffectRow). Members '[NativeTmux, NativeCodecE command, Stop CodecError] r => InterpreterFor (TmuxApi command) r
- Chiasma.Ui.Data.Measure: axis :: HasMLayout c_a1vzC => Lens' c_a1vzC Axis
+ Chiasma.Ui.Data.Measure: axis :: HasMLayout c => Lens' c Axis
- Chiasma.Ui.Data.Measure: class HasMLayout c_a1vzC
+ Chiasma.Ui.Data.Measure: class HasMLayout c
- Chiasma.Ui.Data.Measure: class HasMPane c_a1vtn
+ Chiasma.Ui.Data.Measure: class HasMPane c
- Chiasma.Ui.Data.Measure: class HasMeasured c_a1vGJ a_a1vAb | c_a1vGJ -> a_a1vAb
+ Chiasma.Ui.Data.Measure: class HasMeasured c a | c -> a
- Chiasma.Ui.Data.Measure: lMainPosition :: HasMLayout c_a1vzC => Lens' c_a1vzC Int
+ Chiasma.Ui.Data.Measure: lMainPosition :: HasMLayout c => Lens' c Int
- Chiasma.Ui.Data.Measure: lOffPosition :: HasMLayout c_a1vzC => Lens' c_a1vzC Int
+ Chiasma.Ui.Data.Measure: lOffPosition :: HasMLayout c => Lens' c Int
- Chiasma.Ui.Data.Measure: mLayout :: HasMLayout c_a1vzC => Lens' c_a1vzC MLayout
+ Chiasma.Ui.Data.Measure: mLayout :: HasMLayout c => Lens' c MLayout
- Chiasma.Ui.Data.Measure: mPane :: HasMPane c_a1vtn => Lens' c_a1vtn MPane
+ Chiasma.Ui.Data.Measure: mPane :: HasMPane c => Lens' c MPane
- Chiasma.Ui.Data.Measure: mainPosition :: HasMPane c_a1vtn => Lens' c_a1vtn Int
+ Chiasma.Ui.Data.Measure: mainPosition :: HasMPane c => Lens' c Int
- Chiasma.Ui.Data.Measure: measured :: HasMeasured c_a1vGJ a_a1vAb => Lens' c_a1vGJ (Measured a_a1vAb)
+ Chiasma.Ui.Data.Measure: measured :: HasMeasured c a => Lens' c (Measured a)
- Chiasma.Ui.Data.Measure: offPosition :: HasMPane c_a1vtn => Lens' c_a1vtn Int
+ Chiasma.Ui.Data.Measure: offPosition :: HasMPane c => Lens' c Int
- Chiasma.Ui.Data.Measure: paneId :: HasMPane c_a1vtn => Lens' c_a1vtn PaneId
+ Chiasma.Ui.Data.Measure: paneId :: HasMPane c => Lens' c PaneId
- Chiasma.Ui.Data.Measure: reference :: HasMLayout c_a1vzC => Lens' c_a1vzC PaneId
+ Chiasma.Ui.Data.Measure: reference :: HasMLayout c => Lens' c PaneId
- Chiasma.Ui.Data.Measure: size :: HasMeasured c_a1vGJ a_a1vAb => Lens' c_a1vGJ Int
+ Chiasma.Ui.Data.Measure: size :: HasMeasured c a => Lens' c Int
- Chiasma.Ui.Data.Measure: type MeasureTree = NTree (Measured MLayout) (Measured MPane)
+ Chiasma.Ui.Data.Measure: type MeasureTree = NTree Measured MLayout Measured MPane
- Chiasma.Ui.Data.Measure: type MeasureTreeSub = NNode (Measured MLayout) (Measured MPane)
+ Chiasma.Ui.Data.Measure: type MeasureTreeSub = NNode Measured MLayout Measured MPane
- Chiasma.Ui.Data.Measure: view :: HasMeasured c_a1vGJ a_a1vAb => Lens' c_a1vGJ a_a1vAb
+ Chiasma.Ui.Data.Measure: view :: HasMeasured c a => Lens' c a
- Chiasma.Ui.Data.Tree: Leaf :: p -> Node f l p
+ Chiasma.Ui.Data.Tree: Leaf :: p -> Node (f :: Type -> Type) l p
- Chiasma.Ui.Data.Tree: Sub :: Tree f l p -> Node f l p
+ Chiasma.Ui.Data.Tree: Sub :: Tree f l p -> Node (f :: Type -> Type) l p
- Chiasma.Ui.Data.Tree: Tree :: l -> f (Node f l p) -> Tree f l p
+ Chiasma.Ui.Data.Tree: Tree :: l -> f (Node f l p) -> Tree (f :: Type -> Type) l p
- Chiasma.Ui.Data.Tree: class HasNode c_a1sXU f_a1sO4 l_a1sO5 p_a1sO6 | c_a1sXU -> f_a1sO4 l_a1sO5 p_a1sO6
+ Chiasma.Ui.Data.Tree: class HasNode c (f :: Type -> Type) l p | c -> f l p
- Chiasma.Ui.Data.Tree: class HasTree c_a1sTV f_a1sO7 l_a1sO8 p_a1sO9 | c_a1sTV -> f_a1sO7 l_a1sO8 p_a1sO9
+ Chiasma.Ui.Data.Tree: class HasTree c (f :: Type -> Type) l p | c -> f l p
- Chiasma.Ui.Data.Tree: data Node f l p
+ Chiasma.Ui.Data.Tree: data Node (f :: Type -> Type) l p
- Chiasma.Ui.Data.Tree: data Tree f l p
+ Chiasma.Ui.Data.Tree: data Tree (f :: Type -> Type) l p
- Chiasma.Ui.Data.Tree: forest :: HasTree c_a1sTV f_a1sO7 l_a1sO8 p_a1sO9 => Lens' c_a1sTV (f_a1sO7 (Node f_a1sO7 l_a1sO8 p_a1sO9))
+ Chiasma.Ui.Data.Tree: forest :: HasTree c f l p => Lens' c (f (Node f l p))
- Chiasma.Ui.Data.Tree: leafData :: HasNode c_a1sXU f_a1sO4 l_a1sO5 p_a1sO6 => Traversal' c_a1sXU p_a1sO6
+ Chiasma.Ui.Data.Tree: leafData :: HasNode c f l p => Traversal' c p
- Chiasma.Ui.Data.Tree: node :: HasNode c_a1sXU f_a1sO4 l_a1sO5 p_a1sO6 => Lens' c_a1sXU (Node f_a1sO4 l_a1sO5 p_a1sO6)
+ Chiasma.Ui.Data.Tree: node :: HasNode c f l p => Lens' c (Node f l p)
- Chiasma.Ui.Data.Tree: subTree :: HasNode c_a1sXU f_a1sO4 l_a1sO5 p_a1sO6 => Traversal' c_a1sXU (Tree f_a1sO4 l_a1sO5 p_a1sO6)
+ Chiasma.Ui.Data.Tree: subTree :: HasNode c f l p => Traversal' c (Tree f l p)
- Chiasma.Ui.Data.Tree: tree :: HasTree c_a1sTV f_a1sO7 l_a1sO8 p_a1sO9 => Lens' c_a1sTV (Tree f_a1sO7 l_a1sO8 p_a1sO9)
+ Chiasma.Ui.Data.Tree: tree :: HasTree c f l p => Lens' c (Tree f l p)
- Chiasma.Ui.Data.Tree: treeData :: HasTree c_a1sTV f_a1sO7 l_a1sO8 p_a1sO9 => Lens' c_a1sTV l_a1sO8
+ Chiasma.Ui.Data.Tree: treeData :: HasTree c f l p => Lens' c l
- Chiasma.Ui.Data.View: treeByIdent :: forall l p. Identifiable l => Data l => Data p => Ident -> Tree l p -> Maybe (Tree l p)
+ Chiasma.Ui.Data.View: treeByIdent :: (Identifiable l, Data l, Data p) => Ident -> Tree l p -> Maybe (Tree l p)
- Chiasma.Ui.Data.View: treeTraversal :: Traversal' (Tree l p) (Tree l p)
+ Chiasma.Ui.Data.View: treeTraversal :: forall l p f. Applicative f => (Tree l p -> f (Tree l p)) -> Tree l p -> f (Tree l p)
- Chiasma.Ui.Data.View: treesByIdent :: forall l p. Identifiable l => Data l => Data p => Ident -> Tree l p -> [Tree l p]
+ Chiasma.Ui.Data.View: treesByIdent :: (Identifiable l, Data l, Data p) => Ident -> Tree l p -> [Tree l p]
- Chiasma.Ui.Data.View: treesIdent :: forall l p. Identifiable l => Data l => Data p => Ident -> Fold (Tree l p) (Tree l p)
+ Chiasma.Ui.Data.View: treesIdent :: (Identifiable l, Data l, Data p) => Ident -> Fold (Tree l p) (Tree l p)
- Chiasma.Ui.ViewTree: depthTraverseTree :: forall a. Monoid a => (a -> ViewTree -> (a, ViewTree)) -> (PaneView -> (a, PaneView)) -> ViewTree -> (a, ViewTree)
+ Chiasma.Ui.ViewTree: depthTraverseTree :: Monoid a => (a -> ViewTree -> (a, ViewTree)) -> (PaneView -> (a, PaneView)) -> ViewTree -> (a, ViewTree)
- Chiasma.View: addView :: Member (AtomicState Views) r => Setter a -> Ident -> Sem r (View a)
+ Chiasma.View: addView :: forall (r :: EffectRow) a. Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Setter a -> Ident -> Sem r (View a)
- Chiasma.View: findOrCreateView :: Member (AtomicState Views) r => Getter a -> Setter a -> Ident -> Sem r (View a)
+ Chiasma.View: findOrCreateView :: forall (r :: EffectRow) a. Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Getter a -> Setter a -> Ident -> Sem r (View a)
- Chiasma.View: type Getter a = Ident -> Views -> Either ViewsError (View a)
+ Chiasma.View: type Getter a = Ident -> Views -> Either ViewsError View a
- Chiasma.View: updateView :: forall a. Lens' Views [View a] -> (Ident -> ViewsError) -> View a -> Views -> Views
+ Chiasma.View: updateView :: Lens' Views [View a] -> (Ident -> ViewsError) -> View a -> Views -> Views
- Chiasma.View: viewsLog :: Member (AtomicState Views) r => Doc AnsiStyle -> Sem r ()
+ Chiasma.View: viewsLog :: forall (r :: EffectRow). Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Doc AnsiStyle -> Sem r ()
- Chiasma.View: viewsLogS :: Member (AtomicState Views) r => Text -> Sem r ()
+ Chiasma.View: viewsLogS :: forall (r :: EffectRow). Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Text -> Sem r ()
- Chiasma.View.State: paneId :: Members [AtomicState Views, Stop ViewsError] r => Ident -> Sem r PaneId
+ Chiasma.View.State: paneId :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Stop ViewsError] r => Ident -> Sem r PaneId
- Chiasma.Window: ensurePane :: Members [TmuxPanes Pane, AtomicState Views, Tmux] r => Path Abs Dir -> WindowId -> PaneView -> Sem r (Maybe RenderableNode)
+ Chiasma.Window: ensurePane :: forall (r :: EffectRow). Members '[TmuxPanes Pane, AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Path Abs Dir -> WindowId -> PaneView -> Sem r (Maybe RenderableNode)
- Chiasma.Window: ensurePaneClosed :: Members [AtomicState Views, Tmux] r => Maybe Pane -> Sem r ()
+ Chiasma.Window: ensurePaneClosed :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Maybe Pane -> Sem r ()
- Chiasma.Window: ensurePaneOpen :: Members [AtomicState Views, Tmux] r => Path Abs Dir -> Maybe Pane -> WindowId -> Sem r Pane
+ Chiasma.Window: ensurePaneOpen :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Path Abs Dir -> Maybe Pane -> WindowId -> Sem r Pane
- Chiasma.Window: ensureView :: Members [TmuxPanes Pane, AtomicState Views, Tmux] r => Path Abs Dir -> WindowId -> ViewTree -> Sem r (Maybe RenderableTree)
+ Chiasma.Window: ensureView :: forall (r :: EffectRow). Members '[TmuxPanes Pane, AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Path Abs Dir -> WindowId -> ViewTree -> Sem r (Maybe RenderableTree)
- Chiasma.Window: ensureWindow :: Members [TmuxPanes Pane, AtomicState Views, Tmux, Stop RenderError] r => SessionId -> View WindowId -> Maybe WindowId -> ViewTree -> Sem r Window
+ Chiasma.Window: ensureWindow :: forall (r :: EffectRow). Members '[TmuxPanes Pane, AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux, Stop RenderError] r => SessionId -> View WindowId -> Maybe WindowId -> ViewTree -> Sem r Window
- Chiasma.Window: findOrCreatePane :: Member (AtomicState Views) r => Ident -> Sem r (View PaneId)
+ Chiasma.Window: findOrCreatePane :: forall (r :: EffectRow). Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Ident -> Sem r (View PaneId)
- Chiasma.Window: findOrCreateWindow :: Member (AtomicState Views) r => Ident -> Sem r (View WindowId)
+ Chiasma.Window: findOrCreateWindow :: forall (r :: EffectRow). Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Ident -> Sem r (View WindowId)
- Chiasma.Window: nativePane :: Member (TmuxPanes Pane) r => WindowId -> View PaneId -> Sem r (Maybe Pane)
+ Chiasma.Window: nativePane :: forall (r :: EffectRow). Member (TmuxPanes Pane) r => WindowId -> View PaneId -> Sem r (Maybe Pane)
- Chiasma.Window: openPane :: Members [AtomicState Views, Tmux] r => Path Abs Dir -> WindowId -> Sem r Pane
+ Chiasma.Window: openPane :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => Path Abs Dir -> WindowId -> Sem r Pane
- Chiasma.Window: principalPane :: Members [AtomicState Views, Tmux, Stop RenderError] r => ViewTree -> Sem r (PaneView, View PaneId)
+ Chiasma.Window: principalPane :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux, Stop RenderError] r => ViewTree -> Sem r (PaneView, View PaneId)
- Chiasma.Window: registerWindowId :: Member (AtomicState Views) r => Ident -> WindowId -> Sem r ()
+ Chiasma.Window: registerWindowId :: forall (r :: EffectRow). Member (AtomicState Views :: (Type -> Type) -> Type -> Type) r => Ident -> WindowId -> Sem r ()
- Chiasma.Window: spawnWindow :: Members [AtomicState Views, Tmux] r => SessionId -> Ident -> Sem r Window
+ Chiasma.Window: spawnWindow :: forall (r :: EffectRow). Members '[AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux] r => SessionId -> Ident -> Sem r Window
- Chiasma.Window: syncPrincipal :: Members [TmuxPanes Pane, AtomicState Views, Tmux, Stop RenderError] r => WindowId -> ViewTree -> Sem r ()
+ Chiasma.Window: syncPrincipal :: forall (r :: EffectRow). Members '[TmuxPanes Pane, AtomicState Views :: (Type -> Type) -> Type -> Type, Tmux, Stop RenderError] r => WindowId -> ViewTree -> Sem r ()
- Chiasma.Window: windowState :: Member (TmuxPanes Pane) r => Ident -> Window -> RenderableTree -> Sem r WindowState
+ Chiasma.Window: windowState :: forall (r :: EffectRow). Member (TmuxPanes Pane) r => Ident -> Window -> RenderableTree -> Sem r WindowState

Files

chiasma.cabal view
@@ -1,11 +1,11 @@ cabal-version: 2.2 --- This file has been generated from package.yaml by hpack version 0.35.2.+-- This file has been generated from package.yaml by hpack version 0.38.2. -- -- see: https://github.com/sol/hpack  name:           chiasma-version:        0.10.1.0+version:        0.10.2.0 synopsis:       A tmux client for Polysemy description:    See https://hackage.haskell.org/package/chiasma/docs/Chiasma.html category:       Terminal@@ -13,7 +13,7 @@ bug-reports:    https://github.com/tek/chiasma/issues author:         Torsten Schmits maintainer:     hackage@tryp.io-copyright:      2023 Torsten Schmits+copyright:      2025 Torsten Schmits license:        BSD-2-Clause-Patent license-file:   LICENSE build-type:     Simple@@ -143,9 +143,12 @@       GADTs       LambdaCase       LiberalTypeSynonyms+      MonadComprehensions       MultiWayIf+      NoFieldSelectors       OverloadedLabels       OverloadedLists+      OverloadedRecordDot       OverloadedStrings       PackageImports       PartialTypeSignatures@@ -161,36 +164,34 @@       UndecidableInstances       UnicodeSyntax       ViewPatterns-      OverloadedRecordDot-      NoFieldSelectors   ghc-options: -fplugin=Polysemy.Plugin -Wall -Widentities -Wincomplete-uni-patterns -Wmissing-deriving-strategies -Wredundant-constraints -Wunused-type-patterns -Wunused-packages   build-depends:-      attoparsec >=0.13-    , base ==4.*+      attoparsec+    , base <5     , bytestring-    , composition >=1.0+    , composition     , containers     , exon     , extra     , first-class-families-    , lens >=4+    , lens     , parsec-    , parsers >=0.12+    , parsers     , path     , polysemy-    , polysemy-conc >=0.9-    , polysemy-log >=0.7+    , polysemy-conc+    , polysemy-log     , polysemy-plugin-    , polysemy-process >=0.9-    , polysemy-time >=0.5-    , prelate >=0.6 && <0.8-    , prettyprinter >=1.6-    , prettyprinter-ansi-terminal >=1.1-    , random >=1.1+    , polysemy-process+    , polysemy-time+    , prelate+    , prettyprinter+    , prettyprinter-ansi-terminal+    , random     , text     , transformers-    , typed-process >=0.2-    , uuid >=1.3+    , typed-process+    , uuid   mixins:       base hiding (Prelude)     , prelate (Prelate as Prelude)
lib/Chiasma/Command/Pane.hs view
@@ -1,4 +1,3 @@-{-# OPTIONS_GHC -Wno-ambiguous-fields #-} module Chiasma.Command.Pane where  import Prelude hiding (output)@@ -6,22 +5,20 @@ import qualified Chiasma.Codec.Data.Pane as Codec (Pane) import qualified Chiasma.Codec.Data.PaneMode as Codec (PaneMode (PaneMode)) import Chiasma.Data.Axis (Axis)-import Chiasma.Data.CapturePaneParams (CaptureOutput (Stdout), escapeSequences, output, target)-import Chiasma.Data.CopyModeParams (target)-import Chiasma.Data.KillPaneParams (target)+import Chiasma.Data.CapturePaneParams (CaptureOutput (Stdout), CapturePaneParams (..))+import qualified Chiasma.Data.CopyModeParams as CopyModeParams+import qualified Chiasma.Data.KillPaneParams as KillPaneParams import qualified Chiasma.Data.PaneSelection as PaneSelection import qualified Chiasma.Data.Panes as Panes import Chiasma.Data.Panes (TmuxPanes)-import Chiasma.Data.PipePaneParams (command, target)-import Chiasma.Data.ResizePaneParams (ResizeAbsolute (ResizeAbsolute), absolute, target)-import Chiasma.Data.SelectParams (target)+import Chiasma.Data.PipePaneParams (PipePaneParams (..))+import Chiasma.Data.ResizePaneParams (ResizeAbsolute (ResizeAbsolute), ResizePaneParams (..))+import qualified Chiasma.Data.SelectParams as SelectParams import qualified Chiasma.Data.SendKeysParams as SendKeysParams-import Chiasma.Data.SendKeysParams (Key, keys, target)+import Chiasma.Data.SendKeysParams (Key, SendKeysParams (..)) import Chiasma.Data.SplitParams (JoinPaneParams (axis, detach, source, target)) import qualified Chiasma.Data.Target as Target-import Chiasma.Data.TmuxCommand (-  TmuxCommand (CapturePane, CopyMode, KillPane, MovePane, PipePane, ResizePane, SelectPane, SendKeys),-  )+import Chiasma.Data.TmuxCommand (TmuxCommand (..)) import Chiasma.Data.TmuxId (PaneId, WindowId) import Chiasma.Data.View (View (View)) import qualified Chiasma.Effect.TmuxApi as Tmux@@ -59,7 +56,7 @@   PaneId ->   Sem r () closePane paneId =-  Tmux.send (KillPane def { target = Target.Pane paneId })+  Tmux.send (KillPane def { KillPaneParams.target = Target.Pane paneId })  isPaneIdOpen ::   Member (TmuxPanes Codec.Pane) r =>@@ -132,14 +129,14 @@   PaneId ->   Sem r () selectPane paneId =-  Tmux.send (SelectPane def { target = Target.Pane paneId })+  Tmux.send (SelectPane def { SelectParams.target = Target.Pane paneId })  copyMode ::   Member Tmux r =>   PaneId ->   Sem r () copyMode paneId =-  Tmux.send (CopyMode def { target = Target.Pane paneId })+  Tmux.send (CopyMode def { CopyModeParams.target = Target.Pane paneId })  paneMode ::   Member (TmuxPanes Codec.PaneMode) r =>
lib/Chiasma/Command/Session.hs view
@@ -3,7 +3,7 @@ import Chiasma.Codec.Data.Client (Client (Client)) import Chiasma.Codec.Data.Session (Session (Session)) import Chiasma.Data.Ident (Ident)-import Chiasma.Data.SessionParams (name)+import Chiasma.Data.SessionParams (SessionParams (..)) import qualified Chiasma.Data.Target as Target import Chiasma.Data.TmuxCommand (TmuxCommand (ListClients, ListSessions, NewSession, SwitchClient)) import Chiasma.Data.TmuxError (TmuxError (NoClients))
lib/Chiasma/Command/Window.hs view
@@ -10,7 +10,7 @@ import qualified Chiasma.Data.Target as Target import Chiasma.Data.TmuxCommand (TmuxCommand (ListWindows, NewWindow, SplitWindow)) import Chiasma.Data.TmuxId (SessionId, WindowId)-import Chiasma.Data.WindowParams (cwd, detach, name, target)+import Chiasma.Data.WindowParams (WindowParams (..)) import qualified Chiasma.Data.WindowSelection as WindowSelection import qualified Chiasma.Effect.TmuxApi as Tmux import Chiasma.Effect.TmuxApi (Tmux)
lib/Chiasma/Data/TmuxCommand.hs view
@@ -12,7 +12,7 @@ import Chiasma.Codec.Data.Pane (Pane) import Chiasma.Codec.Data.Session (Session) import Chiasma.Codec.Data.Window (Window)-import Chiasma.Data.CapturePaneParams (CapturePaneParams (CapturePaneParams), stripBlank, stripTrailingWs)+import Chiasma.Data.CapturePaneParams (CapturePaneParams (..)) import Chiasma.Data.CopyModeParams (CopyModeParams) import Chiasma.Data.DecodeError (DecodeError) import Chiasma.Data.KillPaneParams (KillPaneParams)
lib/Chiasma/Ui/Data/View.hs view
@@ -100,6 +100,9 @@   second f (Tree l sub) =     Tree l (fmap (second f) sub) +instance Functor (Tree l) where+  fmap = second+ instance Bifoldable Tree where   bifoldMap fl fr (Tree l sub) = mappend (fl l) (foldMap (bifoldMap fl fr) sub) @@ -115,6 +118,9 @@    second f (TreeNode t) = TreeNode (second f t)   second f (TreeLeaf p) = TreeLeaf (f p)++instance Functor (TreeSub l) where+  fmap = second  instance Bifoldable TreeSub where   bifoldMap fl fr (TreeNode t) = bifoldMap fl fr t
lib/Chiasma/Ui/ViewTree.hs view
@@ -1,6 +1,6 @@ module Chiasma.Ui.ViewTree where -import Control.Lens (anyOf, cosmos, ix, mapMOf, transformM)+import Control.Lens (cosmos, ix, transformM) import Control.Monad.Trans.Class (lift) import Control.Monad.Trans.Except (ExceptT (ExceptT), runExceptT) import Control.Monad.Trans.Writer (WriterT, runWriterT, tell)