All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.kynthus.hatalib.argparse.syntax.ParserSyntax0.scala Maven / Gradle / Ivy

The newest version!
package org.kynthus.hatalib.argparse.syntax

import org.kynthus.hatalib.argparse.concept._
import scalaz.{@@, \/, ~~>}
import scopt.OParser

import scala.language.{higherKinds, implicitConversions}

/**
 * 各種パーサ構築のためのメソッド拡張用クラスの第1候補です。
 *
 * @author Kynthus Auoeau
 * @since 1.0.0
 * @version 1.0.0
 */
private[syntax] trait ParserSyntax0 extends Any with ParserSyntax1 {

  /**
   * 新しい型に対応したオプションを追加するメソッドを付与するクラスへの暗黙変換です。
   *
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @return 新しい型に対応したオプションを追加するメソッドを付与するクラスのインスタンス
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  implicit final def ElementParserOps[
    Derived,
    Input,
    Instance
  ](derived: => Derived @@ (Input @@ Instance)):
  ParserSyntax0.ElementParserOps[Derived, Input, Instance] =
    ParserSyntax0.ElementParserOps(() => derived)

  /**
   * 型を持たないオプションを追加するメソッドを付与するクラスへの暗黙変換です。
   *
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @return 新しい型に対応したオプションを追加するメソッドを付与するクラスのインスタンス
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  implicit final def UnitParserOps[
    Derived,
    Input,
    Instance
  ](derived: => Derived @@ (Input @@ Instance)):
  ParserSyntax0.UnitParserOps[Derived, Input, Instance] =
    ParserSyntax0.UnitParserOps(() => derived)

  /**
   * オプションに対する詳細設定を行うメソッドを付与するクラスへの暗黙変換です。
   *
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @return 新しい型に対応したオプションを追加するメソッドを付与するクラスのインスタンス
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  implicit final def ConfigParserOps[
    Derived,
    Input,
    Instance
  ](derived: => Derived @@ (Input @@ Instance)):
  ParserSyntax0.ConfigParserOps[Derived, Input, Instance] =
    ParserSyntax0.ConfigParserOps(() => derived)

  /**
   * 子パーサへの分岐を行うメソッドを付与するクラスへの暗黙変換です。
   *
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @return 新しい型に対応したオプションを追加するメソッドを付与するクラスのインスタンス
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  implicit final def ChildrenParserOps[
    Derived,
    Input,
    Instance
  ](derived: Derived @@ (Input @@ Instance)):
  ParserSyntax0.ChildrenParserOps[Derived, Input, Instance] =
    ParserSyntax0.ChildrenParserOps(() => derived)

  /**
   * 親パーサへ合流を行うメソッドを付与するクラスへの暗黙変換です。
   *
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @return 新しい型に対応したオプションを追加するメソッドを付与するクラスのインスタンス
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  implicit final def ParentParserOps[
    Derived,
    Input,
    Instance
  ](derived: => Derived @@ (Input @@ Instance)):
  ParserSyntax0.ParentParserOps[Derived, Input, Instance] =
    ParserSyntax0.ParentParserOps(() => derived)

}

/**
 * 各種パーサ構築のためのメソッド拡張用クラスの第1候補を内部的に定義します。
 *
 * @author Kynthus Auoeau
 * @since 1.0.0
 * @version 1.0.0
 */
private object ParserSyntax0 extends AnyRef {

  /**
   * 新しい型に対応したオプションを追加するメソッドを付与するクラスです。
   *
   * @constructor 新しい型に対応したオプションを追加する拡張メソッド使用時に暗黙のうちに呼び出されます。
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  private[syntax] final case class ElementParserOps[
    Derived,
    Input,
    Instance
  ](derived: () => Derived @@ (Input @@ Instance)) extends AnyRef {

    /**
     * パーサに設定したオプションをまとめて追加します。
     *
     * @param parser 追加するオプション
     * @param base   オプションを追加できることを保証する
     * @tparam NewInput 新しい現在値の型
     * @tparam Output   オプションをパーサへ追加した後の型
     * @return 現在の型を更新し、オプションを追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def parser[NewInput, Output]
    (parser: OParser[NewInput, Instance])
    (
      implicit
      base: ElementParser.Aux[
        Derived @@ (Input @@ Instance),
        NewInput,
        Instance,
        Output
      ]
    ): Output = ElementParser.apply.apply(this.derived(), parser)

    /**
     * [[scala.Unit]]型を新たな現在値の型とし、単独の位置引数を追加します。
     *
     * @param name 位置引数名
     * @param base オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return 現在の型を[[scala.Unit]]へ更新し、位置引数を追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def arg[Output]
    (name: String)
    (
      implicit
      base: ElementParser.Aux[
        Derived @@ (Input @@ Instance),
        Unit,
        Instance,
        Output
      ]
    ): Output = this.arg(name, classOf[Unit])

    /**
     * クラス情報をもとに新しい現在値の型へ更新し、単独の位置引数を追加します。
     *
     * @param name    位置引数名
     * @param element 新しい現在値の型のクラス情報
     * @param base    オプションを追加できることを保証する
     * @tparam NewInput 新しい現在値の型
     * @tparam Output   オプションをパーサへ追加した後の型
     * @return 現在の型を更新し、位置引数を追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def arg[NewInput, Output]
    (name: String, element: => Class[NewInput])
    (
      implicit
      base: ElementParser.Aux[
        Derived @@ (Input @@ Instance),
        NewInput,
        Instance,
        Output
      ]
    ): Output = ElementParser.apply.arg(this.derived(), name)

    /**
     * 関数の戻り値をもとに新しい現在値の型へ更新し、単独の位置引数を追加します。
     *
     * @param name    位置引数名
     * @param element 新しい現在値を返す処理
     * @param base    オプションを追加できることを保証する
     * @tparam NewInput 新しい現在値の型
     * @tparam Output   オプションをパーサへ追加した後の型
     * @return 現在の型を更新し、位置引数を追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def arg[NewInput, Output]
    (name: String, element: Instance => NewInput)
    (
      implicit
      base: ElementParser.Aux[
        Derived @@ (Input @@ Instance),
        NewInput,
        Instance,
        Output
      ]
    ): Output = ElementParser.apply.arg(this.derived(), name)

    /**
     * [[scala.Unit]]型を新たな現在値の型とし、単独のオプション付き引数を追加します。
     *
     * @param name オプション名
     * @param base オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return 現在の型を[[scala.Unit]]へ更新し、オプション付き引数を追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def opt[Output]
    (name: String)
    (
      implicit
      base: ElementParser.Aux[
        Derived @@ (Input @@ Instance),
        Unit,
        Instance,
        Output
      ]
    ): Output = this.opt(name, classOf[Unit])

    /**
     * クラス情報をもとに新しい現在値の型へ更新し、単独のオプション付き引数を追加します。
     *
     * @param name    オプション名
     * @param element 新しい現在値の型のクラス情報
     * @param base    オプションを追加できることを保証する
     * @tparam NewInput 新しい現在値の型
     * @tparam Output   オプションをパーサへ追加した後の型
     * @return 現在の型を更新し、オプション付き引数を追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def opt[NewInput, Output]
    (name: String, element: => Class[NewInput])
    (
      implicit
      base: ElementParser.Aux[
        Derived @@ (Input @@ Instance),
        NewInput,
        Instance,
        Output
      ]
    ): Output = ElementParser.apply.opt(this.derived(), name)

    /**
     * 関数の戻り値をもとに新しい現在値の型へ更新し、単独のオプション付き引数を追加します。
     *
     * @param name    オプション名
     * @param element 新しい現在値を返す処理
     * @param base    オプションを追加できることを保証する
     * @tparam NewInput 新しい現在値の型
     * @tparam Output   オプションをパーサへ追加した後の型
     * @return 現在の型を更新し、オプション付き引数を追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def opt[NewInput, Output]
    (name: String, element: Instance => NewInput)
    (
      implicit
      base: ElementParser.Aux[
        Derived @@ (Input @@ Instance),
        NewInput,
        Instance,
        Output
      ]
    ): Output = ElementParser.apply.opt(this.derived(), name)

  }

  /**
   * 型を持たないオプションを追加するメソッドを付与するクラスです。
   *
   * @constructor 型を持たないオプションを追加する拡張メソッド使用時に暗黙のうちに呼び出されます。
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  private[syntax] final case class UnitParserOps[
    Derived,
    Input,
    Instance
  ](derived: () => Derived @@ (Input @@ Instance)) extends AnyRef {

    /**
     * プログラム名を設定します。
     *
     * @param name プログラム名
     * @param base オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return プログラム名を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def programName[Output]
    (name: String)
    (
      implicit
      base: UnitParser.Aux[
        Derived @@ (Input @@ Instance),
        Instance,
        Output
      ]
    ): Output = UnitParser.apply.programName(this.derived(), name)

    /**
     * ヘッダメッセージを設定します。
     *
     * @param message ヘッダメッセージ
     * @param base    オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return ヘッダメッセージを追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def head[Output]
    (message: String*)
    (
      implicit
      base: UnitParser.Aux[
        Derived @@ (Input @@ Instance),
        Instance,
        Output
      ]
    ): Output = UnitParser.apply.head(this.derived(), message: _*)

    /**
     * サブコマンドを追加します。
     *
     * @param name サブコマンド名
     * @param base オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return サブコマンドを追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def cmd[Output]
    (name: String)
    (
      implicit
      base: UnitParser.Aux[
        Derived @@ (Input @@ Instance),
        Instance,
        Output
      ]
    ): Output = UnitParser.apply.cmd(this.derived(), name)

    /**
     * ヘルプ表示用のオプションを追加します。
     *
     * @param name ヘルプ表示用のオプション名
     * @param base オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return ヘルプ表示用のオプションを追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def help[Output]
    (name: String)
    (
      implicit
      base: UnitParser.Aux[
        Derived @@ (Input @@ Instance),
        Instance,
        Output
      ]
    ): Output = UnitParser.apply.help(this.derived(), name)

    /**
     * バージョン表示用のオプションを追加します。
     *
     * @param name バージョン表示用のオプション名
     * @param base オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return バージョン表示用のオプションを追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def version[Output]
    (name: String)
    (
      implicit
      base: UnitParser.Aux[
        Derived @@ (Input @@ Instance),
        Instance,
        Output
      ]
    ): Output = UnitParser.apply.version(this.derived(), name)

    /**
     * コマンドの使用方法として表示されるメッセージを追加します。
     *
     * @param message コマンド使用方法のメッセージ
     * @param base    オプションを追加できることを保証する
     * @tparam Output オプションをパーサへ追加した後の型
     * @return コマンドの使用方法を追加した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def note[Output]
    (message: String)
    (
      implicit
      base: UnitParser.Aux[
        Derived @@ (Input @@ Instance),
        Instance,
        Output
      ]
    ): Output = UnitParser.apply.note(this.derived(), message)

    /**
     * 実際にコマンドから渡されたオプション値を検証します。
     *
     * コマンドライン引数の解析後に実行され、インスタンスが持つフィールド値を見て判断を行います。
     * 正常値であれば成功を示す型を、異常値であれば失敗を示す型を返します。
     *
     * 今後予想されるScalaz 7.3.x系への移行に備え、
     * いったん[[scalaz.\/]]へ変換後に、その後[[scala.Either]]へ変換します。
     *
     * @param checker       フィールド値に対する、正常・異常の判定処理
     * @param base          オプションを追加できることを保証する
     * @param toDisjunction 成功・失敗を表現可能な型から[[scalaz.\/]]へ変換できることを保証する
     * @param toEither      [[scalaz.\/]]から[[scala.Either]]へ変換できることを保証する
     * @tparam UnusedRight    成功を表現する型が持つ右側の型([[scala.Unit]]への変換により破棄)
     * @tparam UnusedCategory 2つの型パラメータを持ち、成功・失敗を表現可能な型
     * @tparam Output         オプションをパーサへ追加した後の型
     * @return 検証処理を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def checkConfig[UnusedRight, UnusedCategory[_, _], Output]
    (checker: Instance => UnusedCategory[String, UnusedRight])
    (
      implicit
      base: UnitParser.Aux[
        Derived @@ (Input @@ Instance),
        Instance,
        Output
      ],
      toDisjunction: UnusedCategory ~~> \/,
      toEither: \/ ~~> Either
    ): Output = UnitParser.apply.checkConfig(this.derived(), checker)

  }

  /**
   * オプションに対する詳細設定を行うメソッドを付与するクラスです。
   *
   * @constructor オプションに対する詳細設定を行う拡張メソッド使用時に暗黙のうちに呼び出されます。
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  private[syntax] final case class ConfigParserOps[
    Derived,
    Input,
    Instance
  ](derived: () => Derived @@ (Input @@ Instance)) extends AnyRef {

    /**
     * オプションに対して別名を設定します。
     *
     * @param name オプションの別名
     * @param base 詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 別名を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def abbr[Output]
    (name: String)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.abbr(this.derived(), name)

    /**
     * オプションが指定された際に実行する処理のうち、固定値の設定用に使用します。
     *
     * @param function 固定値を設定する処理
     * @param base     詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 実行する処理を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def set[Output]
    (function: Instance => Instance)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = this.action((instance, _) => function(instance))

    /**
     * オプションが指定された際に実行する処理を設定します。
     *
     * @param function 実行する処理
     * @param base     詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 実行する処理を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def action[Output]
    (function: (Instance, Input) => Instance)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.action(this.derived(), function)

    /**
     * オプションの説明文を設定します。
     *
     * @param message オプションに対する説明文
     * @param base    詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return オプションの説明文を設定します。
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def text[Output]
    (message: String)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.text(this.derived(), message)

    /**
     * オプションに最低限必要な引数の数を設定します。
     *
     * @param occurs 最低限必要な引数の数
     * @param base   詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 最低限必要な引数の数を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def minOccurs[Output]
    (occurs: Int)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.minOccurs(this.derived(), occurs)

    /**
     * オプションに引数をいくつまで指定できるかを設定します。
     *
     * @param occurs 引数の最大数
     * @param base   詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 引数の最大数を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def maxOccurs[Output]
    (occurs: Int)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.maxOccurs(this.derived(), occurs)

    /**
     * オプションを必須扱いにします。
     *
     * @param base 詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return オプションを必須化した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def required[Output]
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.required(this.derived())

    /**
     * オプションを任意(省略可能)にします。
     *
     * @param base 詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return オプションを任意化した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def optional[Output]
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.optional(this.derived())

    /**
     * オプションに対して引数を無制限に指定できるようにします。
     *
     * @param base 詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 引数の指定数を無制限とした結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def unbounded[Output]
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.unbounded(this.derived())

    /**
     * オプションを隠しオプションにします。
     *
     * @param base 詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 隠しオプション化した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def hidden[Output]
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.hidden(this.derived())

    /**
     * オプションのキー名を設定します。
     *
     * @param name キー名
     * @param base 詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return キー名を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def keyName[Output]
    (name: String)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.keyName(this.derived(), name)

    /**
     * オプションの値名を設定します。
     *
     * @param name 値名
     * @param base 詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return 値名を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def valueName[Output]
    (name: String)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.valueName(this.derived(), name)

    /**
     * オプションのキー名と値名を設定します。
     *
     * @param keyName   キー名
     * @param valueName 値名
     * @param base      詳細設定が可能なことを保証する
     * @tparam Output オプションへ詳細設定を適用した後の型
     * @return キー名と値名を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def keyValueName[Output]
    (keyName: String, valueName: String)
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ]
    ): Output = ConfigParser.apply.keyValueName(this.derived(), keyName, valueName)

    /**
     * 実際にコマンドから渡されたオプション値を検証します。
     *
     * コマンドライン引数の解析中に実行され、オプションに対する引数の値を判断します。
     * 正常値であれば成功を示す型を、異常値であれば失敗を示す型を返します。
     *
     * 今後予想されるScalaz 7.3.x系への移行に備え、
     * いったん[[scalaz.\/]]へ変換後に、その後[[scala.Either]]へ変換します。
     *
     * @param validator     検証処理
     * @param base          詳細設定が可能なことを保証する
     * @param toDisjunction 成功・失敗を表現可能な型から[[scalaz.\/]]へ変換できることを保証する
     * @param toEither      [[scalaz.\/]]から[[scala.Either]]へ変換できることを保証する
     * @tparam UnusedRight    成功を表現する型が持つ右側の型([[scala.Unit]]への変換により破棄)
     * @tparam UnusedCategory 2つの型パラメータを持ち、成功・失敗を表現可能な型
     * @tparam Output         オプションへ詳細設定を適用した後の型
     * @return 検証処理を設定した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def validate[UnusedRight, UnusedCategory[_, _], Output]
    (validator: Input => UnusedCategory[String, UnusedRight])
    (
      implicit
      base: ConfigParser.Aux[
        Derived @@ (Input @@ Instance),
        Input,
        Instance,
        Output
      ],
      toDisjunction: UnusedCategory ~~> \/,
      toEither: \/ ~~> Either
    ): Output = ConfigParser.apply.validate(this.derived(), validator)

  }

  /**
   * 子パーサへの分岐を行うメソッドを付与するクラスです。
   *
   * @constructor 子パーサへの分岐を行う拡張メソッド使用時に暗黙のうちに呼び出されます。
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  private[syntax] final case class ChildrenParserOps[
    Derived,
    Input,
    Instance
  ](derived: () => Derived @@ (Input @@ Instance)) extends AnyRef {

    /**
     * 子パーサへ分岐した結果を返します。
     *
     * @param base 子パーサへ分岐可能なことを保証する
     * @tparam Output 子パーサへ分岐した後の型
     * @return 子パーサへ分岐した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def children[Output]
    (
      implicit
      base: ChildrenParser.Aux[
        Derived @@ (Input @@ Instance),
        Output
      ]
    ): Output = ChildrenParser.apply.apply(this.derived())

  }

  /**
   * 親パーサへ合流を行うメソッドを付与するクラスです。
   *
   * @constructor 親パーサへ合流を行う拡張メソッド使用時に暗黙のうちに呼び出されます。
   * @param derived 構築中のパーサを保持する値
   * @tparam Derived  構築中のパーサを保持する型
   * @tparam Input    現在値の型
   * @tparam Instance 各オプションの初期値を持つ型
   * @author Kynthus Auoeau
   * @since 1.0.0
   * @version 1.0.0
   */
  private[syntax] final case class ParentParserOps[
    Derived,
    Input,
    Instance
  ](derived: () => Derived @@ (Input @@ Instance)) extends AnyRef {

    /**
     * 親パーサへ合流した結果を返します。
     *
     * @param base 親パーサへ合流可能なことを保証する
     * @tparam Output 親パーサへ合流した後の型
     * @return 親パーサへ合流した結果
     * @author Kynthus Auoeau
     * @since 1.0.0
     * @version 1.0.0
     */
    def parent[Output]
    (
      implicit
      base: ParentParser.Aux[
        Derived @@ (Input @@ Instance),
        Output
      ]
    ): Output = ParentParser.apply.apply(this.derived())

  }

}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy