Struct scalp::Builder

pub struct Builder<S, P = At<()>> { /* private fields */ }

Implementations

impl<S, P> Builder<S, P>

pub fn pipe<Q>(self, pipe: impl FnOnce(Self) -> Builder<S, Q>) -> Builder<S, Q>

impl<S, P> Builder<S, P>

pub fn map<T, F: Fn(P::Value) -> T>( self, map: F ) -> Builder<S, Map<P, impl Fn(P::Value) -> Result<T, Error>>>

where P: Parse,

pub fn try_map<T, F: Fn(P::Value) -> Result<T, Error>>( self, map: F ) -> Builder<S, Map<P, F>>

where P: Parse,

pub fn filter( self, filter: impl Fn(&P::Value) -> bool ) -> Builder<S, Map<P, impl Fn(P::Value) -> Result<Option<P::Value>, Error>>>

where P: Parse,

pub fn filter_or( self, error: impl Into<Error>, filter: impl Fn(&P::Value) -> bool ) -> Builder<S, Map<P, impl Fn(P::Value) -> Result<P::Value, Error>>>

where P: Parse,

pub fn or<T>( self, error: impl Into<Error> ) -> Builder<S, Map<P, impl Fn(P::Value) -> Result<T, Error>>>

where P: Parse<Value = Option<T>>,

pub fn boxed( self ) -> Builder<S, Box<dyn Parse<Value = P::Value, State = P::State>>>

where P: Parse + 'static,

pub fn any<T>( self ) -> Builder<S, Map<P, impl Fn(P::Value) -> Result<Option<T>, Error>>>

where P: Parse, P::Value: Any<T>,

pub fn any_or<T>( self, error: impl Into<Error> ) -> Builder<S, Map<P, impl Fn(P::Value) -> Result<T, Error>>>

where P: Parse, P::Value: Any<T>,

impl<S: Scope, P> Builder<S, P>

pub fn help(self, help: impl Into<Cow<'static, str>>) -> Self

pub fn note(self, note: impl Into<Cow<'static, str>>) -> Self

pub fn hide(self) -> Self

pub fn show(self) -> Self

impl<S: Node, P> Builder<S, P>

pub fn usage(self, usage: impl Into<Cow<'static, str>>) -> Self

pub fn group<Q>( self, build: impl FnOnce(Builder<Group, At>) -> Builder<Group, Q> ) -> Builder<S, P::Push<Q>>

where P: Stack,

pub fn verb<Q>( self, build: impl FnOnce(Builder<Verb, At>) -> Builder<Verb, Q> ) -> Builder<S, P::Push<Node<Q>>>

where P: Stack,

pub fn option<T: FromStr + 'static, Q>( self, build: impl FnOnce(Builder<Option, Value<T>>) -> Builder<Option, Q> ) -> Builder<S, P::Push<With<Q>>>

where P: Stack,

pub fn options(self, options: impl IntoIterator<Item = Options>) -> Self

impl<S: Version, P> Builder<S, P>

pub fn version(self, version: impl Into<Cow<'static, str>>) -> Self

impl Builder<Root>

pub fn new() -> Self

pub fn case(self, case: Case) -> Self

pub fn prefix( self, short: impl Into<Cow<'static, str>>, long: impl Into<Cow<'static, str>> ) -> Self

impl<P> Builder<Root, P>

pub fn build(self) -> Result<Parser<Node<P>>, Error>

where P: Parse,

pub fn name(self, name: impl Into<Cow<'static, str>>) -> Self

pub fn license( self, name: impl Into<Cow<'static, str>>, file: impl Into<Cow<'static, str>> ) -> Self

pub fn author(self, author: impl Into<Cow<'static, str>>) -> Self

impl<P> Builder<Group, P>

pub fn name(self, name: impl Into<Cow<'static, str>>) -> Self

impl<P> Builder<Verb, P>

pub fn name(self, name: impl Into<Cow<'static, str>>) -> Self

impl Builder<Option, Value<Unit>>

pub fn parse<T: FromStr + 'static>(self) -> Builder<Option, Value<T>>

impl<P> Builder<Option, P>

pub fn name(self, name: impl Into<Cow<'static, str>>) -> Self

pub fn position(self) -> Self

pub fn swizzle(self) -> Self

where P: Parse, <P as Parse>::Value: Flag,

pub fn default<T: Clone + Debug>( self, default: impl Into<T> ) -> Builder<Option, Default<P, impl Fn() -> T>>

where P: Parse<Value = Option<T>>,

pub fn default_with<T, F: Fn() -> T>( self, default: F, format: impl Into<Cow<'static, str>> ) -> Builder<Option, Default<P, F>>

where P: Parse<Value = Option<T>>,

pub fn environment<T: FromStr>( self, variable: impl Into<Cow<'static, str>> ) -> Builder<Option, Environment<P, impl Fn(&str) -> Option<T>>>

where P: Parse<Value = Option<T>>,

pub fn environment_with<T, F: Fn(&str) -> Option<T>>( self, variable: impl Into<Cow<'static, str>>, parse: F ) -> Builder<Option, Environment<P, F>>

where P: Parse<Value = Option<T>>,

pub fn require(self) -> Builder<Option, Require<P>>

pub fn many<T, I: Default + Extend<T>>( self ) -> Builder<Option, Many<P, I, impl Fn() -> I, impl Fn(&mut I, T)>>

where P: Parse<Value = Option<T>>,

pub fn many_with<T, I, N: Fn() -> I, F: Fn(&mut I, T)>( self, per: Option<NonZeroUsize>, new: N, add: F ) -> Builder<Option, Many<P, I, N, F>>

where P: Parse<Value = Option<T>>,

pub fn valid(self, pattern: impl Into<Cow<'static, str>>) -> Self

Trait Implementations

impl Default for Builder<Root>

fn default() -> Self

Returns the “default value” for a type.