util

abstract def getClass(): Class[_]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit final def ArgsOps[Derived](derived: ⇒ Derived): ArgsOps[Derived]

implicit final def ArgumentOps[Derived](derived: ⇒ Derived): ArgumentOps[Derived]

implicit final val ArrayFoldable: Foldable[Array]

implicit final def BiNaturalTransformationOps[Category[_, _], Element1, Element2](derived: ⇒ Category[Element1, Element2]): BiNaturalTransformationOps[Category, Element1, Element2]

implicit final def BifoldableArgument[ConvertingElement1, ConvertingElement2, ConvertingCategory[_, _], ConvertedElement, ConvertedCategory[_]](implicit arg0: Bifoldable[ConvertingCategory], argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plusEmpty: PlusEmpty[ConvertedCategory], lazyElement1Argument: Lazy[Aux[ConvertingElement1, ConvertedCategory[ConvertedElement]]], lazyElement2rgument: Lazy[Aux[ConvertingElement2, ConvertedCategory[ConvertedElement]]]): Aux[ConvertingCategory[ConvertingElement1, ConvertingElement2], ConvertedCategory[ConvertedElement]]

implicit final def BuilderOps[Derived](derived: ⇒ Derived): BuilderOps[Derived]

implicit final def CConsArgument[ConvertingHead, ConvertingTail <: Coproduct, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], lazyHeadArgument: Lazy[Aux[ConvertingHead, ConvertedCategory[ConvertedElement]]], tailArguments: Aux[ConvertingTail, ConvertedCategory[ConvertedElement]]): Aux[:+:[ConvertingHead, ConvertingTail], ConvertedCategory[ConvertedElement]]

implicit final def CNilArgument[ExtendsCNil <: CNil, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plusEmpty: PlusEmpty[ConvertedCategory]): Aux[ExtendsCNil, ConvertedCategory[ConvertedElement]]

implicit final def CategoryArgs[ConvertingArgument, ConvertedArgument, ConvertedCategory[_], DerivedArgs, OutputArgs, OutputCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedArgument], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], runCategory: @@[ResultCategory[OutputCategory], Run.type], bind: Bind[OutputCategory], base: Aux[DerivedArgs, ConvertingArgument, OutputCategory[OutputArgs]]): Aux[OutputCategory[DerivedArgs], ConvertingArgument, OutputCategory[OutputArgs]]

implicit final def CategoryChildrenParserOps[Derived, Category[_], Input, Instance](derived: ⇒ Category[@@[Derived, @@[Input, Instance]]])(implicit runCategory: @@[ResultCategory[Category], Run.type], bind: Bind[Category]): CategoryChildrenParserOps[Derived, Category, Input, Instance]

implicit final def CategoryConfigParserOps[Derived, Category[_], Input, Instance](derived: ⇒ Category[@@[Derived, @@[Input, Instance]]])(implicit runCategory: @@[ResultCategory[Category], Run.type], bind: Bind[Category]): CategoryConfigParserOps[Derived, Category, Input, Instance]

implicit final def CategoryElementParserOps[Derived, Category[_], Input, Instance](derived: ⇒ Category[@@[Derived, @@[Input, Instance]]])(implicit runCategory: @@[ResultCategory[Category], Run.type], bind: Bind[Category]): CategoryElementParserOps[Derived, Category, Input, Instance]

implicit final def CategoryInitial[ConvertingField, ConvertedField <: HList, DerivedInitial, OutputInitial, OutputCategory[_]](implicit runCategory: @@[ResultCategory[OutputCategory], Run.type], bind: Bind[OutputCategory], base: Aux[DerivedInitial, ConvertingField, OutputCategory[OutputInitial]]): Aux[OutputCategory[DerivedInitial], ConvertingField, OutputCategory[OutputInitial]]

implicit final def CategoryParentParserOps[Derived, Category[_], Input, Instance](derived: ⇒ Category[@@[Derived, @@[Input, Instance]]])(implicit runCategory: @@[ResultCategory[Category], Run.type], bind: Bind[Category]): CategoryParentParserOps[Derived, Category, Input, Instance]

implicit final def CategoryRun[Instance, Element, Category[_], Running, Ran[_]](implicit argumentElement: @@[ResultElement[Element], Argument.type], argumentConverter: @@[Aux[Element, String], Argument.type], argumentCategory: @@[ResultCategory[Category], Argument.type], runCategory: @@[ResultCategory[Ran], Run.type], bind: Bind[Ran], base: @@[Aux[Running, Ran[Instance]], scopt.OParser.type]): @@[Aux[Ran[Running], Ran[Instance]], scopt.OParser.type]

