higher-order.qky

[ this ] is higher-order.qky

( ------ Higher Order Functions ------
  Copyright (C) 2022 Gordon Charlton
   https://github.com/GordonCharlton )

( Glossary:

  fold ( [ x --> x ):

  fold cumulatively applies the word or nest x to the items in a
  nest, taking the first item as the first partial result without 
  applying x to it. So

  ' [ 1 2 3 4 5 ] ' + fold

  is equivalent to

    1 2 + 3 + 4 + 5 +

  and returns 15

  If the nest is empty fold returns an empty nest.

  If the nest has one item, fold returns that item.

  x must consume two items and return one item.


  foldr ( [ x --> x ):

  Like fold, but applies x to the items of the nest in reverse
  order, from right to left.

  Incidentally, like map and filter, it is defined here in terms
  of fold, trivially as [ reverse fold ], but for the benefit of
  completists, reverse can be defined with fold as:

    [ ' [ [ ] ] swap join
      ' [ nested swap join ]
      fold ]                 is reverse ( [ --> [ ):


  map ( [ x --> [ ):

  map applies the word or nest x to each item in a nest. So

  ' [ [ 1 2 ] [ 3 4 ] [ 5 6 ] ] ' reverse map

  would return [ [ 2 1 ] [ 4 3 ] [ 6 5 ] ]

  If the nest is empty map returns an empty nest.

  x must take one argument and return one item.


  filter ( [ x --> [ ):

  filter applies the test x to each item in a nest. It returns a
  nest of the items for which the test returned true.

  If the nest is empty filter returns an empty nest.

  x must consume one item and return a Boolean.

)

  [ over [] = iff drop done
     dip 
       [ behead swap
        ' [ witheach ] ]
     nested join do ]       is fold   ( [ x --> x )

  [ dip reverse fold ]      is foldr  ( [ x --> x )

  [ ' [ [ ] ] rot join swap
    nested
    ' [ nested join ] join
    fold ]                  is map    ( [ x --> [ )

  [ ' [ [ ] ] rot join swap
    nested ' dup swap join
    ' [ iff [ nested join ]
        else drop ] join
    fold ]                  is filter ( [ x --> [ )