Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Functional ‘while’ loops – no, really

billwadge.wordpress.com

Post reply on HN
Print view View original

1–8 of 8 posts

Re: Functional ‘while’ loops – no, really

#2

Post by pwdisswordfish8 »

What happens if the loop body does not assign to the result variable? What if the condition is false before entering the loop?

I think it would have been cleaner to pass the value the loop should return to a break primitive and otherwise compute it in a dedicated block.

Re: Functional ‘while’ loops – no, really

#3

Post by tromp »

The author suggests that Haskell could benefit from rewriting

    nodups = dedup [] where
      dedup m [] = m
      dedup m (x:xs) = dedup (if x `elem` m then m else m++[x]) xs
as some syntactic sugar while loop:

    nodups l = while k != []
                 k = l ||| tail l
                 m = [] ||| if head k `elem` m then m else m ++ head k
                 result = m
but I would disagree. Btw, the former appears to suffer from quadratic slowdown due to repeated use of ++ which can be avoided by replacing m++[x] with x:m and making dedup m [] = reverse m.

Re: Functional ‘while’ loops – no, really

#4

Post by iamevn »

pwdisswordfish8 wrote: post #2

What happens if the loop body does not assign to the result variable? What if the condition is false before entering the loop? I think it would have been cleaner to pass the value the loop should return to a break primitive and otherwise compute it in a dedicated block.

My understanding is that a while (or a valof) that doesn't assign to result is invalid.

If the condition is false before entering the loop then result would be 1 (its initial value)

if it helps and if I understand correctly, this would be the same algorithm expressed in scheme:

(define (fib n) (let loop ([i 1] [f 1] [pf 1]) (if (((let name args body) is essentially sugar for creating a function and calling it with some default args)

Re: Functional ‘while’ loops – no, really

#5

Post by iamevn »

iamevn wrote: post #4
pwdisswordfish8 wrote: post #2

What happens if the loop body does not assign to the result variable? What if the condition is false before entering the loop? I think it would have been cleaner to pass the value the loop should return to a break primitive and otherwise compute it in a dedicated block.

My understanding is that a while (or a valof) that doesn't assign to result is invalid. If the condition is false before entering the loop then result would be 1 (its initial value) if it helps and if I understand correctly, this would be the same algorithm expressed in scheme: (define (fib n) (let loop ([i 1] [f 1] [pf 1]) (if ( ((let name args body) is essentially sugar for creating a function and calling it with s…

(code with formatting http://pasterack.org/pastes/80204 )

Re: Functional ‘while’ loops – no, really

#6

Post by bade »

iamevn wrote: post #4
pwdisswordfish8 wrote: post #2

What happens if the loop body does not assign to the result variable? What if the condition is false before entering the loop? I think it would have been cleaner to pass the value the loop should return to a break primitive and otherwise compute it in a dedicated block.

My understanding is that a while (or a valof) that doesn't assign to result is invalid. If the condition is false before entering the loop then result would be 1 (its initial value) if it helps and if I understand correctly, this would be the same algorithm expressed in scheme: (define (fib n) (let loop ([i 1] [f 1] [pf 1]) (if ( ((let name args body) is essentially sugar for creating a function and calling it with s…

I wouldn't use the word "assign" these are definitions and their order is not significant. You're right, a while without a definition of result produces a syntax error. If the condition is initially false, the definition of result is immediately evaluated.

Looks like I fooled some people into assuming that whiles are imperative. They're not

Re: Functional ‘while’ loops – no, really

#8

Post by bade »

myWindoonn wrote: post #7

Haskell sucks, but they don't even know Haskell. There's a package ( https://hackage.haskell.org/package/monad-loops ) which contains `whileM`, a pure while-loop which works with any Monad.

I assume 'they' means me. True I don't know Haskell but from what I can tell these loops are a far cry from what I'm proposing. One variable, monads, and apparently side effects.

Mine have multiple variables, no monads, and no side effects - it all gets done by tail recursion.

Post reply on HN