implicit final def CategorySetup[InsertingSetup, InsertedSetup, InsertedCategory[_]](implicit runCategory: @@[ResultCategory[InsertedCategory], Run.type], bind: Bind[InsertedCategory], base: Aux[InsertingSetup, InsertedCategory[InsertedSetup]]): Aux[InsertedCategory[InsertingSetup], InsertedCategory[InsertedSetup]]

implicit final def CategoryUnitParserOps[Derived, Category[_], Input, Instance](derived: ⇒ Category[@@[Derived, @@[Input, Instance]]])(implicit runCategory: @@[ResultCategory[Category], Run.type], bind: Bind[Category]): CategoryUnitParserOps[Derived, Category, Input, Instance]

implicit final def ChildrenParserOps[Derived, Input, Instance](derived: @@[Derived, @@[Input, Instance]]): ChildrenParserOps[Derived, Input, Instance]

implicit final def ConfigParserOps[Derived, Input, Instance](derived: ⇒ @@[Derived, @@[Input, Instance]]): ConfigParserOps[Derived, Input, Instance]

implicit final def ConverterOps[Derived](derived: ⇒ Derived): ConverterOps[Derived]

implicit final def ConvertibleArgument[ConvertingArgument, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], applicative: Applicative[ConvertedCategory], elementConverter: @@[Aux[ConvertingArgument, ConvertedElement], Argument.type]): Aux[ConvertingArgument, ConvertedCategory[ConvertedElement]]

implicit final def DefaultSetupRun[Input, Instance, Element, Category[_], Running <: HList, Hierarchy <: HList, Ran[_]](implicit argumentElement: @@[ResultElement[Element], Argument.type], argumentConverter: @@[Aux[Element, String], Argument.type], argumentCategory: @@[ResultCategory[Category], Argument.type], runCategory: @@[ResultCategory[Ran], Run.type], currentSelector: Aux[Running, T, scopt.OParser[Input, Instance]], hierarchySelector: Aux[Running, T, Hierarchy], hierarchyTraversable: Aux[Hierarchy, Seq, scopt.OParser[_, Instance]], decidedSelector: Aux[Running, T, List[Queue[scopt.OParser[_, Instance]]]], argsSelector: Aux[Running, T, Category[Element]], initialSelector: Aux[Running, T, Instance], categoryToSeq: ~>[Category, Seq], optionToRan: ~>[Option, Ran], setupNotExist: Refute[Selector[Running, T]]): @@[Aux[@@[Running, @@[Input, Instance]], Ran[Instance]], scopt.OParser.type]

implicit final val DisjunctionIdentityBiNaturalTransformation: ~~>[\/, \/]

implicit final val DisjunctionToEitherBiNaturalTransformation: ~~>[\/, Either]

implicit final val DisjunctionToValidationBiNaturalTransformation: ~~>[\/, Validation]

implicit final def DurationArgument[ExtendsDuration <: Duration, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], lazyStringArgument: Lazy[Aux[String, ConvertedCategory[ConvertedElement]]], lazyPairArgument: Lazy[Aux[(Long, TimeUnit), ConvertedCategory[ConvertedElement]]]): Aux[ExtendsDuration, ConvertedCategory[ConvertedElement]]

implicit final val EitherIdentityBiNaturalTransformation: ~~>[Either, Either]

implicit final val EitherToDisjunctionBiNaturalTransformation: ~~>[Either, \/]

implicit final val EitherToValidationBiNaturalTransformation: ~~>[Either, Validation]

implicit final def ElementParserOps[Derived, Input, Instance](derived: ⇒ @@[Derived, @@[Input, Instance]]): ElementParserOps[Derived, Input, Instance]

implicit final def FieldOps[Derived](derived: ⇒ Derived): FieldOps[Derived]

implicit final def FieldTypeArgument[ConvertingKey, ConvertingValue, ConvertedElement, ConvertedCategory[_]](implicit arg0: Aux[ConvertingKey], argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], lazyPairArgument: Lazy[Aux[(ConvertingKey, ConvertingValue), ConvertedCategory[ConvertedElement]]]): Aux[FieldType[ConvertingKey, ConvertingValue], ConvertedCategory[ConvertedElement]]

implicit final def FieldTypeField[ConvertingKey, ConvertingValue]: Aux[FieldType[ConvertingKey, ConvertingValue], ::[FieldType[ConvertingKey, ConvertingValue], HNil]]

