<html><head></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space; "><div><br></div><div>I like this idea a lot. If you start from racket/base, you can then 'graduate' to a saner Racket gradually. -- Matthias</div><div><br></div><div><br></div><div><br></div><br><div><div>On Mar 10, 2013, at 7:07 AM, Laurent wrote:</div><br class="Apple-interchange-newline"><blockquote type="cite"><div dir="ltr"><div><div><div><div><div>Just a side question:<br></div>Would it be a bad idea to make a separate library that uses the normal names without f, so that people can write<br></div>#lang racket<br></div>(require racket/flist)<br>

<br>?<br></div>or even use `prefix-in' if they prefer?<br><br></div>Laurent<br><div><div><br><br></div></div></div><div class="gmail_extra"><br><br><div class="gmail_quote">On Sat, Mar 9, 2013 at 4:28 PM, Eli Barzilay <span dir="ltr">&lt;<a href="mailto:eli@barzilay.org" target="_blank">eli@barzilay.org</a>&gt;</span> wrote:<br>

<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Two days ago, Asumu Takikawa wrote:<br>
&gt; We were considering the following set of names:<br>
&gt;<br>
&gt; &nbsp; takef, dropf, takef-right, dropf-right, splitf, splitf-right<br>
<br>
I did most of this, and there are three important comments:<br>
<br>
1. Name: `splitf' is not right, since it's missing the "-at". &nbsp;I<br>
&nbsp; &nbsp;eventually went with `splitf-at' (since adding the `f' at the end<br>
&nbsp; &nbsp;makes it unreadable).<br>
<br>
2. Argument order: I think that it is important to be able to switch<br>
&nbsp; &nbsp;from (for example) `take' to `takef' and the index by a predicate.<br>
&nbsp; &nbsp;For this analogy to work, the order of arguments needs to be the<br>
&nbsp; &nbsp;same for both. &nbsp;Given that `take' etc already exist, it's the new<br>
&nbsp; &nbsp;functions that need to change. &nbsp;This is unfortunate:<br>
&nbsp; &nbsp;0. It goes against `take' in Haskell and in lazy (not new).<br>
&nbsp; &nbsp;1. Clojure joins that other party.<br>
&nbsp; &nbsp;2. It also goes against `member' and `find' where the list is the<br>
&nbsp; &nbsp; &nbsp; second argument, so the "f" similarity between `findf' and<br>
&nbsp; &nbsp; &nbsp; `takef' can be confusing.<br>
&nbsp; &nbsp;Personally, I think that this has been a PITA for such a long time<br>
&nbsp; &nbsp;and I'd prefer seeing `take' etc change to join the winning party.<br>
&nbsp; &nbsp;I think that srfi-1 made a mistake, not just that it chose the path<br>
&nbsp; &nbsp;that ended up being unpopular, because it made an inconsistent<br>
&nbsp; &nbsp;choice with other functionality that it provides.<br>
<br>
&nbsp; &nbsp;Regardless of this, if it's uniform interface vs good order, I<br>
&nbsp; &nbsp;prefer going with the uniform interface and the existing bad<br>
&nbsp; &nbsp;order. &nbsp;So I think that I should switch the order, protest myself<br>
&nbsp; &nbsp;silently, and continue.<br>
<br>
3. `takef-right' etc. &nbsp;I started implementing these, but maybe they<br>
&nbsp; &nbsp;shouldn't. &nbsp;The following explanation is probably only for people<br>
&nbsp; &nbsp;who are interested in what gets added (ie, Asumu), or maybe if you<br>
&nbsp; &nbsp;like a dead-end puzzle. &nbsp;For the others, it's probably enough to<br>
&nbsp; &nbsp;note that there are no such things in drfi-1/clojure/etc that I<br>
&nbsp; &nbsp;see.<br>
<br>
&nbsp; &nbsp;Here's why I think it might be useless:<br>
<br>
&nbsp; &nbsp;For just `takef-right', it's possible to do something smart that<br>
&nbsp; &nbsp;scans the list in order, keeping a pointer to the beginning of the<br>
&nbsp; &nbsp;"current good block". &nbsp;This avoids a double scan *but* the payment<br>
&nbsp; &nbsp;is in applying the predicate on all emlements. &nbsp;There might be a<br>
&nbsp; &nbsp;point in that in some cases, but probably in most cases it's best<br>
&nbsp; &nbsp;to apply it in reverse order, get the index, then do the usual<br>
&nbsp; &nbsp;thing.<br>
<br>
&nbsp; &nbsp;That's mildly useful in a completely unexciting way, but when it<br>
&nbsp; &nbsp;gets to the other *f-right functions, it gets worse in that the<br>
&nbsp; &nbsp;first approach won't work.<br>
<br>
&nbsp; &nbsp;So for all of these, the best that I see is: reverse the list[*],<br>
&nbsp; &nbsp;look for the place where the predicate flips to #f, then use one of<br>
&nbsp; &nbsp;the non-f from-right functions to do the work. &nbsp;So they're all just<br>
&nbsp; &nbsp;a little bit better than a reverese + non-f + reverse combination.<br>
<br>
&nbsp; &nbsp;([*] Not a strict reverse, to make these functions work with<br>
&nbsp; &nbsp;improper lists -- which is in-line with other questionable srfi-1<br>
&nbsp; &nbsp;inheritance.)<br>
<span class="HOEnZb"><font color="#888888"><br>
--<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; ((lambda (x) (x x)) (lambda (x) (x x))) &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Eli Barzilay:<br>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; <a href="http://barzilay.org/" target="_blank">http://barzilay.org/</a> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; Maze is Life!<br>
_________________________<br>
&nbsp; Racket Developers list:<br>
&nbsp; <a href="http://lists.racket-lang.org/dev" target="_blank">http://lists.racket-lang.org/dev</a><br>
</font></span></blockquote></div><br></div>
_________________________<br> &nbsp;Racket Developers list:<br> &nbsp;<a href="http://lists.racket-lang.org/dev">http://lists.racket-lang.org/dev</a><br></blockquote></div><br>
</body></html>