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

searchableList.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 searchableList
#
#  Author: Fridtjof Siebert (siebert@tokiwa.software)
#
# -----------------------------------------------------------------------

# searchableList -- a list whose elements inherit from hasEquals
#
# In contrast to searchablelist, this uses ref type 'list' and not choice
# type 'list', so it is more flexible.
#
#
searchableList<A: hasEquals<A>>(from Sequence<A>) : Sequence<A>
is

  # create a list from this Sequence.
  #
  redef asList => from.asList


  # does this list start with l?
  #
  startsWith (l Sequence<A>) =>
    (searchablelist asList).startsWith l.asList


  # 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.
  #
  indexOf (x A) => find [x]

  # get the index of l within this list or nil if it does not exist
  #
  find (l Sequence<A>) =>
    (searchablelist asList).find l.asList


  # replace all occurances of f by r
  #
  replace (f, r Sequence<A>) =>
    (searchablelist asList).replace f.asList r.asList


  # get the number of matches of l
  #
  countMatchesOverlapping (l Sequence<A>) =>
    (searchablelist asList).countMatchesOverlapping l.asList


  # get the number of non-overlapping matches of l within this
  #
  countMatches (l Sequence<A>) =>
    (searchablelist asList).countMatches l.asList