implicit final def FieldTypeToTuple2Converter[Key, Value](implicit arg0: Aux[Key]): Aux[FieldType[Key, Value], (Key, Value)]

implicit final def Foldable1Argument[ConvertingElement, ConvertingCategory[_], ConvertedElement, ConvertedCategory[_]](implicit arg0: Foldable1[ConvertingCategory], argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plus: Plus[ConvertedCategory], lazyElementArgument: Lazy[Aux[ConvertingElement, ConvertedCategory[ConvertedElement]]]): Aux[ConvertingCategory[ConvertingElement], ConvertedCategory[ConvertedElement]]

implicit final def FoldableArgument[ConvertingElement, ConvertingCategory[_], ConvertedElement, ConvertedCategory[_]](implicit arg0: Foldable[ConvertingCategory], argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plusEmpty: PlusEmpty[ConvertedCategory], lazyElementArgument: Lazy[Aux[ConvertingElement, ConvertedCategory[ConvertedElement]]]): Aux[ConvertingCategory[ConvertingElement], ConvertedCategory[ConvertedElement]]

implicit final def FoldableToSeqNaturalTransformation[Category[_]](implicit arg0: Foldable[Category]): ~>[Category, Seq]

implicit final val Function0Foldable: Foldable[Function0]

implicit final def GenericArgument[ConvertingFrom, ConvertingTo, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], productGeneric: Aux[ConvertingFrom, ConvertingTo], lazyToArgument: Lazy[Aux[ConvertingTo, ConvertedCategory[ConvertedElement]]]): Aux[ConvertingFrom, ConvertedCategory[ConvertedElement]]

implicit final def GenericOps[Derived](derived: ⇒ Derived): GenericOps[Derived]

implicit final def HCons1Argument[ConvertingElement, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], lazyArgument: Lazy[Aux[ConvertingElement, ConvertedCategory[ConvertedElement]]]): Aux[::[ConvertingElement, HNil], ConvertedCategory[ConvertedElement]]

implicit final def HConsArgument[ConvertingHead, ConvertingTail <: HList, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plus: Plus[ConvertedCategory], lazyHeadArgument: Lazy[Aux[ConvertingHead, ConvertedCategory[ConvertedElement]]], tailArguments: Aux[ConvertingTail, ConvertedCategory[ConvertedElement]]): Aux[::[ConvertingHead, ConvertingTail], ConvertedCategory[ConvertedElement]]

implicit final def HConsField[ConvertingHead, ConvertedHead <: HList, ConvertingTail <: HList, ConvertedTail <: HList, ConvertedField <: HList](implicit lazyHeadField: Lazy[Aux[ConvertingHead, ConvertedHead]], tailFields: Aux[ConvertingTail, ConvertedTail], fieldMerger: shapeless.ops.record.Merger.Aux[ConvertedHead, ConvertedTail, ConvertedField]): Aux[::[ConvertingHead, ConvertingTail], ConvertedField]

implicit final def HNilArgument[ExtendsHNil <: HNil, ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plusEmpty: PlusEmpty[ConvertedCategory]): Aux[ExtendsHNil, ConvertedCategory[ConvertedElement]]

implicit final def HNilField[ExtendsHNil <: HNil]: Aux[ExtendsHNil, HNil]

implicit final def InitialOps[Derived](derived: ⇒ Derived): InitialOps[Derived]

implicit final def InsertArgs[ConvertingArgument, ConvertedArgument, ConvertedCategory[_], UnusedKeys, InsertingArgs <: HList, InsertedArgs <: HList, InsertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedArgument], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], runCategory: @@[ResultCategory[InsertedCategory], Run.type], applicative: Applicative[InsertedCategory], argument: Aux[ConvertingArgument, ConvertedCategory[ConvertedArgument]], argsUpdater: Aux[InsertingArgs, FieldType[T, ConvertedCategory[ConvertedArgument]], InsertedArgs], argsNotExist: Refute[Selector[InsertingArgs, T]]): Aux[@@[InsertingArgs, UnusedKeys], ConvertingArgument, InsertedCategory[@@[InsertedArgs, UnusedKeys]]]

implicit final def InsertElementParser[Input, Instance, NewInput, InsertingParser <: HList, InsertedParser <: HList, InsertedCategory[_]](implicit arg0: Read[NewInput], runCategory: @@[ResultCategory[InsertedCategory], Run.type], applicative: Applicative[InsertedCategory], currentUpdater: Aux[InsertingParser, FieldType[T, scopt.OParser[NewInput, Instance]], InsertedParser], currentNotExist: Refute[Selector[InsertingParser, T]]): Aux[@@[InsertingParser, @@[Input, Instance]], NewInput, Instance, InsertedCategory[@@[InsertedParser, @@[NewInput, Instance]]]]

