☰
outcome
outcome
Type Parameters
Functions
returns o if outcome is ok, otherwise return the outcome's own
error.
collect the contents of this Sequence into an array
create an array backed version of this sequence in case this is not array
backed. This will ensure that operations like index[] or drop perform
in constant time.
returns Sequence.this if is_array_backed.
converts switch into a list of either a single element in case
switch.this.exists or `nil`otherwise
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Type Parameters
Functions
returns o if outcome is ok, otherwise return the outcome's own
error.
collect the contents of this Sequence into an array
create an array backed version of this sequence in case this is not array
backed. This will ensure that operations like index[] or drop perform
in constant time.
returns Sequence.this if is_array_backed.
converts switch into a list of either a single element in case
switch.this.exists or `nil`otherwise
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Functions
returns o if outcome is ok, otherwise return the outcome's own
error.
collect the contents of this Sequence into an array
create an array backed version of this sequence in case this is not array
backed. This will ensure that operations like index[] or drop perform
in constant time.
returns Sequence.this if is_array_backed.
converts switch into a list of either a single element in case
switch.this.exists or `nil`otherwise
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
returns o if outcome is ok, otherwise return the outcome's own
error.
error.
collect the contents of this Sequence into an array
create an array backed version of this sequence in case this is not array
backed. This will ensure that operations like index[] or drop perform
in constant time.
returns Sequence.this if is_array_backed.
converts switch into a list of either a single element in case
switch.this.exists or `nil`otherwise
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
collect the contents of this Sequence into an array
create an array backed version of this sequence in case this is not array
backed. This will ensure that operations like index[] or drop perform
in constant time.
returns Sequence.this if is_array_backed.
converts switch into a list of either a single element in case
switch.this.exists or `nil`otherwise
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create an array backed version of this sequence in case this is not array
backed. This will ensure that operations like index[] or drop perform
in constant time.
returns Sequence.this if is_array_backed.
backed. This will ensure that operations like index[] or drop perform
in constant time.
returns Sequence.this if is_array_backed.
converts switch into a list of either a single element in case
switch.this.exists or `nil`otherwise
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
converts switch into a list of either a single element in case
switch.this.exists or `nil`otherwise
switch.this.exists or `nil`otherwise
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
convert this switch to an option
convert this to an outcome
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
convert this to an outcome
this is essentially a no-op.
this is essentially a no-op.
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
convert this switch to an outcome
convenience feature to work around type inference issues
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
convenience feature to work around type inference issues
NYI remove when type inference gets better
NYI remove when type inference gets better
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a string representation of this Sequence including all the string
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
representations of its contents, separated by 'sep'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a string representation of this Sequence including all the string
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
representations of its contents, separated by ", " and enclosed in '['
and ']'.
NOTE: In case this Sequence is not finite, this will attempt to create an
infinitely long string resulting in failure due to resource exchaustion.
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
call 'as_string' on the elements
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
the arithmetic mean of the sequence
https://en.wikipedia.org/wiki/Arithmetic_mean
https://en.wikipedia.org/wiki/Arithmetic_mean
create a new list that contains the first elements of
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a new list that contains the first elements of
this Sequence for which 'f e' is false
this Sequence for which 'f e' is false
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
chop this Sequence into chunks of `chunk_size`.
the last chunk may be smaller than `chunk_size`.
the last chunk may be smaller than `chunk_size`.
§create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
§
create a new Sequence from the result of applying 'f' to the
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
elements all combinations of elements of this Sequence and
all elements of 'b' iterating of 'b' repeatedly as follows
Sequence.this[0] , b[0]
Sequence.this[0] , b[1]
Sequence.this[0] , b[2]
Sequence.this[0] , ...
Sequence.this[0] , b.last
Sequence.this[1] , b[0]
Sequence.this[1] , b[1]
Sequence.this[1] , ...
... , ...
Sequence.this.last, b.last
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a Sequence that consists of all the elements of this Sequence followed
by all the elements of s
by all the elements of s
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
does the Sequence contain element x?
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
count the number of elements in this Sequence. Note that this typically
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
runs forever if executed on an endless list
For lists that are not array backed, this might require time in O(count).
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get the number of non-overlapping matches of l within this
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get the number of matches of l
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a list that repeats the current Sequence indefinitely. In case 'Sequence.this'
is empty, returns 'nil'
is empty, returns 'nil'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a list that consists of the elements of this Sequence except the first
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
n elements
NOTE: this may have performance in O(n) unless it is backed by an immutable array.
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Lazily drop the first elements of this Sequence for which predicate 'p' holds.
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierarchy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
the euclidean norm of this sequence
i.e. the square of the sum of squares of this sequence
i.e. the square of the sum of squares of this sequence
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Does this switch contain a value of type A?
filter elements using predicate f
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
filter elements using predicate f
values for which f is false are dropped
values for which f is false are dropped
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get the index of pattern within this Sequence or nil if it does not exist
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
uses the Knuth-Morris-Pratt algorithm
port of racket code from this paper:
https://www.cambridge.org/core/services/aop-cambridge-core/content/view/8EFA77D663D585B68630E372BCE1EBA4/S0956796824000017a.pdf/knuth-morris-pratt-illustrated.pdf
worst-case performance: O( seq_length ) + O( pattern_length )
worst-case space complexity: O( pattern_length )
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
is this sequence known to be finite? For infinite sequences, features like
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
count diverge.
TRUE = known finite
FALSE = known infinite
nil = unknown
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get the first element of this Sequence
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get the first element of this Sequence or default if sequence is empty
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
map each element of this Sequence to Sequence
Then flatten the result by one level,
essentially combining all the sequences.
Then flatten the result by one level,
essentially combining all the sequences.
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
fold the elements of this Sequence using the given monoid.
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
e.g., to sum the elements of a Sequence of i32, use s.fold i32.sum
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
fold the elements of this non-empty Sequence using the given function
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
e.g., to find the minimum of a Sequence of i32, use `s.fold1 (<=)`
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
fold the elements of this Sequence using the given function and initial
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
value.
In case this Sequence is empty, the result is `e`.
e.g., to find the product of a Sequence of i32, use `s.foldf (*) 1`
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a list and call 'for_each f' on it
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
apply 'f' to each element 'e' as long as 'f e'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
unwraps a switch that is known to contain a value
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
this can only be called in cases where it is known for sure that this switch
is not nil. A runtime error will be created otherwise.
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
unwrap value or get default
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get a function that, given an index, returns the element at that index
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
the nth element in the sequence, must exist
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
determine the index of element x within this list. 0 if x is at the
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
head of the list, 1 if it comes directly after head, etc. nil if x is
not in the list.
adds the corresponding index to
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
adds the corresponding index to
every element in the sequence
every element in the sequence
adds an index to every element
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
adds an index to every element
in the sequence starting at start_idx
in the sequence starting at start_idx
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
consume all elements of this Sequence by f. This is an infix operator alias
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
for for_each.
Ex.: To print all the elements of a list, you can use
1..10 ! say
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
filter elements using predicate f, infix operator
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
synonym of filter.
NYI: What is better, 'infix |&' or 'infix &', or something else?
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
infix operand synonym for concat_sequences
§monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
§
monadic operator
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
map the Sequence to a new Sequence applying function f to all elements
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
This is an infix operator alias of map enabling piping code like
l := 1..10 | *10 | 300-
to obtain 290,280,270,...200
Note that map and therefore also this operator is lazy, so
_ := (1..10 | say)
will not print anything while
(1..10 | say).for_each _->unit
will print the elements since `for_each` is not lazy.
filter elements using predicate f, infix operator
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
filter elements using predicate f, infix operator
synonym of filter.
synonym of filter.
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
check if predicate f holds for all elements
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
check if predicate f holds for at least one element
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
insert element v at position at
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
apply transducer to sequence, returning a sequence of results
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
example usage:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
is this Sequence known to be array backed? If so, this means that operations
like index[] are fast.
like index[] are fast.
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
is this Sequence empty?
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Does this outcome contain an error
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
check if argument is a valid index in this sequence.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
Note that this may have a performance in O(i) unless this
Sequence is_array_backed.
§(MMA type :monad monad.MA (monad monad.A monad.MA), a MMA) => monad.MA [Inherited from monad] [Abstract feature]join operator
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
§
(MMA
type
:monad monad.MA (monad monad.A monad.MA), a MMA) =>
monad.MA [Inherited from monad]
[Abstract feature]
join operator
NYI: useless since redefinition currently not supported for
feature with generics.
NYI: useless since redefinition currently not supported for
feature with generics.
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get the last element of this Sequence
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
This may take time in O(count), in particular, it may not terminate
for an infinite Sequence.
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
get the last element of this Sequence or default if sequence is empty
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
map the Sequence to a new Sequence applying function f to all elements
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
This performs a lazy mapping, f is called only when the elements
in the resulting list are accessed.
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Map this Sequence to f applied to neighboring pairs of values
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
in this Sequence.
In case this Sequence has less than two elements, the result will
be the empty list.
ex. to obtain a list of differences you, you may use `map_pairs (-)`:
[2,3,5,7,11,13,17,19,23,29].map_pairs a,b->b-a
results in `[1,2,2,4,2,4,2,4,6]`
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
maximum value in the sequence
the median of the sequence
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
the median of the sequence
https://en.wikipedia.org/wiki/Median
https://en.wikipedia.org/wiki/Median
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
minimum value in the sequence
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
the nth element in the sequence if it exists, wrapped in an option,
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
nil otherwise.
Complexity: if Sequence is array backed O(1) otherwise O(n)
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
Does this switch contain a value of type A?
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
returns o if outcome is not ok, otherwise return this outcome's value.
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
create a new Sequence from tuples of all combinations of elements
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
of this Sequence and all elements of 'b' iterating of 'b' repeatedly
as follows
(Sequence.this[0] , b[0] )
(Sequence.this[0] , b[1] )
(Sequence.this[0] , b[2] )
(Sequence.this[0] , ... )
(Sequence.this[0] , b.last)
(Sequence.this[1] , b[0] )
(Sequence.this[1] , b[1] )
(Sequence.this[1] , ... )
(... , ... )
(Sequence.this.last, b.last)
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
calls `f` for element in the Sequence.
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
Unlike `for_each` this returns itself
allowing easier composition with
other Sequence features.
example:
[1,2,3,4,5]
.filter is_prime
.peek say
.drop_while <10
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
short-hand postfix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
short-hand postfix operator for 'exists'
short-hand prefix operator for '!exists'
short-hand prefix operator for '!exists'
outcome is a choice type that represents the result of a routine that
may either produce something useful or fail producing an error condition.
Several error conditions are needed if there are several very different
reasons for an operation to fail, e.g.
get_data (u User, t Type) outcome data IO_Error Permission_Error is
read_file t Type outcome data IO_Error is
Note that 'outcome data IO_Error' is not assignment compatible with
'outcome data IO_Error Permission_Error', it has to be unwrapped first.
This unwrapping, however, requires very little boilerplate, it is done
using the '?' on the result of the call to 'read_file': This unwraps
'outcome data IO_Error' into 'IO_Error', which would be returned abruptly,
and 'data', which would be returned normally. Both are assignment
compatible to 'outcome data IO_Error Permission_Error', so everything
is fine.