It is kind of fitting that additional support for Functional Programming in JavaScript should be provided as additional methods of the JavaScript class Function. Don't you think?
This blog-post describes some additional features not previously covered and the fpmap() -library as a whole. The described features are now implemented in the "fpmp" download available from npm and GitHub, see links below.
1. WHERE DID IT ALL COME FROM?
JavaScript standard Array.prototype.map() can be used to execute a given function once once for each of the array-elements and get back an array containing the results of each such call:var arr = [1,2,3];
var a2 = arr.map (double); // -> [2, 4, 6]
Above "double" is a function which returns its argument times two. Writing such code I occurred to me to ask did I write it correctly. Or should I have instead written:
var a3 = double.map (arr); // ???
Luckily I had it correct no problem. I usually don't' make errors like that I congratulated myself. But then I started thinking, is there any rule-of-thumb I could use to easily remember the correct order? Is there perhaps something obviously wrong in the "wrong order" ?
I couldn't find anything obviously wrong with it. So I started thinking, why does it have to matter which way I put it? If both ways would produce the same result then I could more easily remember the simplest rule: Order doesn't matter! If something seems good either way, we shouldn't have to think much about which way to do it.
So, went to work and implemented the function "fpmap()". Calling it to first install Function.prototpe.map(), it now allows me to write:
var a3 = double.map (arr); // -> [2,4,6]
2. AN INSIGHT AND A REVELATION
This made me feel almost like I had discovered complex numbers! Why? Because it seemed the possible ways of using the same operation, with different types of arguments had now greatly expanded. It was almost like jumping out of line to the plane around it! Let me explain...With [1,2,3].map(double) the "recipient" must always be an Array, and it seems argument-type must be Function, to make it useful in general. Regardless of what type the Array elements are, you can then always put in as argument some function that accepts those array-elements as argument.
With double.map([1,2,3]) it came obvious to ask a follow-up question: What if I use something else as argument, perhaps an Object like: "double.map({x: 1, y: 2})" ? Is there something useful such an expression could do? YES OF COURSE. It can iterate over the fields of the argument-object, like {x:1, y:2}.
You could't really do such an expansion with Array.prototype.map(), unless you start adding the method "map()" to all built-in prototypes in JavaScript. That is a possibility but there's no need for that if we can make Function.prototype.map treat different types of arguments in different ways. The area of the standard library that needs to be extended this way stays smaller, and you choose and alternative method-name to use as desired. You can install it as Function . prototype . map9() if you wish to use a more unique name
With this re-arrangement there seems to be no reason why the argument could not be a non-Array "object". Which leads to the further question: What else? What are the argument-types that could be passed to Function .prototype .map, to accomplish something useful, some economies of the amount of code you must write, read, and understand? What should be the behavior of 'map' with such possible argument-types?
3. THE USEFUL ARGUMENT-TYPES OF Function.prototype.map
The previous blog-posts described three argument-types so far: Array, (non-Array) Object, Function. Yes. Function.prototype.map() can also take a function as its argument, the result being the "composition" of the two functions. And you can compose a whole series, a "pipeline" if you will: funkA . map(funkB) . map(funkC) ;But turns out there are still a few more argument-types with different, useful behavior. In the end, currently "fpmap" now supports the following behaviors on the following six (6) argument-types:
A) Array
Like standard Array.prototype.map() but with recipient and the argument-types switched.B) Object
Similar to Arrays but iterates over named properties of the object rather than array indexes.C) Function
Implements function-composition. Like: var result = funkA . map(funkB) . map(funkC) ;D) RegExp
Returns a function which can be used to Iterate over all matches of a given Regular Expression for any string-argument.E) Number
Returns a function which when given an initial argument will call the source-function with it, then call it again with the results and so on N times, where N is the number that was given as argument to fmap(N). Naturally requires that the source-function result-type is the same as its argument type. Useful for creating numeric series like Fibonacci's but also for building arbitrary recursive data-structures.F) String
Iterates by repeatedly calling a function that incrementally consumes parts of the argument string, in effect parsing it according to the language specified by the recipient-function.4. WHAT UNITES THEM ALL
What unites the different argument types described above is they are all used in the same manner, as argument to Function.prototype.map. So it's kind of easy to remember how to use them, if not exactly what each of them exactly does. But that you can look up from documentation.For detailed documentation of the above and other features of fpmap() see the unit-tests-file fpmap_test.js. Tests don't lie. The code of the tests serve as examples of how to use fpmap() with different arguments, and what to expects as result. There's also explanatory comments. The README.md of course is a good source for documentation as well.
Could there still be other additional, useful argument-types besides the above? Possibly. But the above is a good start.
5. LINKS
GitHuh: https://github.com/panulogic/fpmapNpm: https://www.npmjs.com/package/fpmap
Twitter: https://twitter.com/panulogic
_____________________________________________________________
Copyright © 2017 Panu Viljamaa. All rights reserved unless otherwise noted.Reuse of source-code in this blog-post is allowed under the terms of
Creative Commons Attribution 4.0 International (CC BY 4.0) -license
No comments:
Post a Comment