implicit final def InsertInitial[ConvertingField, ConvertedField <: HList, UnusedKeys, InsertingInitial <: HList, InsertedDecided <: HList, InsertedInitial <: HList, InsertedCategory[_]](implicit runCategory: @@[ResultCategory[InsertedCategory], Run.type], applicative: Applicative[InsertedCategory], initialField: Aux[ConvertingField, ConvertedField], decidedUpdater: Aux[InsertingInitial, FieldType[T, List[Queue[scopt.OParser[_, ConvertedField]]]], InsertedDecided], initialUpdater: Aux[InsertedDecided, FieldType[T, ConvertedField], InsertedInitial], currentNotExist: Refute[Selector[InsertingInitial, T]], initialNotExist: Refute[Selector[InsertingInitial, T]]): Aux[@@[InsertingInitial, UnusedKeys], ConvertingField, InsertedCategory[@@[InsertedInitial, @@[Unit, ConvertedField]]]]

implicit final def InsertSetup[InsertingSetup <: HList, UnusedKeys, InsertedSetup <: HList, InsertedCategory[_]](implicit runCategory: @@[ResultCategory[InsertedCategory], Run.type], applicative: Applicative[InsertedCategory], setupUpdater: Aux[InsertingSetup, FieldType[T, scopt.OParserSetup], InsertedSetup], setupNotExist: Refute[Selector[InsertingSetup, T]]): Aux[@@[InsertingSetup, UnusedKeys], InsertedCategory[@@[InsertedSetup, UnusedKeys]]]

implicit final def InsertUnitParser[UnusedInput, Instance, InsertingParser <: HList, InsertedParser <: HList, InsertedCategory[_]](implicit runCategory: @@[ResultCategory[InsertedCategory], Run.type], applicative: Applicative[InsertedCategory], currentUpdater: Aux[InsertingParser, FieldType[T, scopt.OParser[Unit, Instance]], InsertedParser], currentNotExist: Refute[Selector[InsertingParser, T]]): Aux[@@[InsertingParser, @@[UnusedInput, Instance]], Instance, InsertedCategory[@@[InsertedParser, @@[Unit, Instance]]]]

implicit final def IterableSubtypeFoldable[ExtendsIterable[Element] <: Iterable[Element]]: Foldable[ExtendsIterable]

implicit final def IteratorSubtypeFoldable[ExtendsIterator[Element] <: Iterator[Element]]: Foldable[ExtendsIterator]

implicit final def JavaAtomicReferenceArrayFoldable[ExtendsAtomicReferenceArray[Element] <: AtomicReferenceArray[Element]]: Foldable[ExtendsAtomicReferenceArray]

implicit final def JavaAtomicReferenceFoldable[ExtendsAtomicReference[Element] <: AtomicReference[Element]]: Foldable[ExtendsAtomicReference]

implicit final val JavaDictionaryBifoldable: Bifoldable[Dictionary]

implicit final def JavaEnumerationSubtypeFoldable[ExtendsEnumeration[Element] <: Enumeration[Element]]: Foldable[ExtendsEnumeration]

implicit final def JavaIterableSubtypeFoldable[ExtendsIterable[Element] <: Iterable[Element]]: Foldable[ExtendsIterable]

implicit final def JavaIteratorSubtypeFoldable[ExtendsIterator[Element] <: Iterator[Element]]: Foldable[ExtendsIterator]

implicit final def JavaMapSubtypeBifoldable[ExtendsMap[Key, Value] <: Map[Key, Value]]: Bifoldable[ExtendsMap]

implicit final def LabelledGenericField[ConvertingFrom, ConvertingTo, ConvertedField](implicit labelledGeneric: Aux[ConvertingFrom, ConvertingTo], lazyToField: Lazy[Aux[ConvertingTo, ConvertedField]]): Aux[ConvertingFrom, ConvertedField]

implicit final def LabelledGenericOps[Derived](derived: ⇒ Derived): LabelledGenericOps[Derived]

implicit final def LazyIdOps[Derived](derived: ⇒ Derived): LazyIdOps[Derived]

implicit final val LazyOptionIdentityNaturalTransformation: ~>[LazyOption, LazyOption]

implicit final val LazyOptionToMaybeNaturalTransformation: ~>[LazyOption, Maybe]

