You might need to do optimizations until there are no more changes to make.
Conceptually, you can express it as a while loop.
On Monday, July 10, 2017 at 8:28:15 AM UTC-7, Erkal Selman wrote:
>
> What exactly do you need the while-loop for?
>
> On Thursday, July 6, 2017 at 7:04:18 AM UTC+2, John Bugner wrote:
>>
>> In imperative OO languages, there are for/while loops:
>>
>> A for-loop often looks like this:
>>
>> for (i = 0; i < 100; i++) {
>> a[i] = f(i);
>> }
>>
>> In Elm (and Haskell), we have the neat `map` function that captures this
>> pattern:
>>
>> map f a
>>
>> A while-loop looks like this:
>>
>> while (!isDone(s)) {
>> f(s);
>> }
>>
>> Haskell has the `until` function that captures this pattern:
>>
>> until isDone f s
>>
>> Elm lacks this function. Is there a reason why? What's the current elmic
>> way of doing this? Explicit recursion, I assume?
>>
>> Anyways, it seems that somebody else already yearned for `until` like me,
>> and made this module:
>> http://package.elm-lang.org/packages/Chadtech/elm-loop/1.0.2/Loop ...
>>
>> I note though, that he changed the order of the arguments from Haskell's
>> `(a -> Bool) -> (a -> a) -> a -> a` to `(a -> Bool) -> a -> (a -> a) -> a`.
>> I'm not sure why. If he wanted to match the usual impOO order, then why not
>> `a -> (a -> Bool) -> (a -> a) -> a` instead ? Anyways, I think Haskell's
>> order is the right order, because it let's you make useful closures, like
>> this:
>>
>> collatz : Int -> Int
>> collatz =
>> let
>> u : Int -> Int
>> u n =
>> if isEven n
>> then n // 2
>> else 3 * n + 1
>> in
>> until ((==) 1) u
>>
>> This function is elegantly defined, but not very useful, because the
>> result of every (positive) number will simply return 1 (mathematicians
>> strongly suspect so, anyways). What's interesting is the *sequence* that a
>> number makes on it's way down to 1. So I made a function that repeats like
>> `until`, but also records each intermediate result in a list, like `scanl`:
>>
>> scanUntil : (a -> Bool) -> (a -> a) -> a -> List a
>> scanUntil p u s =
>> let
>> p_ : List a -> Bool
>> p_ xs = case xs of
>> [] -> True
>> x :: _ -> p x
>> u_ : List a -> List a
>> u_ xs = case xs of
>> [] -> []
>> x :: _ -> u x :: xs
>> in
>> until p_ u_ [s]
>>
>> I'm not sure that `scanUntil` is the best name. Can anybody think of a
>> better name? I also note that list that it returns is reversed compared to
>> `scanl`'s and Haskell's `iterate` function (
>> https://hackage.haskell.org/package/base-4.7.0.2/docs/Prelude.html#v:iterate
>> ), but feels right because the most useful value is probably going to be
>> the last one calculated. But maybe this doesn't matter, because if you
>> really want the last one calculated, then you'd just use `until` instead
>> anyways.
>>
>> Anyways... answers, thoughts, and comments are welcome.
>>
>>
--
You received this message because you are subscribed to the Google Groups "Elm
Discuss" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
