This issue is related to the fact that primitive types in Java are not unified to be substitutable for Object, and with generic type erasure. Using Function<T, Integer> instead of IntFunction<T> when the last one suffices has 2 disadvantages: Every returned int is boxed – meaning a larger memory footprint; Every returned Integer gets an … Read more
I’ve been gathering examples of functional programming with Ruby: Wiki page Presentation: Functional programming with Ruby.
OK. We have three times the Function.prototype.bind function here, whose (simplified) code function bind(context) { var fn = this; return function() { return fn.apply(context, arguments); } } I will abbreviate in a more functional style with lots of partial application: bindfn(context) -> fncontext. So what does it do? You have got bind.call(bind, bind) or bindbind(bind). … Read more
One way to think of this is that a value of type IO a is a “recipe”, containing a list of instructions that if performed would have side effects. Constructing that “recipe” though, does not have any side effects. So a haskell program (whose type is IO ()) is basically a computation that constructs such … Read more
There’s nothing to stop you from adding arbitrary properties to a function, eg. function bar(o) { var f = function() { return “Hello World!”; } o.__proto__ = f.__proto__; f.__proto__ = o; return f; } var o = { x: 5 }; var foo = bar(o); assert(foo() === “Hello World!”); delete foo.x; assert(foo.x === 5); I … Read more
Math.max can be used as a higher-order function. The problem is .reduce will call the function with 4 arguments: Math.max(accumulator, value, index, the_array) here is the_array is an array, so Math.max returns NaN. I don’t think there’s simpler way to discard the last 2 arguments.
List comprehensions (in fact, Monad comprehensions) can be desugared into do notation. do i <- [1..4] j <- [i+1..4] return (i,j) Which can be desugared as usual: [1..4] >>= \i -> [i+1..4] >>= \j -> return (i,j) It is well known that a >>= \x -> return b is the same as fmap (\x -> … Read more
Implementation which does not stack-overflows: let splitList list = List.foldBack (fun x (l,r) -> x::r, l) list ([],[])
The best answer is ‘neither’. 🙂 There’s some ugliness associated with both while loops and tail recursion. While loops require mutability and effects, and though I have nothing against using these in moderation, especially when encapsulated in the context of a local function, you do sometimes feel like you’re cluttering/uglifying your program when you start … Read more
This is probably not the answer you’re looking, but I just noticed Validation has the following methods /** Run a disjunction function and back to validation again. Alias for `@\/` */ def disjunctioned[EE, AA](k: (E \/ A) => (EE \/ AA)): Validation[EE, AA] = k(disjunction).validation /** Run a disjunction function and back to validation again. … Read more