crow/col/collection.crow (source)

index-too-big record exception variant-member

show string(anonymous index-too-big)

iterator-out-of-bounds record exception variant-member

    Exception when attempting to skip too far forward or backward

    show string(anonymous iterator-out-of-bounds)

    slice-right-to-left record exception variant-member

      For a 'slice', the first iterator should be to the right of the second iterator.

      show string(anonymous slice-right-to-left)

      iterator-not-comparable record exception variant-member

        Some iterator operations like 'slice' require two iterators to be for the same collection.

        show string(anonymous iterator-not-comparable)

        is-empty[t] spec

        size[t] spec

        iterate[col, elem] spec

        begin[iter, col] spec

        • begin iter(a col)

        end[iter, col] spec

        • end iter(a col)

        begin-end[iter, col] spec (iter, col) begin, (iter, col) end

          collection[col, iter] spec

          • collection col(a iter)

          prev-next[elem, iter] spec (elem, iter) prev, (elem, iter) next

            set-prev[iter, elem] spec

            set-next[iter, elem] spec

            set-prev-next[iter, elem] spec (iter, elem) set-prev, (iter, elem) set-next

              slice[col, iter] spec

              • slice col(begin iter, end iter)

              slice-out-of-order record exception variant-member

                show string(anonymous slice-out-of-order)

                skip-prev[iter] spec

                skip-next[iter] spec

                skip-prev-next[iter] spec iter skip-prev, iter skip-next

                  index-relative-to-end record

                  Represents an index relative to the size of a collection

                  end index-relative-to-end() bare

                  - index-relative-to-end(a index-relative-to-end, n nat64) bare

                  at-index[col, elem] spec

                  set-at-index[col, elem] spec

                  subscript[col, elem] elem(a col, index index-relative-to-end) bare, (col, elem) at-index, col size

                  set-subscript[col, elem] void(a col, index index-relative-to-end, value elem) bare, (col, elem) set-at-index, col size

                  fill[col, iter, elem] void(a col, value elem) bare, (iter, col) begin, (elem, iter) next, (iter, elem) set-next

                  map=[col, iter, elem] void(a col, f mut elem(elem)) (iter, col) begin, (elem, iter) next, (iter, elem) set-next

                  range-relative-to-end record

                  .. range-relative-to-end(low nat64, high index-relative-to-end) bare

                  to-range nat64 range(a range-relative-to-end, size nat64) bare

                  subscript-range[col] spec

                  subscript[col] col(a col, indices range-relative-to-end) bare, col size, col subscript-range

                  slice-left[col, iter] col(a iter) (col, iter) collection, (iter, col) begin, (col, iter) slice

                  slice-right[col, iter] col(a iter) (col, iter) collection, (iter, col) end, (col, iter) slice

                  set-reverse[col, iter, elem] void(a col) (iter, col) begin-end, (elem, iter) prev-next, iter subtract-to-nat, (iter, elem) set-prev-next

                  swap-at[col, elem] void(a col, i nat64, j nat64) (col, elem) at-index, (col, elem) set-at-index

                  swap-at[col, elem] void(a col, i nat64, j index-relative-to-end) col size, (col, elem) at-index, (col, elem) set-at-index

                  swap-at[col, elem] void(a col, i index-relative-to-end, j index-relative-to-end) col size, (col, elem) at-index, (col, elem) set-at-index

                  reverse-in-place[col, elem] void(a col) col size, (col, elem) at-index, (col, elem) set-at-index

                  for-loop[col, elem] void(a col, f mut void(elem)) (col, elem) iterate

                  Call 'f' for each element in the collection and return nothing.

                  for-loop[out-col, out-elem, out-builder, in-col, in-elem] out-col(in in-col, f mut out-elem(in-elem)) (out-col, out-elem, out-builder) build, (in-col, in-elem) iterate, in-col size

                  and return an output collection of the results of 'f'.

                  for-break[out, col, elem] out(a col, f-loop mut out break-or-continue(elem), f-else mut out(void)) (col, elem) iterate

                  Call f for each element in the collection, but stop and return the result of the first break.
                  If there is no break, return f-else instead.

                  for-break[col, elem] void(a col, f-loop mut void break-or-continue(elem)) (col, elem) iterate

                  for-break[out, col, elem] out?(a col, f-loop mut out break-or-continue(elem)) (col, elem) iterate

                  Call f for each element in the collection, but stop and return the result of the first break.
                  If there is no break, return an empty option instead.

                  filter[out-col, elem, out-builder, in-col] out-col(in in-col, f mut bool(elem)) (out-col, elem, out-builder) build, (in-col, elem) iterate

                  Call f for each element in the input collection,
                  and return an output collection of the elements for which f was true.

                  reduce[col, elem] elem?(a col, f mut elem((elem, elem) tuple2)) (col, elem) iterate

                  contains[col, elem] bool(a col, value elem) (col, elem) iterate, elem equal

                  True if value is an element of a.
                  For sets, prefer in.

                  starts-with[col, iter, elem] bool(a col, b col) (iter, col) begin, (elem, iter) next, elem equal

                  ends-with[col, iter, elem] bool(a col, b col) (iter, col) end, (elem, iter) prev, elem equal

                  try-remove-start[col, iter, elem] col?(a col, start col) (iter, col) begin-end, (elem, iter) next, (col, iter) slice, elem equal

                  try-remove-end[col, iter, elem] col?(a col, end col) (iter, col) begin-end, (elem, iter) prev, (col, iter) slice, elem equal

                  strip-left[col, iter, elem] col(a col, b col) (iter, col) begin-end, (elem, iter) next, (col, iter) slice, elem equal

                  Removes all occurrences of 'b' from the front of 'a'.

                  strip-right[col, iter, elem] col(a col, b col) (iter, col) begin-end, (elem, iter) prev, (col, iter) slice, elem equal

                  Removes all occurrences of 'b' from the end of 'a'.

                  contains-seq[col, iter, elem] bool(a col, b col) (iter, col) begin, (elem, iter) next, elem equal

                  true iff b is contained in a.

                  That means: The elements in b appear in a, in order, without interruptions.

                  try-split-once[col, iter, elem] (col, col) tuple2?(a col, b col) (iter, col) begin-end, (elem, iter) next, (col, iter) slice, elem equal

                  Finds the first appearance of b in a,
                  and returns slices of a to the left and right of that.

                  Returns an empty option iff b is not a subsequence of a.

                  try-split-once-right[col, iter, elem] (col, col) tuple2?(a col, b col) (iter, col) begin-end, (elem, iter) prev, (col, iter) slice, elem equal

                  find[col, elem] elem?(a col, f mut bool(elem)) (col, elem) iterate

                  Returns the first element for which f returns true,
                  or an empty option if f was always false.

                  find-index[col, elem] nat64?(a col, f mut bool(elem)) (col, elem) iterate

                  Returns the first index i for which f[a[i]] is true.
                  Returns an empty option iff f returns false for every elem of a.

                  find-last-iter[col, iter, elem] iter?(a col, f mut bool(elem)) (iter, col) end, (elem, iter) prev

                  last-iter-of[col, iter, elem] iter?(a col, value elem) (iter, col) end, (elem, iter) prev, elem equal

                  index-of[col, elem] nat64?(a col, search-value elem) (col, elem) iterate, elem equal

                  If search-value is in a, return its index.

                  exists[col, elem] bool(a col, f mut bool(elem)) (col, elem) iterate

                  Equivalent to f[a[0]] || f[a[1]] || ... || f[a[end - 1]]

                  Calls f on each element of a and returns true the first time f does.
                  Returns false iff f returned false every time.

                  every[col, elem] bool(a col, f mut bool(elem)) (col, elem) iterate

                  Equivalent to f[a[0]] && f[a[1]] && ... && f[a[end - 1]].

                  Calls f on each element of a and returns false the fist time f does.
                  Returns true iff f returned true every time.

                  drop-while[col, iter, elem] col(a col, f mut bool(elem)) (iter, col) begin-end, (elem, iter) next, (col, iter) slice

                  Drops elements from the left until f returns false.
                  If f always returns true, this returns an empty collection.

                  drop-right-while[col, iter, elem] col(a col, f mut bool(elem)) (iter, col) begin-end, (elem, iter) prev, (col, iter) slice

                  Drops elements from the right that match f.

                  take-while[col, iter, elem] col(a col, f mut bool(elem)) (iter, col) begin, (elem, iter) next, (col, iter) slice

                  take-right-while[col, iter, elem] col(a col, f mut bool(elem)) (iter, col) end, (elem, iter) prev, (col, iter) slice

                  concatenate[t] spec

                  • ~~ t(a t, b t)

                  flatten[col, col-col] col(a col-col) (col-col, col) iterate, col concatenate, col new

                  repeat[col] col(a col, n nat64) col concatenate, col new

                  Concatenate n copies of a.

                  n-of[col, elem, builder] col(n nat64, value elem) (col, elem, builder) build

                  reverse[col, iter, elem, builder] col(a col) col size, (col, elem, builder) build, (iter, col) end, (elem, iter) prev

                  reversed[col] record nominal

                  • inner col

                  size[col] nat64(a col reversed) col size

                  for-loop[col, iter, elem] void(a col reversed, f mut void(elem)) (iter, col) end, (elem, iter) prev

                  for-loop[out-col, out-elem, out-builder, in-col, in-iter, in-elem] out-col(a in-col reversed, f mut out-elem(in-elem)) (out-col, out-elem, out-builder) build, (in-iter, in-col) end, (in-elem, in-iter) prev, in-col size

                  indices[col] nat64 range(a col) col size

                  with-index[col] record

                  (has non-public fields)

                    with-index[col] col with-index(a col)

                    for-loop[col, elem] void(a col with-index, f mut void((nat64, elem) tuple2)) (col, elem) iterate

                    for-loop[out-col, out-elem, out-builder, in-col, in-elem] out-col(a in-col with-index, f mut out-elem((nat64, in-elem) tuple2)) (out-col, out-elem, out-builder) build, (in-col, in-elem) iterate, in-col size

                    for-break[col, elem] void(a col with-index, f mut void break-or-continue((nat64, elem) tuple2)) (col, elem) iterate

                    exists[col, elem] bool(a col with-index, f mut bool((nat64, elem) tuple2)) (col, elem) iterate

                    corresponds[col0, iter0, elem0, col1, iter1, elem1] bool(a col0, b col1, f mut bool((elem0, elem1) tuple2)) col0 size, (iter0, col0) begin, (elem0, iter0) next, col1 size, (iter1, col1) begin, (elem1, iter1) next

                    builder[col, builder] spec

                    build[col, elem, builder] spec (col, builder) builder

                    • ~= void(a builder, value elem)

                    build-options record

                    build build-options()

                    build build-options(size-hint nat64)

                    with-block[col, builder] col(a build-options, f mut void(builder)) (col, builder) builder