implicit final val LazyOptionToOptionNaturalTransformation: ~>[LazyOption, Option]

implicit final def LeftWrappedKind2Unapply[Base[_[_]], Derived[_, _], Category[_], Element1, Element2](implicit applier: Base[[$qmark]Derived[Category[?], Element2]]): Unapply[Base, Derived[Category[Element1], Element2]] { ... /* 2 definitions in type refinement */ }

implicit final val ListFoldable: Foldable[List]

implicit final val ListMonadPlus: MonadPlus[List]

implicit final val MaybeIdentityNaturalTransformation: ~>[Maybe, Maybe]

implicit final val MaybeToLazyOptionNaturalTransformation: ~>[Maybe, LazyOption]

implicit final val MaybeToOptionNaturalTransformation: ~>[Maybe, Option]

implicit final def NaturalTransformationOps[Category[_], Element](derived: ⇒ Category[Element]): NaturalTransformationOps[Category, Element]

final val OParser: scopt.OParser.type

scopt.OParserのコンパニオンオブジェクトに対するエイリアス変数です。

implicit final def OParserParseBuilder[Category[_]](implicit runCategory: @@[ResultCategory[Category], Run.type], applicative: Applicative[Category]): @@[Aux[scopt.OParser.type, Category[@@[::[FieldType[T, HNil], HNil], Unit]]], scopt.OParser.type]

implicit final val OptionFoldable: Foldable[Option]

implicit final val OptionIdentityNaturalTransformation: ~>[Option, Option]

implicit final val OptionMonadPlus: MonadPlus[Option]

implicit final val OptionOptional: Optional[Option]

implicit final val OptionToLazyOptionNaturalTransformation: ~>[Option, LazyOption]

implicit final val OptionToMaybeNaturalTransformation: ~>[Option, Maybe]

implicit final def PairIterableSubtypeBifoldable[ExtendsIterable[Element1, Element2] <: Iterable[(Element1, Element2)]]: Bifoldable[ExtendsIterable]

implicit final def PairIteratorSubtypeBifoldable[ExtendsIterator[Element1, Element2] <: Iterator[(Element1, Element2)]]: Bifoldable[ExtendsIterator]

implicit final def PairParIterableSubtypeBifoldable[ExtendsParIterable[Element1, Element2] <: ParIterable[(Element1, Element2)]]: Bifoldable[ExtendsParIterable]

implicit final def ParIterableSubtypeFoldable[ExtendsParIterable[Element] <: ParIterable[Element]]: Foldable[ExtendsParIterable]

implicit final def ParentParserOps[Derived, Input, Instance](derived: ⇒ @@[Derived, @@[Input, Instance]]): ParentParserOps[Derived, Input, Instance]

implicit final def ParseBuilderOps[Derived](derived: ⇒ Derived): ParseBuilderOps[Derived]

implicit final def PhantomOps[Value](derived: ⇒ Value): PhantomOps[Value]

final val RenderingMode: scopt.RenderingMode.type

scopt.RenderingModeのコンパニオンオブジェクトに対するエイリアス変数です。

implicit final def RunOps[Derived](derived: ⇒ Derived): RunOps[Derived]

implicit final def RunProductOps[Derived](derived: ⇒ Derived): RunProductOps[Derived]

implicit final val SetFoldable: Foldable[Set]

implicit final def SetupOps[Derived](derived: ⇒ Derived): SetupOps[Derived]

implicit final val StreamFoldable: Foldable[Stream]

implicit final val StreamMonadPlus: MonadPlus[Stream]

implicit final def TagOps[Derived](derived: ⇒ Derived): TagOps[Derived]

implicit final def TaggedBuilderOps[Derived](derived: ⇒ Derived): TaggedBuilderOps[Derived]

implicit final def TaggedCategoryMonad[Category[_], Tag](implicit arg0: Monad[Category]): Monad[[$qmark]@@[Category[?], Tag]]

implicit final def TaggedCategoryNaturalTransformation[Source[_], Target[_], Tag](implicit transformer: ~>[Source, Target]): ~>[Source, [$qmark]@@[Target[?], Tag]]

implicit final def TaggedCategoryOptional[Category[_], Tag](implicit arg0: Optional[Category]): Optional[[$qmark]@@[Category[?], Tag]]

implicit final def TaggedConverterOps[Derived](derived: ⇒ Derived): TaggedConverterOps[Derived]

implicit final def TaggedRunOps[Derived](derived: ⇒ Derived): TaggedRunOps[Derived]

implicit def ToApplyOps[F[_], A](v: F[A])(implicit F0: Apply[F]): ApplyOps[F, A]

