Rosetta Code

Higher-order functions: Difference between revisions

Page Discussion

Higher-order functions (view source)

Revision as of 22:34, 30 September 2016

278 bytes removed ,  7 years ago
m
{{header|Lily}} Update for current version.
m (→‎{{header|REXX}}: changed the comment describing the program.)
m ({{header|Lily}} Update for current version.)
Line 1,598:
 
=={{header|Lily}}==
<lang lily>define fsquare(x: integer, yInteger): integer)Integer▼
A simple function that can take another function can be defined like this:
▲<lang lily>define f(x: integer, y: integer)
{
return x +* yx
}
 
var l = [1, 2, 3] # Inferred type: List[Integer].
define simpleHigherOrder(x: integer, y: integer, f: function(integer, integer => integer) => integer)
{
return f(x, y)
}
 
# First,Transform using anothera user-defined function.
print(l.map(square)) # [1, 4, 9]
simpleHigherOrder(1, 2, f) # Result: 3
 
# Again,Using buta using abuilt-in lambdamethod this time.
print(l.map(Integer.to_s)) # ["1", "2", "3"]
simpleHigherOrder(1, 2, {|a, b| a + b}) # Result: 3</lang>
 
# Using a lambda (with the type of 'x' properly inferred).
Here's something more interesting, using generics:
print(l.map{|x| (x + 1).to_s()}) # ["2", "3", "4"]
 
# In reverse order using F#-styled pipes.
<lang lily>define genericHigherOrder[A](x: A, y: A, f: function(A, A => A) => A)
Boolean.to_i |> [true, false].map |> print
 
define apply[A, B](value: A, f: Function(A => B)): B
{
return f(x, yvalue)
}
 
# Calling user-defined transformation.
# x is of type 'A', so A is inferred to be type integer within the lambda.
print(apply("123", String.parse_i)) # Some(123)</lang>
genericHigherOrder(1.5, 2.5, {|a, b| a + b}) # Result: 4.0
 
# The string class contains a method called concat, which joins two strings.
# Since A = string in every case, this is also allowed.
genericHigherOrder("1", "2", string::concat) # Result: "12"</lang>
 
=={{header|Lua}}==
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/13713"