View source for Higher Order Functions Hall of Fame Assignment

=Code To Implement=
==MapHof==
===map===
{{JavaToImplement|MapHof|map|hof.map.assignment}}

 <nowiki>public static <T, R> ImmutableList<R> map(Function<T, R> f, ImmutableList<T> list)</nowiki> {{HofHof}}

==MapHofApps==
{{JavaToImplement|MapHofApps|mapToLengths<br>mapToStrictlyLessThan|hof.map.assignment}}

 <nowiki>public static ImmutableList<Integer> mapToLengths(ImmutableList<String> texts)</nowiki>

 <nowiki>public static ImmutableList<Boolean> mapToStrictlyLessThan(ImmutableList<Integer> xs, int threshold)</nowiki>

==FilterHof==
===filter===
{{JavaToImplement|FilterHof|filter|hof.filter.assignment}}

 <nowiki>public static <E> ImmutableList<E> filter(Predicate<E> predicate, ImmutableList<E> list)</nowiki> {{HofHof}}

==FilterHofApps==
{{JavaToImplement|FilterHofApps|filterWordsWhichContainAllVowels<br>filterEvens|hof.map.assignment}}

 <nowiki>public static ImmutableList<String> filterWordsWhichContainAllVowels(ImmutableList<String> words)</nowiki>

 <nowiki>public static ImmutableList<Integer> filterEvens(ImmutableList<Integer> xs)</nowiki>

==FoldHof==
<!--
Lexical scope is not unique to ML.  Nearly all programming languages use lexical scope, including Java.  

First, we will build the utility methods: foldLeft (which can be easily built with tail recursion) and foldRight (which cannot).

Next, we will build some applications which use fold: sum (which does not require lexical scope) and countBetweenMinAndMaxExclusive (which does).
-->
{{JavaToImplement|FoldHof|foldLeft<br>foldRight|hof.fold.assignment}}

===foldLeft===
[http://sml-family.org/Basis/list.html#SIG:LIST.foldl:VAL SML List foldl] 

 <nowiki>public static <A, B> A foldLeft(BiFunction<A, B, A> f, A acc, ImmutableList<B> list)</nowiki> {{HofHof}}
:<code>foldLeft(f, initial_value, [x1, x2, ..., xn])</code>
:returns <code>f(xn,...,f(x2, f(x1, initial_value))...)</code> or <code>initial_value</code> if the list is empty.

===foldRight===
 <nowiki>public static <A, B> A foldRight(BiFunction<A, B, A> f, A acc, ImmutableList<B> list)</nowiki> {{HofHof}}
:<code>foldRight(f, initial_value, [x1, x2, ..., xn])</code>
:returns <code>f(x1, f(x2, ..., f(xn, init)...))</code> or <code>initial_value</code> if the list is empty.

==Fold Apps==
{{JavaToImplement|FoldHofApps|sum<br>countBetweenMinAndMaxExclusive|hof.map.assignment}}
===sum===
 <nowiki>public static int sum(ImmutableList<Integer> xs)</nowiki>
===countBetweenMinAndMaxExclusive===
 <nowiki>public static int countBetweenMinAndMaxExclusive(int min, int maxExclusive, ImmutableList<Integer> xs)</nowiki>

==Find==

==Find Apps==

=Test=
{{TestSuite|HigherOrderFunctionTestSuite|hof.assignment}}
==Map==
{{TestSuite|MapTestSuite|hof.map.assignment}}
==Filter==
{{TestSuite|FilterTestSuite|hof.filter.assignment}}
==Fold==
{{TestSuite|FoldTestSuite|hof.fold.assignment}}
==Filter==
{{TestSuite|FindTestSuite|hof.find.assignment}}

=Test=
{{TestSuite|FoldTestSuite|hof.fold.assignment}}