implicit def ToApplyOpsUnapply[FA](v: FA)(implicit F0: Unapply[Apply, FA]): ApplyOps[M, A]

implicit def ToBindOps[F[_], A](v: F[A])(implicit F0: Bind[F]): BindOps[F, A]

implicit def ToBindOpsUnapply[FA](v: FA)(implicit F0: Unapply[Bind, FA]): BindOps[M, A]

implicit def ToFunctorIdV[A](v: A): FunctorIdV[A]

implicit def ToFunctorOps[F[_], A](v: F[A])(implicit F0: Functor[F]): FunctorOps[F, A]

implicit def ToFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[Functor, FA]): FunctorOps[M, A]

implicit def ToInvariantFunctorOps[F[_], A](v: F[A])(implicit F0: InvariantFunctor[F]): InvariantFunctorOps[F, A]

implicit def ToInvariantFunctorOpsUnapply[FA](v: FA)(implicit F0: Unapply[InvariantFunctor, FA]): InvariantFunctorOps[M, A]

implicit def ToLiftV[F[_], A, B](v: (A) ⇒ B): LiftV[F, A, B]

implicit def ToOptionalOps[F[_], A](v: F[A])(implicit F0: Optional[F]): OptionalOps[F, A]

implicit def ToOptionalOpsUnapply[FA](v: FA)(implicit F0: Unapply[Optional, FA]): OptionalOps[M, A]

implicit final def ToSymbolConverter[Derived]: Aux[Derived, Symbol]

implicit final def Tuple2Field[Converting1, Converting2]: Aux[(Aux[Converting1], Converting2), ::[FieldType[Converting1, Converting2], HNil]]

implicit final def Tuple2ToFieldTypeConverter[Element1, Element2]: Aux[(Aux[Element1], Element2), FieldType[Element1, Element2]]

implicit final def UnitArgument[ConvertedElement, ConvertedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedElement], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plusEmpty: PlusEmpty[ConvertedCategory]): Aux[Unit, ConvertedCategory[ConvertedElement]]

implicit final def UnitParserOps[Derived, Input, Instance](derived: ⇒ @@[Derived, @@[Input, Instance]]): UnitParserOps[Derived, Input, Instance]

implicit final def UpdateArgs[ConvertingArgument, ConvertedArgument, ConvertedCategory[_], UnusedKeys, UpdatingArgs <: HList, UpdatedArgs <: HList, UpdatedCategory[_]](implicit argumentElement: @@[ResultElement[ConvertedArgument], Argument.type], argumentCategory: @@[ResultCategory[ConvertedCategory], Argument.type], plus: Plus[ConvertedCategory], runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], argument: Aux[ConvertingArgument, ConvertedCategory[ConvertedArgument]], argsSelector: Aux[UpdatingArgs, T, ConvertedCategory[ConvertedArgument]], argsUpdater: Aux[UpdatingArgs, FieldType[T, ConvertedCategory[ConvertedArgument]], UpdatedArgs]): Aux[@@[UpdatingArgs, UnusedKeys], ConvertingArgument, UpdatedCategory[@@[UpdatedArgs, UnusedKeys]]]

implicit final def UpdateChildrenParser[Input, Instance, UpdatingParser <: HList, ExistHierarchy <: HList, RemovedCurrent <: HList, RemovedHierarchy <: HList, UpdatedHierarchy <: HList, UpdatedDecided <: HList, UpdatedCategory[_]](implicit runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], currentRemover: shapeless.ops.record.Remover.Aux[UpdatingParser, T, (scopt.OParser[Input, Instance], RemovedCurrent)], hierarchyRemover: shapeless.ops.record.Remover.Aux[RemovedCurrent, T, (ExistHierarchy, RemovedHierarchy)], decidedSelector: Aux[UpdatingParser, T, List[Queue[scopt.OParser[_, Instance]]]], hierarchyUpdater: Aux[RemovedHierarchy, FieldType[T, ::[scopt.OParser[Input, Instance], ExistHierarchy]], UpdatedHierarchy], decidedUpdater: Aux[UpdatedHierarchy, FieldType[T, List[Queue[scopt.OParser[_, Instance]]]], UpdatedDecided]): Aux[@@[UpdatingParser, @@[Input, Instance]], UpdatedCategory[@@[UpdatedDecided, @@[Input, Instance]]]]

