Trait Pattern

Source

pub trait Pattern {
    type Value;
    type Events: Iterator<Item = Event<Self::Value>>;

Show 22 methods    // Required method
    fn query(&self, span: Span) -> Self::Events;

    // Provided methods
    fn query_cycle(&self) -> Self::Events { ... }
    fn into_dyn(self) -> DynPattern<Self::Value>
       where Self: 'static + Sized { ... }
    fn map<T, F>(self, map: F) -> MapValues<Self, F>
       where Self: Sized,
             F: Fn(Self::Value) -> T { ... }
    fn map_query_points<F>(self, map: F) -> MapQueryPoints<Self, F>
       where Self: Sized,
             F: Fn(Rational) -> Rational { ... }
    fn map_event_points<F>(self, map: F) -> MapEventPoints<Self, F>
       where Self: Sized,
             F: Fn(Rational) -> Rational { ... }
    fn map_event_lens<F>(self, map: F) -> impl Pattern<Value = Self::Value>
       where Self: Sized,
             F: Fn(Rational) -> Rational { ... }
    fn map_events<F, T>(self, map: F) -> MapEvents<Self, F>
       where Self: Sized,
             F: Fn(Event<Self::Value>) -> Event<T> { ... }
    fn map_events_iter<E, F, T>(self, map: F) -> MapEventsIter<Self, F>
       where Self: Sized,
             F: Fn(Self::Events) -> E,
             E: Iterator<Item = Event<T>> { ... }
    fn rate(self, rate: Rational) -> Rate<Self>
       where Self: Sized { ... }
    fn shift(self, amount: Rational) -> impl Pattern<Value = Self::Value>
       where Self: 'static + Sized { ... }
    fn apply_with<P, F, B>(self, apply: P) -> impl Pattern<Value = B>
       where Self: 'static + Sized,
             Self::Value: Clone,
             P: 'static + Pattern<Value = F>,
             F: Fn(ApplyEvent<Self::Value>) -> (B, Option<Span>) { ... }
    fn apply<P, F, G, B>(
        self,
        apply: P,
        structure: G,
    ) -> impl Pattern<Value = B>
       where Self: 'static + Sized,
             Self::Value: Clone,
             P: 'static + Pattern<Value = F>,
             F: Fn(Self::Value) -> B,
             G: 'static + Fn(Span, Span) -> Span { ... }
    fn app<P, F, B>(self, apply: P) -> impl Pattern<Value = B>
       where Self: 'static + Sized,
             Self::Value: Clone,
             P: 'static + Pattern<Value = F>,
             F: Fn(Self::Value) -> B { ... }
    fn appl<P, F, B>(self, apply: P) -> impl Pattern<Value = B>
       where Self: 'static + Sized,
             Self::Value: Clone,
             P: 'static + Pattern<Value = F>,
             F: Fn(Self::Value) -> B { ... }
    fn appr<P, F, B>(self, apply: P) -> impl Pattern<Value = B>
       where Self: 'static + Sized,
             Self::Value: Clone,
             P: 'static + Pattern<Value = F>,
             F: Fn(Self::Value) -> B { ... }
    fn merge_with<P, F, T>(self, other: P, merge: F) -> impl Pattern<Value = T>
       where Self: 'static + Sized,
             Self::Value: Clone,
             P: 'static + Pattern,
             P::Value: Clone,
             F: 'static + Fn(Self::Value, P::Value) -> T { ... }
    fn merge_extend<P>(self, other: P) -> impl Pattern<Value = Self::Value>
       where Self: 'static + Sized,
             Self::Value: Clone + Extend<<P::Value as IntoIterator>::Item>,
             P: 'static + Pattern,
             P::Value: Clone + IntoIterator { ... }
    fn polar(self) -> impl Pattern<Value = Self::Value>
       where Self: Sized,
             Self::Value: Polar { ... }
    fn phase(self) -> impl Pattern<Value = [Rational; 2]>
       where Self: Sized { ... }
    fn debug_span(
        &self,
        span: Span,
    ) -> PatternDebug<'_, Self::Value, Self::Events>
       where Self: Sized { ... }
    fn debug(&self) -> PatternDebug<'_, Self::Value, Self::Events>
       where Self: Sized { ... }
}

Expand description

A composable abstraction for 1-dimensional patterns.

A Pattern is any type that may be queried with a Span to produce a sequence of Event<Self::Value>s.

Required Associated Types§

Source

type Value

The type of the values emitted in the pattern’s events.

Source

type Events: Iterator<Item = Event<Self::Value>>

An iterator yielding the events occuring within a query’s span.

Required Methods§

Source

fn query(&self, span: Span) -> Self::Events

Query the pattern for events within the given span.

§Example

use cycles::{atom, saw, span, Pattern, Rational};

let pattern = atom("hello");
let mut events = pattern.query(span!(0/1, 1/1));
assert_eq!(events.next().unwrap().value, "hello");
assert_eq!(events.next(), None);

let pattern = saw();
assert_eq!(pattern.query(span!(0/1)).next().unwrap().value, (0, 1).into());
assert_eq!(pattern.query(span!(1/2)).next().unwrap().value, (1, 2).into());

Provided Methods§

Source

fn query_cycle(&self) -> Self::Events

Query the pattern for events within a single cycle, (i.e. span!(0/1, 1/1)).

Source

fn into_dyn(self) -> DynPattern<Self::Value>
where Self: 'static + Sized,

Convert the pattern to a trait object behind an Arc and dynamically box queries in order to represent the pattern with a known, sized type.

This is useful for storing multiple patterns within a single collection, or passing patterns between threads, etc.

Source

fn map<T, F>(self, map: F) -> MapValues<Self, F>
where Self: Sized, F: Fn(Self::Value) -> T,

Map the values produced by pattern queries with the given function.

Source

fn map_query_points<F>(self, map: F) -> MapQueryPoints<Self, F>
where Self: Sized, F: Fn(Rational) -> Rational,

Map the start and end points of the pattern’s query spans.

Source

fn map_event_points<F>(self, map: F) -> MapEventPoints<Self, F>
where Self: Sized, F: Fn(Rational) -> Rational,

Map the active and whole span start and end points of events produced by pattern queries with the given function. Useful for mapping time.

Source

fn map_event_lens<F>(self, map: F) -> impl Pattern<Value = Self::Value>
where Self: Sized, F: Fn(Rational) -> Rational,

Map the length of the active and whole spans of all events produced by self.

The end of the resulting whole span is adjusted to achieve the returned len.

Source

fn map_events<F, T>(self, map: F) -> MapEvents<Self, F>
where Self: Sized, F: Fn(Event<Self::Value>) -> Event<T>,

Map the events produced by pattern queries with the given function.

Source

fn map_events_iter<E, F, T>(self, map: F) -> MapEventsIter<Self, F>
where Self: Sized, F: Fn(Self::Events) -> E, E: Iterator<Item = Event<T>>,

Map the events iterator produced by the pattern queries with the given function.

Source

fn rate(self, rate: Rational) -> Rate<Self>
where Self: Sized,

Increase or decrease the rate of event emission by the given value.

Source