Time represents points in time space. The difference between two time points is a Duration, for example in a bar of duration 4/4 (that is 1), the difference between the first and third beat 1/2.

Time has an origin (zero) which usually represents the beginning of the musical performance, but this may not always be the case, as the modelled music may be infinite, or contain a musical pickup. Hence Time values can be negative.

Duration, corresponding to note values in standard notation. The standard names can be used: 1/2 for half note 1/4 for a quarter note and so on.

Interpret as durations from 0.

toAbsoluteTime (toRelativeTime xs) == xs

lenght xs == length (toRelativeTime xs)

>>> toAbsoluteTime [1,1,1] :: [Time]
[1,2,3]

Duration between 0 and first value and so on until the last.

toAbsoluteTime (toRelativeTime xs) == xs

lenght xs == length (toRelativeTime xs)

>>> toRelativeTime [1,2,3]
[1,1,1]

Duration between values until the last, then up to the given final value. > lenght xs == length (toRelativeTime xs)

A Span represents a specific time interval.

Another way of looking at Span is that it represents a time transformation where onset is translation and duration is scaling.

This type is known as Arc in Tidal and as Era in the active package.

t <-> u represents the span between t and u.

t >-> d represents the span between t and t .+^ d.

d <-> t represents the span between t .-^ d and t.

View a span as a pair of onset and duration.

View a span as pair of onset and offset.

View a span as a pair of duration and offset.

View a span as pair of onset and offset.

View a span as a pair of onset and duration.

View a span as a pair of duration and offset.

Access the stretch component in a span.

Access the delay component in a span.

A prism to the subset of Span that performs a delay but no stretch.

A prism to the subset of Span that performs a stretch but no delay.

Normalize a span, i.e. reverse it if negative, and do nothing otherwise.

abs $ s^.duration = abs $ (normalizeSpan s)^.duration
s^.midpoint = (normalizeSpan s)^.midpoint

Reflect a span through its midpoint.

Reflect a span through an arbitrary point.

Whether the given span is empty, i.e. whether its onset and offset are equivalent.

Whether the given span has a positive duration, i.e. whether its onset is before its offset.

Whether the given span has a negative duration, i.e. whether its offset is before its onset.

Whether the given point falls inside the given span (inclusively).

Designed to be used infix, for example

>>> 0.5 `inside` 1 <-> 2
False

>>> 1.5 `inside` 1 <-> 2
True

>>> 1 `inside` 1 <-> 2
True

Whether the first given span encloses the second span.

>>> 0 <-> 3 `encloses` 1 <-> 2
True

>>> 0 <-> 2 `encloses` 1 <-> 2
True

>>> 1 <-> 3 `encloses` 1 <-> 2
True

>>> 1 <-> 2 `encloses` 1 <-> 2
True

Whether the first given span encloses the second span.

>>> 0 <-> 3 `properlyEncloses` 1 <-> 2
True

>>> 0 <-> 2 `properlyEncloses` 1 <-> 2
True

>>> 1 <-> 3 `properlyEncloses` 1 <-> 2
True

>>> 1 <-> 2 `properlyEncloses` 1 <-> 2
False

Whether the given span overlaps.

Whether the first given span occurs before the second span.

Show a span in range notation, i.e. t1 <-> t2.

Show a span in delta notation, i.e. t >-> d.

Show a span in codelta notation, i.e. t <-< d.