implicit final def UpdateConfigParser[Input, Instance, UpdatingParser <: HList, UpdatedParser <: HList, UpdatedCategory[_]](implicit runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], currentSelector: Aux[UpdatingParser, T, scopt.OParser[Input, Instance]], currentUpdater: Aux[UpdatingParser, FieldType[T, scopt.OParser[Input, Instance]], UpdatedParser]): Aux[@@[UpdatingParser, @@[Input, Instance]], Input, Instance, UpdatedCategory[@@[UpdatedParser, @@[Input, Instance]]]]

implicit final def UpdateElementParser[Input, Instance, NewInput, UpdatingParser <: HList, RemovedCurrent <: HList, UpdatedCurrent <: HList, UpdatedDecided <: HList, UpdatedCategory[_]](implicit arg0: Read[NewInput], runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], currentRemover: shapeless.ops.record.Remover.Aux[UpdatingParser, T, (scopt.OParser[Input, Instance], RemovedCurrent)], decidedSelector: Aux[UpdatingParser, T, List[Queue[scopt.OParser[_, Instance]]]], currentUpdater: Aux[RemovedCurrent, FieldType[T, scopt.OParser[NewInput, Instance]], UpdatedCurrent], decidedUpdater: Aux[UpdatedCurrent, FieldType[T, List[Queue[scopt.OParser[_, Instance]]]], UpdatedDecided]): Aux[@@[UpdatingParser, @@[Input, Instance]], NewInput, Instance, UpdatedCategory[@@[UpdatedDecided, @@[NewInput, Instance]]]]

implicit final def UpdateInitial[ConvertingField, ConvertedField <: HList, Input, UpdatingInitial <: HList, ExistInitial <: HList, RemovedInitial <: HList, ExistDecided, RemovedDecided <: HList, MergedInitial <: HList, ExistHierarchy <: HList, UpdatedDecided <: HList, UpdatedInitial <: HList, UpdatedCategory[_]](implicit runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], initialField: Aux[ConvertingField, ConvertedField], initialSelector: Aux[UpdatingInitial, T, ExistInitial], initialRemover: shapeless.ops.record.Remover.Aux[UpdatingInitial, T, (ExistInitial, RemovedInitial)], initialMerger: shapeless.ops.record.Merger.Aux[ExistInitial, ConvertedField, MergedInitial], decidedRemover: shapeless.ops.record.Remover.Aux[RemovedInitial, T, (ExistDecided, RemovedDecided)], decidedUpdater: Aux[RemovedDecided, FieldType[T, List[Queue[scopt.OParser[_, MergedInitial]]]], UpdatedDecided], initialUpdater: Aux[UpdatedDecided, FieldType[T, MergedInitial], UpdatedInitial], currentNotExist: Refute[Selector[UpdatingInitial, T]], hierarchySelector: Aux[UpdatingInitial, T, ExistHierarchy], hierarchyIsEmpty: ===[ExistHierarchy, HNil]): Aux[@@[UpdatingInitial, @@[Input, ExistInitial]], ConvertingField, UpdatedCategory[@@[UpdatedInitial, @@[Input, MergedInitial]]]]

implicit final def UpdateParentParser[Input, Instance, NewInput, UpdatingParser <: HList, RemovedCurrent <: HList, UpdatedCurrent <: HList, TailHierarchy <: HList, RemovedHierarchy <: HList, UpdatedHierarchy <: HList, UpdatedDecided <: HList, UpdatedCategory[_]](implicit runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], currentRemover: shapeless.ops.record.Remover.Aux[UpdatingParser, T, (scopt.OParser[Input, Instance], RemovedCurrent)], lazyHierarchyRemover: Lazy[shapeless.ops.record.Remover.Aux[RemovedCurrent, T, (::[scopt.OParser[NewInput, Instance], TailHierarchy], RemovedHierarchy)]], decidedSelector: Aux[UpdatingParser, T, List[Queue[scopt.OParser[_, Instance]]]], currentUpdater: Aux[RemovedHierarchy, FieldType[T, scopt.OParser[NewInput, Instance]], UpdatedCurrent], hierarchyUpdater: Aux[UpdatedCurrent, FieldType[T, TailHierarchy], UpdatedHierarchy], decidedUpdater: Aux[UpdatedHierarchy, FieldType[T, List[Queue[scopt.OParser[_, Instance]]]], UpdatedDecided]): Aux[@@[UpdatingParser, @@[Input, Instance]], UpdatedCategory[@@[UpdatedDecided, @@[NewInput, Instance]]]]

