It sounds like you completely missed the point of Crenshaw’s tutorials. LBC isn’t about writing pretty, clean, or efficient code. It’s all about bringing something that’s steeped in formal theory down to a level where the casual coder can easily and rapidly hack out a rudimentary (but working!) compiler. When I read through LBC years … Read more
I don’t believe there’s anything built into LINQ to do this. There’s a problem with doing it recursively like this – you end up creating a large number of iterators. This can be quite inefficient if the tree is deep. Wes Dyer and Eric Lippert have both blogged about this. You can remove this inefficiency … Read more
This function, perm(xs), returns all the permutations of a given array: function perm(xs) { let ret = []; for (let i = 0; i < xs.length; i = i + 1) { let rest = perm(xs.slice(0, i).concat(xs.slice(i + 1))); if(!rest.length) { ret.push([xs[i]]) } else { for(let j = 0; j < rest.length; j = j … Read more
Tail call elimination is an optimization that saves stack space. It replaces a function call with a goto. Tail recursion elimination is the same thing, but with the added constraint that the function is calling itself. Basically, if the very last thing a function A does is return A(params…) then you can eliminate the allocation … Read more
When searching recursively, you have to pass the result back by returning it. You’re not returning the result of findNode(id, currentChild), though. function findNode(id, currentNode) { var i, currentChild, result; if (id == currentNode.id) { return currentNode; } else { // Use a for loop instead of forEach to avoid nested functions // Otherwise “return” … Read more
It is not possible to recur on anonymous functions in Elixir. Erlang 17 (currently a release candidate) adds this possibility to Erlang and we plan to leverage it soon. Right now, the best approach is to define a module function and pass it around: def neural_bias([i|input],[w|weights], acc) do neural(input,weights,i*w+acc) end def neural_bias([], [bias], acc) do … Read more
You can use: var divs = document.getElementsByTagName(“div”); for(var i = 0; i < divs.length; i++){ //do something to each div like divs[i].innerHTML = “something new…”; }
You’re being hit by filter‘s laziness. Change (filter …) to (doall (filter …)) in your recur form and the problem should go away. A more in-depth explanation: The call to filter returns a lazy seq, which materialises actual elements of the filtered seq as required. As written, your code stacks filter upon filter upon filter…, … Read more
This question and its answers appear to date back to Ruby 1.8.x, which used the C stack. Ruby 1.9.x and later use a VM that has its own stack. In Ruby 2.0.0 and later, the size of the VM stack can be controlled via the RUBY_THREAD_VM_STACK_SIZE environment variable.
There is an interesting way to do it that does rely neither on rebinding nor the behavior of def. The main trick is to go around the limitations of recursion by passing a function as an argument to itself: (defn make-fibo [y] (let [fib (fn [mem-fib x] (let [fib (fn [a] (mem-fib mem-fib a))] (if … Read more