tailrecursion-modulo-cons

I'm very new to Scala, so forgive my ignorance! I'm trying to iterate of pairs of integers that are bounded by a maximum. For example, if the maximum is 5, then the iteration should return: (0, 0), (0, 1), ..., (0, 5), (1, 0), ..., (5, 5) I've chosen to try and tail-recursively return this as a Stream: @tailrec def _pairs(i: Int, j: Int, maximum: Int): Stream[(Int, Int)] = { if (i == maximum && j == maximum) Stream.empty else if (j == maximum) (i, j) #:: _pairs(i + 1, 0, maximum) else (i, j) #:: _pairs(i, j + 1, maximum) } Without the tailrec annotation the code works: scala> _pairs(0, 0, 5)

i see several examples of implementing append an element to a list, but all are not using tail recursion . how to implement such a function in a functional style? (define (append-list lst elem) expr) The following is an implementation of tail recursion modulo cons optimization, resulting in a fully tail recursive code. It copies the input structure and then appends the new element to it, by mutation, in the top-down manner. Since this mutation is done to its internal freshly-created data, it is still functional on the outside (does not alter any data passed into it and has no observable

I'm working through "Learn Prolog now" online book for fun. I'm trying to write a predicate that goes through each member of a list and adds one to it, using accumulators. I have already done it easily without tail recursion. addone([],[]). addone([X|Xs],[Y|Ys]) :- Y is X+1, addone(Xs,Ys). But I have read that it is better to avoid this type of recursion for performance reasons. Is this true? Is it considered 'good practice' to use tail recursion always? Will it be worth the effort to use accumulators to get into a good habit? I have tried to change this example into using accumulators, but it