Hi John,
I don't know the reason why Elm does not have them but Elm's core library
usually gives best minimum set of functions. For example, List module don't
have `find`, `zip`, and `scanl` that are included in community package
named list-extra
<http://package.elm-lang.org/packages/elm-community/list-extra/6.1.0/List-Extra>.
But I don't think all of them should always be listed in core, simply
because it is too many. So it should be important how often we use them or
how these functions effectively work in practice.
I agree that basically it is better to not write a bare recursion. I also
agree `until : (a -> Bool) -> (a -> a) -> a -> a` is better than `until
: (a -> Bool) -> a -> (a -> a) -> a`. But in my daily development,
generating a list or calculating until some condition is very rare logic. I
wonder which is easier to choose/remember a function or to write/read a
recursive function.
2017年7月24日月曜日 19時13分09秒 UTC+9 John Bugner:
>
> For example, making a function that flood fills an area from a given start
> point. You know that it'll eventually end, but you don't know exactly how
> many times you need to recurse, unlike 'map' or 'fold', where the number of
> times is the same as the number of items in the list/collection.
>
> It's basically a wrapper for the recursion, letting your function focus on
> the logic.
>
> On Monday, July 10, 2017 at 10:28:15 AM UTC-5, 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 elm-discuss+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
