Fuzion Logo
flang.dev — The Fuzion Language Portal
JavaScript seems to be disabled. Functionality is limited.

marray.fz


# This file is part of the Fuzion language implementation.
#
# The Fuzion language implementation is free software: you can redistribute it
# and/or modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation, version 3 of the License.
#
# The Fuzion language implementation is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
# License for more details.
#
# You should have received a copy of the GNU General Public License along with The
# Fuzion language implementation.  If not, see <https://www.gnu.org/licenses/>.


# -----------------------------------------------------------------------
#
#  Tokiwa Software GmbH, Germany
#
#  Source code of Fuzion standard library feature marray
#
#  Author: Fridtjof Siebert (siebert@tokiwa.software)
#
# -----------------------------------------------------------------------

# marray -- one-dimensional mutable array
#
marray
  (
   # type of elements stored in this array
   redef T type,

   # length of the marray
   length i32,

   # contents of the marray
   private data fuzion.sys.array<T>,

   # just to distinguish constructor from marray<T>(i32, T)
   _ unit
   ) : Sequence<T>

  pre
    debug: length <= data.length

is

  indices => 0..length-1

  # get element at given index i
  #
  index [ ] (i i32) T
    pre
      safety: 0 <= i < length
  is
    data[i]

  # set element at given index i to given value o
  #
  set [ ] (i i32, o T) unit
    pre
      safety: 0 <= i < length
  # post   NYI: no '==' for Object yet
  #   marray.this[i] == o
  is
    data[i] := o


  # create a new marray by adding a new element o at the end of this marray
  #
  add (o T) marray<T>
    post
      debug: result.length = length + 1
      # debug: result[length] = o  -- there is no 'infix =' defined for T
  is
    d := if (data.length > length) data
      else
        newData := fuzion.sys.array<T> (8.max data.length*2)
        for i in indices do
          newData[i] := data[i]
        newData
    d[length] := o
    marray<T> length+1 d unit


  # infix operator synonyme for add
  #
  infix + (o T) => add o


  # create immutable array from this
  #
  as_array =>
    array<T> length (i -> marray.this[i])

  redef asStream => as_array.asStream


  # map the array to a new array applying function f to all elements
  #
  map<B>(f T -> B) array<B> is
    array<B> marray.this.length (i -> f marray.this[i])


  # fold the elements of this array using the given monoid.
  #
  # e.g., to sum the elements of an array of i32, use a.fold i32.sum
  #
  redef fold (m Monoid<T>) => fold 0 m.e m


  # fold the elements of this array using the given monoid and initial value
  #
  # Used to fold an array tail-recursively
  #
  fold (i i32, s T, m Monoid<T>) T
    pre
      debug: 0 <= i <= length
  is
    if i == length
      s
    else
      fold i+1 (m.op s marray.this[i]) m


# This feature provides a convenient constructor for marray<T>(length,
# fuzion.sys.array<T>, unit).
#
marray<T>
  (
   # length of the marray to crate
   length i32,

   # initial value for elements
   init T

  ) marray<T>

is
  data := fuzion.sys.array<T> length

  for x in 0..length-1 do
    data[x] := init

  marray length data unit