• You write some JS to provide a function main()
• It relies on a helper() function
• What can go wrong?

• helper is in the global name space
• what if some other code has a function called helper()?

						
							<script>
							function helper() {
							...
							}

							function main() {
								helper();
							...
							}
							</script>
						
					

• Write your code inside a function scope
• Top level function executes immediately
• All your code is hidden in the local scope by default
• You can decide what names to expose by setting global variables

						
							(function () {
								// defined in local scope
								function helper () {
								...
								}

								// set in global scope
								main = function () {
									helper();
									...
								}
							})();
						
					

• Even better: let the user of your code choose the name
• Return the function you want exposed
• They assign it to a variable name of their choice

						
							let main = (function () {
								function helper () {
								...
								}

								function myFunction () {
									helper();
									...
								}

								return myFunction;
							})();
						
					

						
							//defining a library
							function makeMyLibrary () {
								function helper () {
								...
								}

								function mainFunction () {
									helper();
								}

								function otherMainFunction() ...

								return {
									"main": mainFunction,
									"otherMain": otherMainFunction};
								};
							}
					

• Nice way to minimize your impact on the global context
• Even if you want to provide many functions
• Define one object that contains all the functions/properties you want to expose
• Define any local variables in local scope of your defining function

							//library user
							let library = makeMyLibrary();
							library.main();
						
					

							function combine(key,x,y) {
								if (key == '+') {
									return x+y;
								} else if (key == '-') {
									return x-y;
								} else if (key == '^') {
									return x**y;
								} else if (key == '*') {
									return x*y;
								}
							}
					

• data about operations interleaved with computation
• writing a new op means changing the code
• inefficient walk through all cases

							(function () {
								let ops = {
									"+": (x,y) => x+y;
									"-": (x,y) => x-y;
									"*": (x,y) => x*y;
							        "^": (x,y) => x**y;
							};

							function combine(key,x,y) {
								returns ops[key](x,y);
								};
							})();
					

• Data about operations separated from code
• Adding an operation edits only the data
• Efficiently jump to relevant case
• DRY avoids duplication of if test
• Can even write functions to dynamically add new operations

Partial Function Evaluation

• Bind can also bind other arguments of the function/method
• Useful if you plan to frequently repeat same arguments
• Or use the function as a callback with parameters the calling function shouldn't know about
• Limitation: can only bind a prefix of the arguments

						
							let add = (x,y) => x+y;
							let power = (x,y) => x**y;
							let increment = add.bind(null,1);
							let exp = power.bind(null,2.718);

							//can't let square = power.bind(null, 2);
							//power.bind(null,2) produces 2**y
						
					

• Often, sequence of updates on an object
• Some redundancy repeating object name
• Can we remove it?

						
							function action1 () {
								this.age=17;
								...
								return;   // no return value
							}

							element.action1();
							element.action2();
							element.action3();
						
					

• Having/using no return value is a waste
• Modify methods to return their own object
• Now can apply next method on returned value

						
							function action1 () {
								this.age = 17;
								...
								return this; // chainable
							}

							element.action1().action2().action(3);

							element.action1()
								.action2();
								.action3();
						
					

• Suppose a language only has functions
• You can implement objects yourself!
• Converse not true: objects cannot implement functions
• Implement an object as a function that, given a key, returns the value associated with that key
• To set a key, define a new function that knows what to return for that key and otherwise asks the old function

							const emptyObject = function() {
								return (key) => undefined;
							}

							const oSet = function(obj,key,value) {
								return function(q) {
									if (q == key) {
										return value;
										} else {
										return obj(q);
									}
								}
							}
					

• λ-calculus developed by Alonzo Church to explore the theory of computation using functions
• “function“ keyword in JS is equivalent to “λ”
• λ(x)(+ 1 x)
• TRUE is a function that returns its first argument
• FALSE returns its second
• IF just applies its first argument to the next two
• Everything is functions, so these functions all return functions

							const TRUE = (x,y) => x;
							const FALSE = (x,y) => y;
							const IF = (x,y,z) => x(y,z);
							const NOT = x => if(x,FALSE,TRUE);
							const AND = (x,y) => IF (x,y,FALSE);
							const OR = (x,y) => IF (x,TRUE,y);

							AND(TRUE,FALSE) -> IF(TRUE,FALSE,FALSE)
			        -> TRUE(FALSE,FALSE)
			        -> FALSE;

							AND(TRUE,TRUE)  -> IF(TRUE,TRUE,FALSE)
			        -> TRUE(TRUE,FALSE)
			        -> FALSE;