F# API

struct libtmux-fsharp latest

SessionSpec

Namespace L.FSharp LibTmux.FSharp

Describes a session and its windows, for <c>Server.newSession</c>.

View as Markdown

Source and package

Module: LibTmux.FSharp
Package: LibTmux.FSharp
Source: src/LibTmux.FSharp/Spec.fsi

type SessionSpecmodule SessionSpec struct [source] ¶

Description#

tmux gives a new session one window, which the first <c>WindowSpec</c> becomes; each later one is a window of its own. A session with no windows listed gets tmux's single default window.

Examples#

Create a session from F# records in one call: the first window is the one tmux makes with the session, and each split goes beside the pane before it. Add a window with a command chain, then read through a handle whose commands each get five seconds. Use Linux or macOS with Git, tmux 3.2a or newer, .NET SDK 10.0.303, and the .NET 8 and 10 runtimes. In an empty directory, fetch the documented library revision:

$ git clone https://github.com/libtmux/libtmux-dotnet.git libtmux-source && \
  git -C libtmux-source checkout --detach cf34b255c896d19a97e7d7fabea58609c916012d

Save this complete consumer setup as global.json: View source

{
  "sdk": {
    "version": "10.0.303",
    "rollForward": "disable",
    "allowPrerelease": false
  },
  "test": {
    "runner": "Microsoft.Testing.Platform"
  }
}

Save this complete consumer setup as NuGet.config: View source

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="libtmux-source" value="libtmux-source/artifacts/api-example-packages" />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
  </packageSources>
  <packageSourceMapping>
    <clear />
    <packageSource key="libtmux-source">
      <package pattern="LibTmux" />
      <package pattern="LibTmux.*" />
    </packageSource>
    <packageSource key="nuget.org">
      <package pattern="*" />
    </packageSource>
  </packageSourceMapping>
</configuration>

Save this complete consumer setup as Example.fsproj: View source

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFrameworks>net8.0;net10.0</TargetFrameworks>
    <LangVersion>10.0</LangVersion>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <DisableImplicitFSharpCoreReference>true</DisableImplicitFSharpCoreReference>
    <DisableImplicitLibraryPacksFolder>true</DisableImplicitLibraryPacksFolder>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="Program.fs" />
    <PackageReference Include="FSharp.Core" Version="[10.1.303]" />
    <PackageReference Include="LibTmux.FSharp" Version="[0.0.0-alpha.20]" />
  </ItemGroup>
</Project>

Save this complete program as Program.fs. It creates a private server with LibTmux.Server.CreateOwnedAsync; use! disposes owned scopes after success, cancellation or failure. The F# facade has no separate server constructor. View source

// fsharp-snippet: BuildSession
open System
open System.Threading
open LibTmux
open LibTmux.FSharp

let runAsync () =
    task {
        use deadline = new CancellationTokenSource(TimeSpan.FromSeconds 20.)
        let token = deadline.Token

        let options =
            ServerConnectionOptions(
                SocketName = "fsharp-build-session-" + Guid.NewGuid().ToString("N"),
                ConfigurationFile = "/dev/null"
            )

        use! owned = options |> Server.createOwned token

        // Describe the session, then create it in one call: the first window is
        // the one tmux makes with the session, and each split goes beside the
        // pane before it, sized in cells or as a share of the space it splits.
        let dev =
            { SessionSpec.named "dev" with
                Windows =
                    [
                        { WindowSpec.named "editor" with
                            Command = Some "exec sleep 60"
                        }
                        { WindowSpec.named "logs" with
                            Command = Some "exec sleep 60"
                            Splits =
                                [
                                    { SplitSpec.empty with
                                        Direction = Some PaneDirection.Right
                                        Size = Some(SplitSize.Percent 30)
                                        Command = Some "exec sleep 60"
                                    }
                                    { SplitSpec.empty with
                                        Size = Some(SplitSize.Cells 8)
                                        Command = Some "exec sleep 60"
                                    }
                                ]
                        }
                    ]
            }

        let! session = owned.Value |> Server.newSession token dev

        // A chain runs in one tmux invocation; each step acts on what the one
        // before made.
        let! _ =
            owned.Value
            |> Chain.start
            |> Chain.newWindow session "watch"
            |> Chain.splitLeftRight
            |> Chain.sendLine "exec sleep 60"
            |> Chain.run token

        // Every command through this handle, and the handles taken from it,
        // gives tmux five seconds.
        let bounded = owned.Value |> Server.within (TimeSpan.FromSeconds 5.)
        let! windows = bounded |> Server.windows |> Query.list token

        for window in windows do
            let! panes = window |> Window.panes |> Query.list token
            printfn "%s: %d panes" window.Name panes.Count
    }

runAsync().GetAwaiter().GetResult()
// endfsharp-snippet

Build the exact source packages and the saved consumer, then run both supported frameworks. The local package feed prevents an unrelated published package from satisfying the restore. Each program checks its result and exits unsuccessfully after an unhandled error:

$ export NUGET_PACKAGES="$PWD/packages" && \
  dotnet restore libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj --locked-mode && \
  dotnet pack libtmux-source/src/LibTmux/LibTmux.csproj \
    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \
    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \
  dotnet pack libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj \
    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \
    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \
  dotnet restore Example.fsproj --configfile NuGet.config && \
  dotnet build Example.fsproj --configuration Release --no-restore --warnaserror && \
  export LIBTMUX_TMUX="$(command -v tmux)" && \
  export TMUX_TMPDIR=/tmp/libtmux-dotnet-dev && \
  mkdir -p "$TMUX_TMPDIR" && \
  unset TMUX TMUX_PANE && \
  dotnet bin/Release/net8.0/Example.dll && \
  dotnet bin/Release/net10.0/Example.dll

Expected program output from each framework:

editor: 1 panes
logs: 3 panes
watch: 2 panes

Members7 members#

Collections and queries1 member#

Windows property The windows, in order; the first is the one tmux creates with the session.

Other members6 members#

Directory property The working directory of the session and its first window.
Environment property Variables added to the session's environment.
Name property The session's name.
named function A named session with tmux's single default window.
running function A named session whose one window runs a command instead of the default shell.
ToString method Names the session, without formatting through printf.

Scripting & web

Compiled & native

JVM

.NET

tmux

SessionSpec

Description#

Examples#

Members7 members#

Collections and queries1 member#

Other members6 members#

Description#

Examples#

Members7 members#

Collections and queries1 member#

Other members6 members#

Related types#