Re: Whence came UFCS?
On Friday, 27 July 2018 at 03:41:29 UTC, Sameer Pradhan wrote: During our Boston D Meetup today, we went through and deconstructed Walter's wonderfully elegant blog post from 2012 called "Component Programming in D" http://www.drdobbs.com/article/print?articleId=240008321=architecture-and-design I stumbled upon this gem (and another score or so articles on the digital mars site) a few days back, while following various hyperlinks, within and around the blog on Walter's take on what was C's biggest mistake which has been getting a lot of comments over the past few days. This post which I have been trying to digest bit-by-bit over the past few days, made me realize why I fell in love with D in the first place. To top it all, Steven played a lightening talk from 2018, called "values as types" by Andreas (https://youtu.be/Odj_5_pDN-U?t=21m10s) which is a parody on C++ and is so utterly ludicrous, we could not stop laughing. Anyway, back to the point. During the same period, but independent of the thread on C's mistake, I found that Kotlin has something called "Extension Functions" and "Extension Properties" (https://kotlinlang.org/docs/reference/extensions.html) via. the following article on Medium https://medium.com/@magnus.chatt/why-you-should-totally-switch-to-kotlin-c7bbde9e10d5 Specifically Item #14. What I saw/read seemed eerily familiar. Almost like a "wolf in sheeps clothing". The example screamed of UFCS. Then, later, while reading the above Kotlin documentation, I saw a reference being made to similar functionality in C# and Gosu (apparently a programming language that I have never heard of before today) called Extensions. Furthermore, I found that Project Lombok (https://projectlombok.org/features/experimental/ExtensionMethod) has tried to make this idiom/functionality available in Java through a @ExtensionMethod annotation. This also almost exactly represent UFCS functionality, though much more cludgy, I must say. Therefore, after reading the word "Extension" in three different contexts, I started wondering and various questions came to mind, starting with---Whence came UFCS? a. Did Walter and/or Andrei invent it independently of C#? b. Was it called UFCS in some other language? c. Were they not aware of Extensions when they coined UFCS? d. Are UFCS and Extensions really one and the same thing? e. If not, what is/are the difference(s)? And is this why a different term/acronym was coined? As far as I can tell a Google search on UFCS leads to only material on D and a Wikipedia entry mentioning Stroustrup and Sutter's proposal from 2016 to extend C++ to have this facility. It is likely that the Wikipedia article is severely incomplete in its historical connections as there is no mention of C# or that of Walter's 2012 Dr. Dobbs post which already lists it towards the end---in the list of features that D has which allows the creation of elegant components---among other dozen or so features. In the end I thought I might as well dump my thoughts on the D forum and hear straight from the horse's (or horses') mouth(s)---so to speak. -- Sameer I remember reading an article that Andrei wrote a long time ago that cited an older language as the inspiration for UFCS, but it was probably from around 2007 where UFCS for arrays was already well-established (I never knew that it was actually a bug at one point). I don't remember what that language was unfortunately.
Re: Whence came UFCS?
On Friday, 27 July 2018 at 03:41:29 UTC, Sameer Pradhan wrote: Therefore, after reading the word "Extension" in three different contexts, I started wondering and various questions came to mind, starting with---Whence came UFCS? The answer I always say back in the day for the functionality was that it was a bug for arrays. The term UFCS though is much newer and just comes from discussion for applying the array bug to all types. Who started it, why it caught on I don't know. The use of the term Extension I believe is because of the implementation/syntax approach used to describe this behavior in C#. In C# you don't have free functions, so instead you need a new class with static methods. This makes the new class act as an "extension" of another object. D having free functions and the functionality working on more than objects means "Extension" wouldn't be a good term to describe it.
Re: Whence came UFCS?
Wow! I am glad to see so many responses! Thanks for your indulgence. So, to summarize, the concept (no pun intended) has been around for a while in D---originally in the context of arrays. It just might have been a bug, or an unintended side-effect. I intend to read the archival posts and might have something to say later. -- Sameer PS: I realize that I am a stickler for history, or rather historical contexts related to technology or research that I am involved in, and more recently regarding programming language concepts. The culprit is probably the fact that I have been teaching programming languages course (or, taught one semester of it, and plan to teach it again in Spring) which has allowed me to learn of the origins of so many concepts which we sometimes take for granted today, but were part of some old languages. PS1: I didn't want to respond to a particular thread, but there is no way in this forum to write a generic response to multiple posts so I am picking one as the anchor.
Re: Whence came UFCS?
On Fri, Jul 27, 2018 at 03:41:29AM +, Sameer Pradhan via Digitalmars-d
wrote:
[...]
> Whence came UFCS?
[...]
As far as I know, UFCS came about from a particular interpretation of
TDPL (Andrei's book). Andrei was talking about the range API, and
inserted a little note about how native arrays can be made into ranges
by adopting the convention that if:
arr.func(...)
cannot be resolved as a member function, then the compiler would rewrite
it as:
func(arr, ...)
instead. This would then allow generic code to be written as:
while (r.empty) {
doSomething(r.front);
r.popFront();
}
without needing to special case the code for native arrays.
Initially, this was only implemented for arrays as a special case, and
some people read Andrei's description as applying only to arrays.
However, others (including myself) read it as a general principle that
ought to apply to all types, even though at the time the compiler had
only implemented this for the array case.
After quite a lot of debate, eventually somebody (I believe it was Kenji
-- man I still miss that guy) implemented a PR for it, and after quite a
bit more controversy, the PR was merged. That was when UFCS became a
reality. The rest, as they say, was history.
T
--
People who are more than casually interested in computers should have at least
some idea of what the underlying hardware is like. Otherwise the programs they
write will be pretty weird. -- D. Knuth
Re: Whence came UFCS?
On Friday, July 27, 2018 8:09:02 AM MDT Simen Kjærås via Digitalmars-d wrote: > On Friday, 27 July 2018 at 13:38:26 UTC, Steven Schveighoffer > > wrote: > > On 7/27/18 7:24 AM, Simen Kjærås wrote: > >> Arrays' .reverse, .sort and others were added in 0.24, but I > >> can't find a download for anything before 0.50. > > > > Reverse and sort were properties (compiler built-ins), not > > extensions. If it existed in 2002, it's safe to say it was > > there pretty much from the beginning. > > From what I recall, UFCS for arrays were essentially a bug - an > unintended side effect of how the properties were implemented. > But it's been 15 years, so I can't really trust my memory. :p I vaguely recall the whole property thing being a bug, but I don't trust my memory on that at this point. - Jonathan M Davis
Re: Whence came UFCS?
On 7/27/18 10:09 AM, Simen Kjærås wrote: On Friday, 27 July 2018 at 13:38:26 UTC, Steven Schveighoffer wrote: On 7/27/18 7:24 AM, Simen Kjærås wrote: Arrays' .reverse, .sort and others were added in 0.24, but I can't find a download for anything before 0.50. Reverse and sort were properties (compiler built-ins), not extensions. If it existed in 2002, it's safe to say it was there pretty much from the beginning. From what I recall, UFCS for arrays were essentially a bug - an unintended side effect of how the properties were implemented. But it's been 15 years, so I can't really trust my memory. :p Heh, that pre-dates my D lifetime. Interesting if it was a bug! -Steve
Re: Whence came UFCS?
On Friday, 27 July 2018 at 14:31:24 UTC, Mike Parker wrote: This is the earliest thread I could find in the archives, based solely on searching for "array" in the title. I almost fell down the rabbit hole reading some of those old threads, as the ones I did look at tickled my memory. Fortunately, I caught myself in time. https://digitalmars.com/d/archives/digitalmars/D/16452.html And even earlier: https://digitalmars.com/d/archives/digitalmars/D/9779.html
Re: Whence came UFCS?
On Friday, 27 July 2018 at 14:12:53 UTC, Mike Parker wrote: On Friday, 27 July 2018 at 14:09:02 UTC, Simen Kjærås wrote: From what I recall, UFCS for arrays were essentially a bug - an unintended side effect of how the properties were implemented. But it's been 15 years, so I can't really trust my memory. :p You're not alone! That's how I remember it as well. This is the earliest thread I could find in the archives, based solely on searching for "array" in the title. I almost fell down the rabbit hole reading some of those old threads, as the ones I did look at tickled my memory. Fortunately, I caught myself in time. https://digitalmars.com/d/archives/digitalmars/D/16452.html
Re: Whence came UFCS?
On Friday, 27 July 2018 at 14:09:02 UTC, Simen Kjærås wrote: From what I recall, UFCS for arrays were essentially a bug - an unintended side effect of how the properties were implemented. But it's been 15 years, so I can't really trust my memory. :p You're not alone! That's how I remember it as well.
Re: Whence came UFCS?
On Friday, 27 July 2018 at 13:38:26 UTC, Steven Schveighoffer wrote: Reverse and sort were properties (compiler built-ins), not extensions. If it existed in 2002, it's safe to say it was there pretty much from the beginning. -Steve I came to D in 2003. I recall this coming up in the forums now and again by people discovering it for the first time and wondering why it only worked with arrays. I remember thinking it was a pretty big deal when it was expanded to work in the general case. I'm sure I wrote about it on my old blog, but now I can't find my database backup to verify.
Re: Whence came UFCS?
On Friday, 27 July 2018 at 13:38:26 UTC, Steven Schveighoffer wrote: On 7/27/18 7:24 AM, Simen Kjærås wrote: Arrays' .reverse, .sort and others were added in 0.24, but I can't find a download for anything before 0.50. Reverse and sort were properties (compiler built-ins), not extensions. If it existed in 2002, it's safe to say it was there pretty much from the beginning. From what I recall, UFCS for arrays were essentially a bug - an unintended side effect of how the properties were implemented. But it's been 15 years, so I can't really trust my memory. :p -- Simen
Re: Whence came UFCS?
On Friday, 27 July 2018 at 05:22:17 UTC, Joakim wrote: On Friday, 27 July 2018 at 03:41:29 UTC, Sameer Pradhan wrote: During our Boston D Meetup today, we went through and deconstructed Walter's wonderfully elegant blog post from 2012 called "Component Programming in D" [...] Extension methods were added to C# 3.0 in 2007, UFCS was discussed as a generalization of the concept to free functions at that year's DConf, fully implemented years later: https://forum.dlang.org/thread/htjuut$av2$1...@digitalmars.com The DConf slides linked from that old thread list this 2000 Scott Meyers article as an inspiration for UFCS: http://www.drdobbs.com/cpp/how-non-member-functions-improve-encapsu/184401197
Re: Whence came UFCS?
On 7/27/18 7:24 AM, Simen Kjærås wrote:
On Friday, 27 July 2018 at 10:30:07 UTC, Jonathan M Davis wrote:
It evolved out of D's member function call syntax for arrays -
basically, for years before we had UFCS in D, we had UFCS for arrays.
However, when and how that was added to arrays, I don't know. I don't
recall it ever not being in the language, but I never used D1, and I
don't know if it had it. At minimum, it's been in D since early D2, if
not much earlier. I'd have to do a lot of spelunking through old
releases to figure out when it was added.
Certainly, the origins of UFCS in D do not come from making it
possible to extend user-defined types with member functions. It comes
from wanting member function call syntax when using arrays (probably
aimed primarily at strings, but I don't know). It's just that later it
was proposed to extend it so that it would work with any type and thus
make the member function call syntax universal.
This compiles in DMD 0.50 (oldest version on the download page, nov 20,
2002), so I think it's safe to say it's been around for a while:
void fun(int[] arr) {}
void main() {
int[] a;
a.fun();
}
Arrays' .reverse, .sort and others were added in 0.24, but I can't find
a download for anything before 0.50.
Reverse and sort were properties (compiler built-ins), not extensions.
If it existed in 2002, it's safe to say it was there pretty much from
the beginning.
-Steve
Re: Whence came UFCS?
On Friday, 27 July 2018 at 10:30:07 UTC, Jonathan M Davis wrote:
It evolved out of D's member function call syntax for arrays -
basically, for years before we had UFCS in D, we had UFCS for
arrays. However, when and how that was added to arrays, I don't
know. I don't recall it ever not being in the language, but I
never used D1, and I don't know if it had it. At minimum, it's
been in D since early D2, if not much earlier. I'd have to do a
lot of spelunking through old releases to figure out when it
was added.
Certainly, the origins of UFCS in D do not come from making it
possible to extend user-defined types with member functions. It
comes from wanting member function call syntax when using
arrays (probably aimed primarily at strings, but I don't know).
It's just that later it was proposed to extend it so that it
would work with any type and thus make the member function call
syntax universal.
This compiles in DMD 0.50 (oldest version on the download page,
nov 20, 2002), so I think it's safe to say it's been around for a
while:
void fun(int[] arr) {}
void main() {
int[] a;
a.fun();
}
Arrays' .reverse, .sort and others were added in 0.24, but I
can't find a download for anything before 0.50.
--
Simen
Re: Whence came UFCS?
On Friday, July 27, 2018 03:41:29 Sameer Pradhan via Digitalmars-d wrote: > In the end I thought I might as well dump my thoughts on the D > forum and hear straight from the horse's (or horses') > mouth(s)---so to speak. It evolved out of D's member function call syntax for arrays - basically, for years before we had UFCS in D, we had UFCS for arrays. However, when and how that was added to arrays, I don't know. I don't recall it ever not being in the language, but I never used D1, and I don't know if it had it. At minimum, it's been in D since early D2, if not much earlier. I'd have to do a lot of spelunking through old releases to figure out when it was added. Certainly, the origins of UFCS in D do not come from making it possible to extend user-defined types with member functions. It comes from wanting member function call syntax when using arrays (probably aimed primarily at strings, but I don't know). It's just that later it was proposed to extend it so that it would work with any type and thus make the member function call syntax universal. - Jonathan M Davis
Re: Whence came UFCS?
On Friday, 27 July 2018 at 03:41:29 UTC, Sameer Pradhan wrote: During our Boston D Meetup today, we went through and deconstructed Walter's wonderfully elegant blog post from 2012 called "Component Programming in D" [...] Extension methods were added to C# 3.0 in 2007, UFCS was discussed as a generalization of the concept to free functions at that year's DConf, fully implemented years later: https://forum.dlang.org/thread/htjuut$av2$1...@digitalmars.com
Re: Whence came UFCS?
On Friday, 27 July 2018 at 03:41:29 UTC, Sameer Pradhan wrote: During our Boston D Meetup today, we went through and deconstructed Walter's wonderfully elegant blog post from 2012 called "Component Programming in D" [...] I remember reading somewhere that it's inspired from Nim. I might be wrong.
