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

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

# Function -- generic function with arbitrary number of arguments and result
#
Function(R type, A type...) ref is

  # call this function on given arguments A...
  #
  call(a A) R is abstract


# NYI: function composition: This needs a solution for either restricing A...
# to a single argument or for converting a tuple result into A...
#
#  # compose f: B -> A with this: A -> R into this ∘ f: B -> R
#  compose<B>(f fun (B) A) => fun(B b) R => call f b
#
#  # compose f: B -> A with this: A -> R into this ∘ f: B -> R
#  compose<B>(f fun (B) tuple<A>) => fun(B b) R => call f b /* destructure result automatically? */
#
#  # short-hand infix operation for composition
#  infix ∘ (f fun (B) A) => compose f


# NYI: would be nice to have schönfinkeling defined here, could work like this:
#
#  curry(x A.0) Function(R, A.1...) is
#    curried Function(R, A1...) is
#      call(a A1...) is Function.this.call x a...
#    curried
#
# --or, with different syntax sugar--
#
#  curry(x A.0) R->A.1... is x,a... -> call x a...
#
# where A.1... is the tail of type argument A (might be empty), and A.0 is the first element,
# void (or unit?) if it does not exist.


# Functions -- unit type containing features related to functions but not requiring an instance
#
Functions is

  # compose g ∘ f
  #
  compose(A,B,C type,
          g B -> C,
          f A -> B) A -> C
  is
    a -> g (f a)