To give some specific recommendations about choosing between namespaces, modules abd classes in F#: If you’re writing functions using let that are expected to be used from F#, then putting them inside a module is the best choice. This gives you API similar to List.map and other basic F# functions. Regarding naming, you should use … Read more
The call method exists on all functions in Javascript. It allows you to call the function and in doing so set the value of this within that function. function myFunc() { console.log(this); } myFunc.call(document.body); In this example, this within myFunc will be document.body. The first parameter of call is the value to be set as … Read more
Don’t worry quite so much about the stack. There is nothing fundamental that says function calls have to be implemented using stack frames; that is merely one possible technique for implementing them. Even when you have “the stack”, there’s certainly nothing that says the stack has to be limited to a small fraction of available … Read more
Actually, some schools already do it this way around. Where I study (University of Copenhagen), they teach SML in the first semester, as an intro to programming. Then they teach Java afterwards, as an intro to OOP. I think it works extremely well, and I agree with you it’s better than the other way around. … Read more
map() returns an iterator, and will not process elements until you ask it to. Turn it into a list to force all elements to be processed: list(map(self.do_someting,range(10))) or use collections.deque() with the length set to 0 to not produce a list if you don’t need the map output: from collections import deque deque(map(self.do_someting, range(10))) but … Read more
Doing functional programming in C# is technically possible (well, any language that has function pointers or delegates equivalent can be “functional”) — but C# gets very very painful if you try to do much. Off the top of my head, in no particular order: Type inference Only exists for locals now Should apply to pretty … Read more
Actually, doing arbitrary arity with type classes turns out to be incredibly easy: module Pred where class Predicate a where complement :: a -> a instance Predicate Bool where complement = not instance (Predicate b) => Predicate (a -> b) where complement f = \a -> complement (f a) — if you want to be … Read more
I want to propose a lazier version of merge: merge [] ys = ys merge (x:xs) ys = x:merge ys xs For one example use case you can check a recent SO question about lazy generation of combinations. The version in the accepted answer is unnecessarily strict in the second argument and that’s what is … Read more
If this class is immutable, won’t it take a huge amount of memory? Typically your memory requirements for that single object might double, because you might have an “old copy” and a “new copy” live at once. So you can view this phenomenon, over the lifetime of the program, as having one more large object … Read more
As always, continuations yield an elegant tailcall solution: open System.Collections.Generic let cache = Dictionary<_,_>() // TODO move inside let memoizedTRFactorial = let rec fac n k = // must make tailcalls to k match cache.TryGetValue(n) with | true, r -> k r | _ -> if n=0 then k 1 else fac (n-1) (fun r1 … Read more