public struct CurrentPlayerEnvelope: Codable, Equatable {
  public let appleReceipt: AppleVerifyReceiptResponse?
  public let player: Player

  public init(
    appleReceipt: AppleVerifyReceiptResponse?,
    player: Player
  ) {
    self.appleReceipt = appleReceipt
    self.player = player
  }
}

struct OnboardingStepView: View {
  let store: Store<OnboardingState, OnboardingAction>
  @ObservedObject var viewStore: ViewStore<ViewState, OnboardingAction>
  @Environment(\.colorScheme) var colorScheme

  init(store: Store<OnboardingState, OnboardingAction>) {
    self.store = store
    self.viewStore = ViewStore(self.store.scope(state: ViewState.init))
  }
  ...

 ...
  var body: some View {
    GeometryReader { proxy in
      let height = proxy.size.height / 4

extension ApiClient {
  private static let baseUrlKey = "co.pointfree.isowords.apiClient.baseUrl"
  private static let currentUserEnvelopeKey = "co.pointfree.isowords.apiClient.currentUserEnvelope"

  public static func live(
    accessToken defaultAccessToken: AccessToken? = nil,
    baseUrl defaultBaseUrl: URL = URL(string: "http://localhost:9876")!,
    sha256: @escaping (Data) -> Data
  ) -> Self {
    let router = ServerRouter.router(
      date: Date.init,
      decoder: decoder,
      encoder: encoder,
      secrets: secrets.split(separator: ",").map(String.init),
      sha256: sha256
    )

    #if DEBUG
      var baseUrl = UserDefaults.standard.url(forKey: baseUrlKey) ?? defaultBaseUrl {
        didSet {
          UserDefaults.standard.set(baseUrl, forKey: baseUrlKey)
        }
      }
    #else
      var baseUrl = URL(string: "https://www.isowords.xyz")!
    #endif
    var currentPlayer = UserDefaults.standard.data(forKey: currentUserEnvelopeKey)
      .flatMap({ try? decoder.decode(CurrentPlayerEnvelope.self, from: $0) })
    {
      didSet {
        UserDefaults.standard.set(
          currentPlayer.flatMap { try? encoder.encode($0) },
          forKey: currentUserEnvelopeKey
        )
      }
    }

extension AppEnvironment {
  static var live: Self {
    let apiClient = ApiClient.live(
      sha256: { Data(SHA256.hash(data: $0)) }
    )

  public static func live(
    accessToken defaultAccessToken: AccessToken? = nil,
    baseUrl defaultBaseUrl: URL = URL(string: "http://localhost:9876")!,
    sha256: @escaping (Data) -> Data
  ) -> Self {

    色々省略

    return Self(
      apiRequest: { route in
        ApiClientLive.apiRequest(
          accessToken: currentPlayer?.player.accessToken,
          baseUrl: baseUrl,
          route: route,
          router: router
        )
      },
      authenticate: { request in
        return ApiClientLive.request(
          baseUrl: baseUrl,
          route: .authenticate(
            .init(
              deviceId: request.deviceId,
              displayName: request.displayName,
              gameCenterLocalPlayerId: request.gameCenterLocalPlayerId,
              timeZone: request.timeZone
            )
          ),
          router: router
        )
        .map { data, _ in data }
        .apiDecode(as: CurrentPlayerEnvelope.self)
        .handleEvents(receiveOutput: { currentPlayer = $0 })
        .eraseToEffect()
      },
      baseUrl: { baseUrl },
      currentPlayer: { currentPlayer },
      logout: {
        .fireAndForget { currentPlayer = nil }
      },
      refreshCurrentPlayer: {
        ApiClientLive.apiRequest(
          accessToken: currentPlayer?.player.accessToken,
          baseUrl: baseUrl,
          route: .currentPlayer,
          router: router
        )

extension ApiClient {
  func loadSoloResults(
    gameMode: GameMode,
    timeScope: TimeScope
  ) -> Effect<ResultEnvelope, ApiError> {
    self.apiRequest(
      route: .leaderboard(
        .fetch(
          gameMode: gameMode,
          language: .en,
          timeScope: timeScope
        )
      ),
      as: FetchLeaderboardResponse.self
    )
    .compactMap { response in
      response.entries.first.map { firstEntry in
        ResultEnvelope(
          outOf: firstEntry.outOf,
          results: response.entries.map { entry in
            ResultEnvelope.Result(
              denseRank: entry.rank,
              id: entry.id.rawValue,
              isYourScore: entry.isYourScore,
              rank: entry.rank,
              score: entry.score,
              subtitle: nil,
              title: entry.playerDisplayName ?? (entry.isYourScore ? "You" : "Someone")
            )
          }
        )
      }
    }
    .eraseToEffect()
  }
}

public struct APIClientSample {
    let baseURL: URL
}

extension APIClientSample {
    static func live(baseURL: URL) -> APIClientSample {
        APIClientSample(baseURL: baseURL)
    }

    func 何かのリクエスト(accessToken: String) -> Effect<Response, Error> {
        let request = UsersMeRequest(baseURL: baseURL, accessToken: accessToken)

        return Effect.future { callback in
           ...
        }
    }
}

                何かのCore.Environment(
                    constants: $0.constants,
                    mainQueue: $0.mainQueue,
                    updateQueue: DispatchQueue.global().eraseToAnyScheduler(),
                    何かのリクエスト: $0.apiClient.何かのリクエスト(accessToken:),
                )

...
public enum ExampleAction: Equatable {
    case onAppear
    case request
    case response(Result<Void, Error>) // ここでのErrorはSwift.Error

    // VoidとErrorがEqutableに準拠してないためここで==を実装してる
    public static func == (lhs: ExampleAction, rhs: ExampleAction) -> Bool {
        switch (lhs, rhs) {
        case (.onAppear, .onAppear),
             (.request, .request),
             (.response, .response):
            return true
        case (.request, _),
             (.onAppear, _),
             (.response, _):
            return false
        }
    }
}
...

...
public struct LocalDatabaseClient {
  public var fetchGamesForWord: (String) -> Effect<[LocalDatabaseClient.Game], Error>

...

...
extension LocalDatabaseClient {
  public static func live(path: URL) -> Self {
    var _db: Sqlite!
    func db() throws -> Sqlite {
      if _db == nil {
        try! FileManager.default.createDirectory(
          at: path.deletingLastPathComponent(), withIntermediateDirectories: true
        )
        _db = try Sqlite(path: path.absoluteString)
      }
      return _db
    }
    return Self(
      fetchGamesForWord: { word in .catching { try db().fetchGames(for: word) } },
...

...
    case let .wordTapped(word):
      return environment.database.fetchGamesForWord(word.letters)
        .map { .init(games: $0, word: word.letters) }
        .mapError { $0 as NSError }
        .catchToEffect()
        .map(VocabAction.gamesResponse)
    }
...

...
public enum VocabAction: Equatable {
  case dismissCubePreview
  case gamesResponse(Result<VocabState.GamesResponse, NSError>)
  case onAppear
  case preview(CubePreviewAction)
  case vocabResponse(Result<LocalDatabaseClient.Vocab, NSError>)
  case wordTapped(LocalDatabaseClient.Vocab.Word)
}
...

...

public struct LocalDatabaseClient {
...
  public var saveGame: (CompletedGame) -> Effect<Void, Error>
...

...
    let saveGameEffect: Effect<GameAction, Never> = environment.database
      .saveGame(.init(gameState: self))
      .fireAndForget()
...

public struct TurnBasedMatchClient {
  public var endMatchInTurn: (EndMatchInTurnRequest) -> Effect<Void, Error>
  public var endTurn: (EndTurnRequest) -> Effect<Void, Error>
  public var load: (TurnBasedMatch.Id) -> Effect<TurnBasedMatch, Error>
  public var loadMatches: () -> Effect<[TurnBasedMatch], Error>
  public var participantQuitInTurn:
    (TurnBasedMatch.Id, Data)
      -> Effect<Error?, Never>
  public var participantQuitOutOfTurn:
    (TurnBasedMatch.Id)
      -> Effect<Error?, Never>

// 成功したらSuccess、失敗したらError
public var foo: ()-> Effect<Success, Error>

// Successは内容がない
struct Success: Hashable {}