higherorder.edh

{
  # partial functions

  method f( a, b, c ) {
    console.print( 'this is f()', a=a, b=b, c=c )
  }

  # partial is used to create partially applied functions
  f1 = partial ( 1, 2 ) ( f )

  # note the (|) pipe operator is flipped procedure call operator, then f2 is
  # equivalent to f1, but more idiomatic
  let f2 = f|partial( 1, 2 )

  # note the pipe (|) operator has a rather low precedence -5, lower than the
  # assign (=) operator's precedence 0, so if not writing it as a `let`
  # statement, parenthesis is necessary, then f3 is equivalent too
  f3 = ( f|partial( 1, 2 ) )

}
f1( 3 )
f2( 5 )
f3( 7 )

{
  # args fusion

  # with respecting to procedure call via ($) or (|), if an ArgsPack
  # takes the place of a procedure (the callee), it just absorbs the other
  # positional argument or a whole arguments pack, to form a new ArgsPack
  # note (|) has higher precedence than ($), so parenthesis quoting is needed

  ( ( 2, 11, n=3 ) $ ( 9, 7, m=5 ) ) | console.print

  ; # this semicolon is necessary or the following round brackets will be
  #   parsed as procedure call

  ( 9, 7, m=5 ) | ( 2, 11, n=3 ) | console.print

}

{
  # decorator

  # %% # A decorator is usually written in the host language, but as well, it can be written in Đ the surface language, in form of an interpreter procedure

  interpreter decor( callerScope, fe ) case callerScope.eval( fe ) of { f } -> {
    callerScope.eval( expr method @(f.name) ( ***apk ) {
        console.info<| 'Calling procedure `' ++ {$ f.name $} ++ '` with: ' ++ apk
        {$ f $} ( ***apk )
    } )
  }

  # %% # And used like this

  decor$
  method g ( a, b, c ) {
    console.info<| 'This is g(), we have: ' ++ ( a=a, b=b, c=c, )
  }

  # %% # The decorated procedure can be used straight forward
  g( 1, 2, 3 )

  # %#
}