implicit final def UpdateSetup[UnusedKey, HasSetup <: HList, UpdatedCategory[_]](implicit runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], setupSelector: Aux[HasSetup, T, scopt.OParserSetup], setupUpdater: Aux[HasSetup, FieldType[T, scopt.OParserSetup], HasSetup]): Aux[@@[HasSetup, UnusedKey], UpdatedCategory[@@[HasSetup, UnusedKey]]]

implicit final def UpdateUnitParser[Input, Instance, UpdatingParser <: HList, RemovedCurrent <: HList, UpdatedCurrent <: HList, UpdatedDecided <: HList, UpdatedCategory[_]](implicit runCategory: @@[ResultCategory[UpdatedCategory], Run.type], applicative: Applicative[UpdatedCategory], currentRemover: shapeless.ops.record.Remover.Aux[UpdatingParser, T, (scopt.OParser[Input, Instance], RemovedCurrent)], decidedSelector: Aux[UpdatingParser, T, List[Queue[scopt.OParser[_, Instance]]]], currentUpdater: Aux[RemovedCurrent, FieldType[T, scopt.OParser[Unit, Instance]], UpdatedCurrent], decidedUpdater: Aux[UpdatedCurrent, FieldType[T, List[Queue[scopt.OParser[_, Instance]]]], UpdatedDecided]): Aux[@@[UpdatingParser, @@[Input, Instance]], Instance, UpdatedCategory[@@[UpdatedDecided, @@[Unit, Instance]]]]

implicit final def UserSetupRun[Input, Instance, Element, Category[_], Running <: HList, Hierarchy <: HList, Ran[_]](implicit argumentElement: @@[ResultElement[Element], Argument.type], argumentConverter: @@[Aux[Element, String], Argument.type], argumentCategory: @@[ResultCategory[Category], Argument.type], runCategory: @@[ResultCategory[Ran], Run.type], currentSelector: Aux[Running, T, scopt.OParser[Input, Instance]], hierarchySelector: Aux[Running, T, Hierarchy], hierarchyTraversable: Aux[Hierarchy, Seq, scopt.OParser[_, Instance]], decidedSelector: Aux[Running, T, List[Queue[scopt.OParser[_, Instance]]]], argsSelector: Aux[Running, T, Category[Element]], initialSelector: Aux[Running, T, Instance], setupSelector: Aux[Running, T, scopt.OParserSetup], categoryToSeq: ~>[Category, Seq], optionToRan: ~>[Option, Ran]): @@[Aux[@@[Running, @@[Input, Instance]], Ran[Instance]], scopt.OParser.type]

implicit final val ValidationIdentityBiNaturalTransformation: ~~>[Validation, Validation]

implicit final val ValidationToDisjunctionBiNaturalTransformation: ~~>[Validation, \/]

implicit final val ValidationToEitherBiNaturalTransformation: ~~>[Validation, Either]

implicit final val VectorFoldable: Foldable[Vector]

implicit final val VectorMonadPlus: MonadPlus[Vector]

def ^[F[_], A, B, C](fa: ⇒ F[A], fb: ⇒ F[B])(f: (A, B) ⇒ C)(implicit F: Apply[F]): F[C]

def ^^[F[_], A, B, C, D](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C])(f: (A, B, C) ⇒ D)(implicit F: Apply[F]): F[D]

def ^^^[F[_], A, B, C, D, E](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D])(f: (A, B, C, D) ⇒ E)(implicit F: Apply[F]): F[E]

def ^^^^[F[_], A, B, C, D, E, I](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E])(f: (A, B, C, D, E) ⇒ I)(implicit F: Apply[F]): F[I]

def ^^^^^[F[_], A, B, C, D, E, I, J](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], fi: ⇒ F[I])(f: (A, B, C, D, E, I) ⇒ J)(implicit F: Apply[F]): F[J]

def ^^^^^^[F[_], A, B, C, D, E, I, J, K](fa: ⇒ F[A], fb: ⇒ F[B], fc: ⇒ F[C], fd: ⇒ F[D], fe: ⇒ F[E], fi: ⇒ F[I], fj: ⇒ F[J])(f: (A, B, C, D, E, I, J) ⇒ K)(implicit F: Apply[F]): F[K]

final def asInstanceOf[T0]: T0

def equals(arg0: Any): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit final def productTupleOps[Derived <: Product](derived: Derived)(implicit isTuple: IsTuple[Derived]): TupleOps[Derived]

scala.Productの子クラスへタプル操作を行うメソッドを追加します。

implicit final def recordOps[Derived <: HList](derived: Derived): RecordOps[Derived]

shapeless.HListの子クラスへレコード操作を行うメソッドを追加します。

def toString(): String