www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Pure functions in D

reply Walter Bright <newshound1 digitalmars.com> writes:
http://www.reddit.com/r/programming/comments/72r6q/walter_bright_pure_functions_in_d/
Sep 22 2008
next sibling parent reply Knud Soerensen <4tuu4k002 sneakemail.com> writes:
Walter Bright wrote:
 http://www.reddit.com/r/programming/comments/72r6q/walter_bright_
ure_functions_in_d/ 
 

When are pure functions coming to dmd ? -- Crowdnews.eu - a social news site based on sharing instead of voting. Follow me on CrowdNews http://crowdnews.eu/users/addGuide/42/
Sep 22 2008
parent reply Walter Bright <newshound1 digitalmars.com> writes:
Knud Soerensen wrote:
 When are pure functions coming to dmd ?

They're about half-implemented. Given the unexpected huge interest in this, I'll have to bump up the priority!
Sep 22 2008
parent Jason House <jason.james.house gmail.com> writes:
Walter Bright Wrote:

 Knud Soerensen wrote:
 When are pure functions coming to dmd ?

They're about half-implemented. Given the unexpected huge interest in this, I'll have to bump up the priority!

Cool. That with TLS and a GC that doesn't block all threads and I'm switching to D2.
Sep 22 2008
prev sibling next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Walter:
 http://www.reddit.com/r/programming/comments/72r6q/walter_bright_pure_functions_in_d/

It's an interesting read, a little refinement of things we have already started discussing. This page shows that gcc too has the "pure" attribute, for the same purpose (but the GCC compiler has to trust the programmer much more): http://gcc.gnu.org/onlinedocs/gcc-4.3.0//gcc/Function-Attributes.html
(Invariant means immutable.)<

This specification, near the top of the article, that tells that a word means something else is a WARNING SIGN large as a wall that tells that that name is wrong and it has to change. Now I think D2 will sooner of later have to use the "immutable" word instead, as Python and Java communities too use.
Parameters to a pure function can be mutable, but calls cannot be cached or
executed asynchronously if the arguments contain any references to mutable
data.<

I don't understand how can such function be pure.
A pure function can throw an exception (purity does not imply nothrow).<

At the moment I think this the trickier decision of the whole pure stuff. This has to be chosen wisely, because a function that can throw isn't really pure. The situation is messy. It may be better for pure functions to never throw exceptions... This topic needs more thinking, with the help from the people of the functional crowd (Lambda the Ultimate) because otherwise there's a high risk of creating half-baked stuff as the closures in D2 (lot of people want a way to not allocate data on the heap. I think this can be solved making them allocate data on the heap by default, unless the programmer explicitly chooses otherwise, for example adding a "scope" statement before the closure). int x = foo(3) + bar[foo(3)]; need only execute foo(3) once. If foo can throw exceptions that's not true anymore, I think.
They can be hot swapped (meaning replaced at runtime), because they do not rely
on any global initialization or termination state.<

This sounds true and interesting, but what can it be used/useful for? ----------- Bill Baxter:
Glad to see that "const" args will be OK for pure functions, too. Not just
"invariant" as was originally announced. That will certainly make pure
functions in D much more useful.<

I don't understand (probably because I don't remember what 'const' exactly means here). millstone:
Also, what if a parameter to a pure function is marked lazy?<

Interesting question. I think the lazy callable can be accepted (at compile time) only if it wraps an immutable value or a pure function. Bye, bearophile
Sep 22 2008
next sibling parent reply Brian Palmer <d brian.codekitchen.net> writes:
bearophile Wrote:

(Invariant means immutable.)<

This specification, near the top of the article, that tells that a word means something else is a WARNING SIGN large as a wall that tells that that name is wrong and it has to change. Now I think D2 will sooner of later have to use the "immutable" word instead, as Python and Java communities too use.

That's exactly what went through my head when I saw this line of the article and I agree 100%, invariant needs to change to immutable in D2 before it becomes too late.
A pure function can throw an exception (purity does not imply nothrow).<


Since this wasn't touched on in the article, I want to point out that Haskell allows "pure functions" to throw exceptions, but not catch them. We need the same limitation in D2 pure functions -- since the exceptions can only be caught in impure code, it's OK that the pure function threw instead of returning. What can't happen is we can't have pure functions catching exceptions, since they can then return a different value when, for example, an out-of-memory exception is thrown. -- Brian
Sep 22 2008
next sibling parent Jacob Carlborg <doobnet gmail.com> writes:
Brian Palmer wrote:
 bearophile Wrote:
 
 (Invariant means immutable.)<


That's exactly what went through my head when I saw this line of the article and I agree 100%, invariant needs to change to immutable in D2 before it becomes too late.

I completely agree. In every document/article I've read about the const system in D and where it says "invariant" it's explained to mean immutable, so why not just change the keyword.
Sep 22 2008
prev sibling next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Brian Palmer:

 Since this wasn't touched on in the article, I want to point out that Haskell
allows "pure functions" to throw exceptions, but not catch them. We need the
same limitation in D2 pure functions -- since the exceptions can only be caught
in impure code, it's OK that the pure function threw instead of returning. What
can't happen is we can't have pure functions catching exceptions, since they
can then return a different value when, for example, an out-of-memory exception
is thrown.

This is quite interesting and it has some consequences. So a pure function can call another pure function only if the second one can't throw? Pure functions can be recursive (because if the stack finishes all the program stops with an error). So recursive pure functions can't throw exceptions? :-) Now I am sure that some knowledge of Haskell may help the design of the functional parts of D. ---------------- Walter says on Reddit:
There's also nothrow, which would specify that the function also did not throw.<

But then you have to write function signatures as: nothrow pure int foo(int x, const int[] a) {...} That looks a bit long to write. ---------------- Walter:
Functional programming capability is an exciting addition to imperative
programming languages.<

I agree. A general comment: functional programming (like OOP) doesn't work in vacuum. Computer languages are like ecologies of many interacting syntaxes. So for some functional programming capability to "survive" well in one of such ecologies several other parts of that ecology have to be fit. To make the usage of FP capabilities handy/good enough to be actually used several other things in a compiler/language have to be fit, like: - Good closures - A very compact syntax for delegates/closures. In Haskell and other FP languages you can see how you can even turn operators into functions in a very short space. - Some type inference, because types tend to become quite convoluted, etc. FP languages have type systems that are much more complex than the currend D one (you don't need to look at Haskell type system, eve, lesser FP languages fit the bill). - Some higher-order functions with a short and flexible syntax, like folds, maps, filters you can find in most FP languages, list comprehensions, etc that in various forms you can find in Python, Ruby, Haskell, etc. - Good management of operator precedence. - Good management of lazy iterables, for example like the presence of the len() function of my libs that returns the length of both eager and lazy iterables, etc. D already has some/part of those things and I am not saying that you need all of them to program in a functional style. In truth you can probably have FP even without all of them. But then the functional programming itself become awkward, feels unnatural, or that requires too much code, and in the end it becomes used very little. So I can already use something like (this is just for show, not working): map((int i){ return op(i)+op(i); }, xfilter((int i){ ....}, iterable))); but it's too much unreadable, so it becomes worse than a normal for loop. While with a Python (or Haskell, or even Ruby) syntax you can do the same thing in a readable enough way, so programmers feel encouraged to actually use functional constructs. This is why syntax matters. Note that for a short syntax to work, the compiler may need to perform more type inferencing, and this in turn may require a a bit more powerful type system... So to make FP in D actually usable a more powerful type system (plus some shorter/sugared syntax) may be needed. I don't know, we'll see. Bye, bearophile
Sep 22 2008
next sibling parent reply Sergey Gromov <snake.scaly gmail.com> writes:
bearophile <bearophileHUGS lycos.com> wrote:
 Since this wasn't touched on in the article, I want to point out
 that Haskell allows "pure functions" to throw exceptions, but not
 catch them.

This is quite interesting and it has some consequences. So a pure function can call another pure function only if the second one can't throw?

I cannot see how this follows. If a function calls another function that may throw, it doesn't automatically make it catch. So the call may be of any depth, and an exception may be thrown at any level. You just not allowed to try/catch, nor various forms of scope.
Sep 22 2008
parent Brian Palmer <d brian.codekitchen.net> writes:
Sergey Gromov Wrote:

 bearophile <bearophileHUGS lycos.com> wrote:
 Since this wasn't touched on in the article, I want to point out
 that Haskell allows "pure functions" to throw exceptions, but not
 catch them.

This is quite interesting and it has some consequences. So a pure function can call another pure function only if the second one can't throw?

I cannot see how this follows. If a function calls another function that may throw, it doesn't automatically make it catch. So the call may be of any depth, and an exception may be thrown at any level. You just not allowed to try/catch, nor various forms of scope.

Yes, Sergey has it right here.
Sep 22 2008
prev sibling next sibling parent bearophile <bearophileHUGS lycos.com> writes:
bearophile:
 - Good closures
 - A very compact syntax for delegates/closures. In Haskell and other FP
languages you can see how you can even turn operators into functions in a very
short space.

In that list I have missed a quite important thing: the compiler has to know those syntax constructs and needs to know ways to simplify them, so they become compiled efficiently, otherwise the programmer of a system language will not be encouraged to use them in some parts of the code. The Haskell compiler has several ways to simplify and compile the code in an efficient way. Other compilers like Scheme Stalin show that there are lot of things that can be done to produce efficient assembly from FP-style code. Bye, bearophile
Sep 22 2008
prev sibling parent renoX <renosky free.fr> writes:
bearophile a écrit :
 Brian Palmer:
 
 Since this wasn't touched on in the article, I want to point out
 that Haskell allows "pure functions" to throw exceptions, but not
 catch them. We need the same limitation in D2 pure functions --
 since the exceptions can only be caught in impure code, it's OK
 that the pure function threw instead of returning. What can't
 happen is we can't have pure functions catching exceptions, since
 they can then return a different value when, for example, an
 out-of-memory exception is thrown.


Mmmm, "pure" functions are not pure with respect to 'out-of-memory' exceptions ie depending on the amount of memory available a pure function might return a value or might return an out-of-memory exception.. IMHO this must be the same in Haskell: I don't see how it could be different.. But this is okay: programs cannot be expected to have the same behaviour when there is or isn't free memory available. So pure functions are not fully identical to math pure functions in this respect.. BR, RenoX
 
 This is quite interesting and it has some consequences. So a pure
 function can call another pure function only if the second one can't
 throw? Pure functions can be recursive (because if the stack finishes
 all the program stops with an error). So recursive pure functions
 can't throw exceptions? :-) Now I am sure that some knowledge of
 Haskell may help the design of the functional parts of D.
 
 ----------------
 
 Walter says on Reddit:
 
 There's also nothrow, which would specify that the function also
 did not throw.<

But then you have to write function signatures as: nothrow pure int foo(int x, const int[] a) {...} That looks a bit long to write. ---------------- Walter:
 Functional programming capability is an exciting addition to
 imperative programming languages.<

I agree. A general comment: functional programming (like OOP) doesn't work in vacuum. Computer languages are like ecologies of many interacting syntaxes. So for some functional programming capability to "survive" well in one of such ecologies several other parts of that ecology have to be fit. To make the usage of FP capabilities handy/good enough to be actually used several other things in a compiler/language have to be fit, like: - Good closures - A very compact syntax for delegates/closures. In Haskell and other FP languages you can see how you can even turn operators into functions in a very short space. - Some type inference, because types tend to become quite convoluted, etc. FP languages have type systems that are much more complex than the currend D one (you don't need to look at Haskell type system, eve, lesser FP languages fit the bill). - Some higher-order functions with a short and flexible syntax, like folds, maps, filters you can find in most FP languages, list comprehensions, etc that in various forms you can find in Python, Ruby, Haskell, etc. - Good management of operator precedence. - Good management of lazy iterables, for example like the presence of the len() function of my libs that returns the length of both eager and lazy iterables, etc. D already has some/part of those things and I am not saying that you need all of them to program in a functional style. In truth you can probably have FP even without all of them. But then the functional programming itself become awkward, feels unnatural, or that requires too much code, and in the end it becomes used very little. So I can already use something like (this is just for show, not working): map((int i){ return op(i)+op(i); }, xfilter((int i){ ....}, iterable))); but it's too much unreadable, so it becomes worse than a normal for loop. While with a Python (or Haskell, or even Ruby) syntax you can do the same thing in a readable enough way, so programmers feel encouraged to actually use functional constructs. This is why syntax matters. Note that for a short syntax to work, the compiler may need to perform more type inferencing, and this in turn may require a a bit more powerful type system... So to make FP in D actually usable a more powerful type system (plus some shorter/sugared syntax) may be needed. I don't know, we'll see. Bye, bearophile

Sep 26 2008
prev sibling parent reply "Bent Rasmussen" <IncredibleShrinkingSphere Gmail.com> writes:
I find invariant more natural and immutable more clumsy. On the other hand, 
why not make invariant the default and be done with it. The trend will go in 
that direction, the introduction of the entire const correctness stuff is an 
indication of where things are going. Better optimizable and safe by default 
than "invariant-with-effort".

Bent


"Brian Palmer" <d brian.codekitchen.net> skrev i meddelelsen 
news:gb89pv$1l31$1 digitalmars.com...
 bearophile Wrote:

(Invariant means immutable.)<

This specification, near the top of the article, that tells that a word means something else is a WARNING SIGN large as a wall that tells that that name is wrong and it has to change. Now I think D2 will sooner of later have to use the "immutable" word instead, as Python and Java communities too use.

That's exactly what went through my head when I saw this line of the article and I agree 100%, invariant needs to change to immutable in D2 before it becomes too late.
A pure function can throw an exception (purity does not imply nothrow).<


Since this wasn't touched on in the article, I want to point out that Haskell allows "pure functions" to throw exceptions, but not catch them. We need the same limitation in D2 pure functions -- since the exceptions can only be caught in impure code, it's OK that the pure function threw instead of returning. What can't happen is we can't have pure functions catching exceptions, since they can then return a different value when, for example, an out-of-memory exception is thrown. -- Brian

Sep 24 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Bent Rasmussen:
 I find invariant more natural and immutable more clumsy.

Yet, it seems that's the right terminology: http://en.wikipedia.org/wiki/Immutable_object
 On the other hand, why not make invariant the default and be 
 done with it. The trend will go in that direction

I agree that this seems where the trend goes, but: - I think you can't change the language too much. D is too much based on mutable data to change it all now. So I think it may be better to invent a new language that uses mostly immutable data (Scala?) instead of turning D inside-out. I presume Walter too will invent other languages when D is finished, or even along the way. - While today some languages show the advantages of immutable data, there's probably space still for a niche with a language with mostly mutable data structures. D is for that niche (today that niche is very large but it may shrink in the following years). Bye, bearophile
Sep 24 2008
parent reply "Bent Rasmussen" <IncredibleShrinkingSphere Gmail.com> writes:
 I agree that this seems where the trend goes, but:
 - I think you can't change the language too much. D is too much based on 
 mutable data to change it all now. So I think it may be better to invent a 
 new language that uses mostly immutable data (Scala?) instead of turning D 
 inside-out. I presume Walter too will invent other languages when D is 
 finished, or even along the way.
 - While today some languages show the advantages of immutable data, 
 there's probably space still for a niche with a language with mostly 
 mutable data structures. D is for that niche (today that niche is very 
 large but it may shrink in the following years).

It's not about either or. The philosphy of D, says that there is no religion. Nevertheless there is still bias. The bias is whitnessed by public/private-by-default, variant/const/invariant-by-default, pure/impure-by-default and shared/unshared-by-default. I say: move defaults towards the sensible future. This is not the same as a religious outlawing of features. There is still D1 for the past. Maybe an IDE could be made to "reverse" the default so it looks like the opposite.
 Bye,
 bearophile 

Sep 24 2008
parent reply "Bent Rasmussen" <IncredibleShrinkingSphere Gmail.com> writes:
- for the record: public counts as sensible: in a safe world there's 
(almost) no reason to hide :-)

Bent


"Bent Rasmussen" <IncredibleShrinkingSphere Gmail.com> skrev i meddelelsen 
news:gbedek$mvf$1 digitalmars.com...
 I agree that this seems where the trend goes, but:
 - I think you can't change the language too much. D is too much based on 
 mutable data to change it all now. So I think it may be better to invent 
 a new language that uses mostly immutable data (Scala?) instead of 
 turning D inside-out. I presume Walter too will invent other languages 
 when D is finished, or even along the way.
 - While today some languages show the advantages of immutable data, 
 there's probably space still for a niche with a language with mostly 
 mutable data structures. D is for that niche (today that niche is very 
 large but it may shrink in the following years).

It's not about either or. The philosphy of D, says that there is no religion. Nevertheless there is still bias. The bias is whitnessed by public/private-by-default, variant/const/invariant-by-default, pure/impure-by-default and shared/unshared-by-default. I say: move defaults towards the sensible future. This is not the same as a religious outlawing of features. There is still D1 for the past. Maybe an IDE could be made to "reverse" the default so it looks like the opposite.
 Bye,
 bearophile


Sep 24 2008
parent renoX <renosky free.fr> writes:
Bent Rasmussen a écrit :
 - for the record: public counts as sensible: in a safe world there's 
 (almost) no reason to hide :-)

I disagree: public isn't about being safe and private about being hidden, it's a "making part of the interface" choice that I'll have to support till the end of times choice. There are quite a few maintainability guides which advise to makes small well-defined interface, so in this mindset public shouldn't be the default. RenoX
 
 Bent
 
 
 "Bent Rasmussen" <IncredibleShrinkingSphere Gmail.com> skrev i 
 meddelelsen news:gbedek$mvf$1 digitalmars.com...
 I agree that this seems where the trend goes, but:
 - I think you can't change the language too much. D is too much based 
 on mutable data to change it all now. So I think it may be better to 
 invent a new language that uses mostly immutable data (Scala?) 
 instead of turning D inside-out. I presume Walter too will invent 
 other languages when D is finished, or even along the way.
 - While today some languages show the advantages of immutable data, 
 there's probably space still for a niche with a language with mostly 
 mutable data structures. D is for that niche (today that niche is 
 very large but it may shrink in the following years).

It's not about either or. The philosphy of D, says that there is no religion. Nevertheless there is still bias. The bias is whitnessed by public/private-by-default, variant/const/invariant-by-default, pure/impure-by-default and shared/unshared-by-default. I say: move defaults towards the sensible future. This is not the same as a religious outlawing of features. There is still D1 for the past. Maybe an IDE could be made to "reverse" the default so it looks like the opposite.
 Bye,
 bearophile



Sep 26 2008
prev sibling next sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"bearophile" wrote
 Walter:
Parameters to a pure function can be mutable, but calls cannot be cached 
or executed asynchronously if the arguments contain any references to 
mutable data.<

I don't understand how can such function be pure.

It can't be. I think Walter made a mistake there. Otherwise, you could pass data that another thread changes while in the middle of using it. Maybe he meant that a pure function can *return* mutable data? Then 'new' could be considered pure? Another possibility is that Walter is assuming the shared/unshared paradigm is in place. Another possibility is that pure functions that accept mutable parameters can only be called from other pure functions, therefore you are guaranteed that the data is not being used in any other thread. Who knows what he was thinking ;) But the current article statement is definitely wrong without clarification. -Steve
Sep 22 2008
parent reply Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
Steven Schveighoffer wrote:
 Another possibility is that pure functions that accept mutable parameters 
 can only be called from other pure functions, therefore you are guaranteed 
 that the data is not being used in any other thread.
 

I'm almost certain this is the intended behavior, with the addition that you can also call that same pure function from an unpure one, only then, the compiler will treat the function as being unpure. This is the gist of the "partially pure"/"contextually pure" idea: a function is considered pure or not dependent on the immutability of the arguments with which it's called. This consideration "happens" on every call. Since the optimizations to pure functions are made on the call, and not on the body of the function, this is perfectly ok. I don't see any other behavior that isn't either broken, or more limited in functionality. Also note that in the case where the given (contextually) pure "foo" function is called from a pure function, the fact that foo is called from a pure function only guarantees that the arguments are not changed by anyone else when foo executes, but foo must still be treated as unpure. Example: pure void foo(int* iptr) { (*iptr)++; // side effect } pure int func() { int a = 1; foo(&a); // side-effect, cannot optimize this call foo(&a); // side-effect, cannot optimize this call return a; } // Yet func is allways pure. -- Bruno Medeiros - Software Developer, MSc. in CS/E graduate http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Sep 23 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Bruno Medeiros" wrote
 Steven Schveighoffer wrote:
 Another possibility is that pure functions that accept mutable parameters 
 can only be called from other pure functions, therefore you are 
 guaranteed that the data is not being used in any other thread.

I'm almost certain this is the intended behavior, with the addition that you can also call that same pure function from an unpure one, only then, the compiler will treat the function as being unpure. This is the gist of the "partially pure"/"contextually pure" idea: a function is considered pure or not dependent on the immutability of the arguments with which it's called. This consideration "happens" on every call. Since the optimizations to pure functions are made on the call, and not on the body of the function, this is perfectly ok. I don't see any other behavior that isn't either broken, or more limited in functionality.

One of the benefits that Walter and Andrei's original purity plan provided was that you could always assume that pure functions did not have to worry about threading issues. I think allowing a pure function that takes mutable arguments to be callable from an unpure function removes that benefit. I hope this isn't the case. Of course, if shared/unshared is implemented, and pure functions are only allowed to be passed 'unshared' mutable data, then the benefit is still on. I'm just unclear on what Walter is planning. I admit I didn't read the whole article, I just saw that quote and thought 'hm... that looks wrong'.
 Also note that in the case where the given (contextually) pure "foo" 
 function is called from a pure function, the fact that foo is called from 
 a pure function only guarantees that the arguments are not changed by 
 anyone else when foo executes, but foo must still be treated as unpure. 
 Example:

 pure void foo(int* iptr) {
   (*iptr)++; // side effect
 }


 pure int func() {
   int a = 1;
   foo(&a); // side-effect, cannot optimize this call
   foo(&a); // side-effect, cannot optimize this call
   return a;
 }
 // Yet func is allways pure.

I agree with you, partially pure functions can be called from pure functions with limited optimization. But if you allow foo to be called from an unpure function you could have this problem: int func2() { static int a = 1; foo(&a); } Now, if 2 threads are calling func2, you have race conditions and threading issues in foo, which seems to be a major concern that W/A were trying to address. And I hope they do address it, it was the one huge benefit I saw from pure functions. -Steve
Sep 23 2008
parent reply Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
Steven Schveighoffer wrote:
 "Bruno Medeiros" wrote
 Steven Schveighoffer wrote:
 Another possibility is that pure functions that accept mutable parameters 
 can only be called from other pure functions, therefore you are 
 guaranteed that the data is not being used in any other thread.

you can also call that same pure function from an unpure one, only then, the compiler will treat the function as being unpure. This is the gist of the "partially pure"/"contextually pure" idea: a function is considered pure or not dependent on the immutability of the arguments with which it's called. This consideration "happens" on every call. Since the optimizations to pure functions are made on the call, and not on the body of the function, this is perfectly ok. I don't see any other behavior that isn't either broken, or more limited in functionality.

One of the benefits that Walter and Andrei's original purity plan provided was that you could always assume that pure functions did not have to worry about threading issues. I think allowing a pure function that takes mutable arguments to be callable from an unpure function removes that benefit. I hope this isn't the case. Of course, if shared/unshared is implemented, and pure functions are only allowed to be passed 'unshared' mutable data, then the benefit is still on. I'm just unclear on what Walter is planning. I admit I didn't read the whole article, I just saw that quote and thought 'hm... that looks wrong'.
 Also note that in the case where the given (contextually) pure "foo" 
 function is called from a pure function, the fact that foo is called from 
 a pure function only guarantees that the arguments are not changed by 
 anyone else when foo executes, but foo must still be treated as unpure. 
 Example:

 pure void foo(int* iptr) {
   (*iptr)++; // side effect
 }


 pure int func() {
   int a = 1;
   foo(&a); // side-effect, cannot optimize this call
   foo(&a); // side-effect, cannot optimize this call
   return a;
 }
 // Yet func is allways pure.

I agree with you, partially pure functions can be called from pure functions with limited optimization. But if you allow foo to be called from an unpure function you could have this problem: int func2() { static int a = 1; foo(&a); } Now, if 2 threads are calling func2, you have race conditions and threading issues in foo, which seems to be a major concern that W/A were trying to address. And I hope they do address it, it was the one huge benefit I saw from pure functions. -Steve

Yes, you can have race and threading issues in foo with that call. But what is the alternative? In the first pure system (in andrei's presentation) that call would not be allowed. So what you would do? You'd have to write another function just like foo (the same code), but that is not marked pure, and use that. But you'd still have the same synchronization problems. If you don't want to have those issues, write a foo function that takes invariant parameters. The partially pure functions (functions with mutable parameters), which basically have localized side-effects and are deterministic when called from "really-pure" functions, are not there to provide the full effects of really-pure functions. They are just a convenience for the writing the really-pure functions. (Also, I'd reckon most static/global functions will be partially pure.) -- Bruno Medeiros - Software Developer, MSc. in CS/E graduate http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Sep 24 2008
parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Bruno Medeiros" wrote
 Steven Schveighoffer wrote:
 "Bruno Medeiros" wrote
 Steven Schveighoffer wrote:
 Another possibility is that pure functions that accept mutable 
 parameters can only be called from other pure functions, therefore you 
 are guaranteed that the data is not being used in any other thread.

you can also call that same pure function from an unpure one, only then, the compiler will treat the function as being unpure. This is the gist of the "partially pure"/"contextually pure" idea: a function is considered pure or not dependent on the immutability of the arguments with which it's called. This consideration "happens" on every call. Since the optimizations to pure functions are made on the call, and not on the body of the function, this is perfectly ok. I don't see any other behavior that isn't either broken, or more limited in functionality.

One of the benefits that Walter and Andrei's original purity plan provided was that you could always assume that pure functions did not have to worry about threading issues. I think allowing a pure function that takes mutable arguments to be callable from an unpure function removes that benefit. I hope this isn't the case. Of course, if shared/unshared is implemented, and pure functions are only allowed to be passed 'unshared' mutable data, then the benefit is still on. I'm just unclear on what Walter is planning. I admit I didn't read the whole article, I just saw that quote and thought 'hm... that looks wrong'.
 Also note that in the case where the given (contextually) pure "foo" 
 function is called from a pure function, the fact that foo is called 
 from a pure function only guarantees that the arguments are not changed 
 by anyone else when foo executes, but foo must still be treated as 
 unpure. Example:

 pure void foo(int* iptr) {
   (*iptr)++; // side effect
 }


 pure int func() {
   int a = 1;
   foo(&a); // side-effect, cannot optimize this call
   foo(&a); // side-effect, cannot optimize this call
   return a;
 }
 // Yet func is allways pure.

I agree with you, partially pure functions can be called from pure functions with limited optimization. But if you allow foo to be called from an unpure function you could have this problem: int func2() { static int a = 1; foo(&a); } Now, if 2 threads are calling func2, you have race conditions and threading issues in foo, which seems to be a major concern that W/A were trying to address. And I hope they do address it, it was the one huge benefit I saw from pure functions. -Steve

Yes, you can have race and threading issues in foo with that call. But what is the alternative? In the first pure system (in andrei's presentation) that call would not be allowed. So what you would do? You'd have to write another function just like foo (the same code), but that is not marked pure, and use that. But you'd still have the same synchronization problems. If you don't want to have those issues, write a foo function that takes invariant parameters. The partially pure functions (functions with mutable parameters), which basically have localized side-effects and are deterministic when called from "really-pure" functions, are not there to provide the full effects of really-pure functions. They are just a convenience for the writing the really-pure functions. (Also, I'd reckon most static/global functions will be partially pure.)

It creates a definitive line which can be used to determine whether or not I need to worry about threading. Having the compiler enforce this I see as a huge benefit. I was hoping to keep that line. If the compiler enforces that the parameters to foo must be local, either by implementing the shared/unshared paradigm or only allowing calling from other pure functions, then the line still exists. It appears that that is the case, as evidenced from other posts. -Steve
Sep 24 2008
prev sibling next sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
bearophile wrote:
 They can be hot swapped (meaning replaced at runtime), because they
 do not rely on any global initialization or termination state.<

This sounds true and interesting, but what can it be used/useful for?

I've heard mention many times that languages like Erlang allow hot swapping meaning the software can be upgraded without bringing the system to a halt first.
Sep 22 2008
parent reply downs <default_357-line yahoo.de> writes:
Denis Koroskin wrote:
 On Tue, 23 Sep 2008 02:24:10 +0400, Walter Bright
 <newshound1 digitalmars.com> wrote:
 
 bearophile wrote:
 They can be hot swapped (meaning replaced at runtime), because they
 do not rely on any global initialization or termination state.<


I've heard mention many times that languages like Erlang allow hot swapping meaning the software can be upgraded without bringing the system to a halt first.

Yes, Java has some support of hot-swapping, too. Imagine you have a MMORPG server. Applying a patch or adding some additional content is a daily event. Doing so without disconnecting the people (especially if there are thousands of player online) is desirable but hardly available in C/C++.

I did that with an IRC bot a while back. Just build a new executable, halt all your running tasks, dump the system state to a file (*including socket handles*), use the exec system call to replace the process with the new executable, and read the system state back, replacing handles as you go. No dropped connections.
Sep 23 2008
next sibling parent Leandro Lucarella <llucax gmail.com> writes:
downs, el 24 de septiembre a las 08:52 me escribiste:
 Denis Koroskin wrote:
 On Tue, 23 Sep 2008 02:24:10 +0400, Walter Bright
 <newshound1 digitalmars.com> wrote:
 
 bearophile wrote:
 They can be hot swapped (meaning replaced at runtime), because they
 do not rely on any global initialization or termination state.<


I've heard mention many times that languages like Erlang allow hot swapping meaning the software can be upgraded without bringing the system to a halt first.

Yes, Java has some support of hot-swapping, too. Imagine you have a MMORPG server. Applying a patch or adding some additional content is a daily event. Doing so without disconnecting the people (especially if there are thousands of player online) is desirable but hardly available in C/C++.

I did that with an IRC bot a while back. Just build a new executable, halt all your running tasks, dump the system state to a file (*including socket handles*), use the exec system call to replace the process with the new executable, and read the system state back, replacing handles as you go. No dropped connections.

Using dynamic libraries with dlopen can be useful for hot-swapping too. -- Leandro Lucarella (luca) | Blog colectivo: http://www.mazziblog.com.ar/blog/ ---------------------------------------------------------------------------- GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145 104C 949E BFB6 5F5A 8D05) ---------------------------------------------------------------------------- El trabajo no sólo tara, sino que tarará y seguirá tararando. -- Ricardo Vaporeso
Sep 24 2008
prev sibling parent Walter Bright <newshound1 digitalmars.com> writes:
downs wrote:
 Just build a new executable, halt all your running tasks, dump the
 system state to a file (*including socket handles*), use the exec
 system call to replace the process with the new executable, and read
 the system state back, replacing handles as you go.
 
 No dropped connections.

I've done that with C/C++ code before. The trouble is finding *all* of the state that matters in order to save/restore it. It can be done, but it is tedious and very error prone. But with pure functions, it's a no-brainer.
Sep 26 2008
prev sibling next sibling parent "Denis Koroskin" <2korden gmail.com> writes:
On Tue, 23 Sep 2008 02:12:58 +0400, Steven Schveighoffer  
<schveiguy yahoo.com> wrote:

 "bearophile" wrote
 Walter:
 Parameters to a pure function can be mutable, but calls cannot be  
 cached
 or executed asynchronously if the arguments contain any references to
 mutable data.<

I don't understand how can such function be pure.

It can't be. I think Walter made a mistake there. Otherwise, you could pass data that another thread changes while in the middle of using it. Maybe he meant that a pure function can *return* mutable data? Then 'new' could be considered pure? Another possibility is that Walter is assuming the shared/unshared paradigm is in place. Another possibility is that pure functions that accept mutable parameters can only be called from other pure functions, therefore you are guaranteed that the data is not being used in any other thread. Who knows what he was thinking ;) But the current article statement is definitely wrong without clarification. -Steve

I think he meant both:
 Pure functions do not require synchronization for use by multiple  
 threads,
 because their data is all either *thread local* or immutable.

Given that an implicit unshared attribute is attached to mutable variable arguments such functions are definitely pure: pure void inplace_tolower(char[] str); // yes! pure Foo bar() { char[] str = "HELLO".dup; inplace_tolower(str); ... }
Sep 22 2008
prev sibling next sibling parent "Denis Koroskin" <2korden gmail.com> writes:
On Tue, 23 Sep 2008 02:24:10 +0400, Walter Bright  
<newshound1 digitalmars.com> wrote:

 bearophile wrote:
 They can be hot swapped (meaning replaced at runtime), because they
 do not rely on any global initialization or termination state.<


I've heard mention many times that languages like Erlang allow hot swapping meaning the software can be upgraded without bringing the system to a halt first.

Yes, Java has some support of hot-swapping, too. Imagine you have a MMORPG server. Applying a patch or adding some additional content is a daily event. Doing so without disconnecting the people (especially if there are thousands of player online) is desirable but hardly available in C/C++.
Sep 22 2008
prev sibling next sibling parent "Denis Koroskin" <2korden gmail.com> writes:
On Wed, 24 Sep 2008 08:25:59 +0400, Steven Schveighoffer  
<schveiguy yahoo.com> wrote:

 "Bruno Medeiros" wrote
 Steven Schveighoffer wrote:
 Another possibility is that pure functions that accept mutable  
 parameters
 can only be called from other pure functions, therefore you are
 guaranteed that the data is not being used in any other thread.



 I agree with you, partially pure functions can be called from pure  
 functions
 with limited optimization.  But if you allow foo to be called from an  
 unpure
 function you could have this problem:

 int func2()
 {
     static int a = 1;
     foo(&a);
 }

 Now, if 2 threads are calling func2, you have race conditions and  
 threading
 issues in foo, which seems to be a major concern that W/A were trying to
 address.  And I hope they do address it, it was the one huge benefit I  
 saw
 from pure functions.

 -Steve

No race conditions if "a" is unshared and Walter mentioned that pure functions allowed thread-local mutable arguments only.
Sep 24 2008
prev sibling parent "Bruce Adams" <tortoise_74 yeah.who.co.uk> writes:
On Wed, 24 Sep 2008 13:15:12 +0100, Leandro Lucarella <llucax gmail.com>  
wrote:

 downs, el 24 de septiembre a las 08:52 me escribiste:
 Denis Koroskin wrote:
 On Tue, 23 Sep 2008 02:24:10 +0400, Walter Bright
 <newshound1 digitalmars.com> wrote:

 bearophile wrote:
 They can be hot swapped (meaning replaced at runtime), because they
 do not rely on any global initialization or termination state.<




 I've heard mention many times that languages like Erlang allow hot
 swapping meaning the software can be upgraded without bringing the
 system to a halt first.

Yes, Java has some support of hot-swapping, too. Imagine you have a MMORPG server. Applying a patch or adding some additional content is a daily event. Doing so without disconnecting

 people (especially if there are thousands of player online) is  

 but hardly available in C/C++.

I did that with an IRC bot a while back. Just build a new executable, halt all your running tasks, dump the system state to a file (*including socket handles*), use the exec system call to replace the process with the new executable, and read the system state back, replacing handles as you go. No dropped connections.

Using dynamic libraries with dlopen can be useful for hot-swapping too.

Also take a look at the purple book "Advanced C++ Programming" by Coplien.
Sep 25 2008
prev sibling next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Walter:

There will be no reasonable way for the programmer who expects a function to be
pure, to see if it actually is pure. If he does check (which might be
arbitrarilly difficult to do) and it is not pure, he has no reasonable way to
determine why the compiler thought it was impure.<

Just a little note: those "he" refer to a male programmer. The D language has a small community, so each person is precious, so it's better to not show sexual discrimination, and try to use a more sexual neutral language in public articles/documents. Bye, bearophile
Sep 22 2008
next sibling parent reply "Adam D. Ruppe" <destructionator gmail.com> writes:
On Mon, Sep 22, 2008 at 09:58:13AM -0400, bearophile wrote:
 Just a little note: those "he" refer to a male programmer. The D language has
a small community, so each person is precious, so it's better to not show
sexual discrimination, and try to use a more sexual neutral language in public
articles/documents.

"He" is technically proper English. When the gender is not known or doesn't matter, you use the male pronouns.
 
 Bye,
 bearophile

-- Adam D. Ruppe http://arsdnet.net
Sep 22 2008
next sibling parent reply Sean Kelly <sean invisibleduck.org> writes:
Adam D. Ruppe wrote:
 On Mon, Sep 22, 2008 at 09:58:13AM -0400, bearophile wrote:
 Just a little note: those "he" refer to a male programmer. The D language has
a small community, so each person is precious, so it's better to not show
sexual discrimination, and try to use a more sexual neutral language in public
articles/documents.

"He" is technically proper English. When the gender is not known or doesn't matter, you use the male pronouns.

Or the female pronouns. Common practice these days is to pick a gender for a particular section, but it's even accepted to switch genders in different sections so long as doing so isn't confusing to the reader. Sean
Sep 22 2008
parent reply Christopher Wright <dhasenan gmail.com> writes:
Sean Kelly wrote:
 Adam D. Ruppe wrote:
 On Mon, Sep 22, 2008 at 09:58:13AM -0400, bearophile wrote:
 Just a little note: those "he" refer to a male programmer. The D 
 language has a small community, so each person is precious, so it's 
 better to not show sexual discrimination, and try to use a more 
 sexual neutral language in public articles/documents.

"He" is technically proper English. When the gender is not known or doesn't matter, you use the male pronouns.

Or the female pronouns. Common practice these days is to pick a gender for a particular section, but it's even accepted to switch genders in different sections so long as doing so isn't confusing to the reader. Sean

It's also common, and has been for a few centuries, to use "they" in these situations. There was a prescriptivist movement not too long ago trying to deprecate that use of "they", but it hasn't been terribly successful.
Sep 22 2008
parent Sean Kelly <sean invisibleduck.org> writes:
Christopher Wright wrote:
 Sean Kelly wrote:
 Adam D. Ruppe wrote:
 On Mon, Sep 22, 2008 at 09:58:13AM -0400, bearophile wrote:
 Just a little note: those "he" refer to a male programmer. The D 
 language has a small community, so each person is precious, so it's 
 better to not show sexual discrimination, and try to use a more 
 sexual neutral language in public articles/documents.

"He" is technically proper English. When the gender is not known or doesn't matter, you use the male pronouns.

Or the female pronouns. Common practice these days is to pick a gender for a particular section, but it's even accepted to switch genders in different sections so long as doing so isn't confusing to the reader.

It's also common, and has been for a few centuries, to use "they" in these situations. There was a prescriptivist movement not too long ago trying to deprecate that use of "they", but it hasn't been terribly successful.

True enough. And I do use "they" from time to time, but I think it tends to be somewhat off-putting if used extensively. Sean
Sep 22 2008
prev sibling parent reply J Duncan <jtd514_ ameritech.net> writes:
Adam D. Ruppe wrote:
 On Mon, Sep 22, 2008 at 09:58:13AM -0400, bearophile wrote:
 Just a little note: those "he" refer to a male programmer. The D language has
a small community, so each person is precious, so it's better to not show
sexual discrimination, and try to use a more sexual neutral language in public
articles/documents.

"He" is technically proper English. When the gender is not known or doesn't matter, you use the male pronouns.
 Bye,
 bearophile


But then how else do you show that you are politically hip and sensitive to PC issues?
Sep 22 2008
parent reply "Saaa" <empty needmail.com> writes:
sie
hir
Sep 22 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Saaa Wrote:
 sie
 hir

Shi/hir/hirself are for hermaphrodite people, so I think they aren't much fit there. Bye, bearophile
Sep 22 2008
parent "Saaa" <empty needmail.com> writes:
Lol, didn't know damn furries stole them.
http://furry.wikia.com/wiki/Hermaphrodite
 Saaa Wrote:
 sie
 hir

Shi/hir/hirself are for hermaphrodite people, so I think they aren't much fit there. Bye, bearophile

Sep 23 2008
prev sibling next sibling parent reply BCS <ao pathlink.com> writes:
Reply to bearophile,

 Walter:
 
 There will be no reasonable way for the programmer who expects a
 function to be pure, to see if it actually is pure. If he does check
 (which might be arbitrarilly difficult to do) and it is not pure, he
 has no reasonable way to determine why the compiler thought it was
 impure.<
 

language has a small community, so each person is precious, so it's better to not show sexual discrimination, and try to use a more sexual neutral language in public articles/documents. Bye, bearophile

Ahh. One Of my pet peeves about the English language. Pronouns!. We have no gender neutral third person singular pronoun ('they' is plural and 'it' is an insult). But the fun one is second person plural. Bet all you'all can't tell me what the best one is... Oh Crud, just blew that one. :(
Sep 22 2008
parent reply Victor Tyurin <eaglux gmail.com> writes:
I think only stupid American feminists will tread word "he" as
"discrimination".
I'm sure that Russian girls-programmers just laugh when hear those
language perversions for sexual polit-correctness.
This is correct for all Russian girls/women, which i know and spoke...

Also, for persons speaking English badly (as me) it will be very
difficult to use correct USA-specific PC-words.

Don't be mad on this shit, i propose!


 Just a little note: those "he" refer to a male programmer. The D
 language has a small community, so each person is precious, so it's
 better to not show sexual discrimination, and try to use a more sexual
 neutral language in public articles/documents.

 Bye,
 bearophile

Ahh. One Of my pet peeves about the English language. Pronouns!. We have no gender neutral third person singular pronoun ('they' is plural and 'it' is an insult). But the fun one is second person plural. Bet all you'all can't tell me what the best one is... Oh Crud, just blew that one. :(

Sep 23 2008
next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Victor Tyurin:
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.

While adult women of other cultures/nations may be annoyed by your words. Bye, bearophile
Sep 23 2008
parent reply Victor Tyurin <eaglux gmail.com> writes:
We can't please every nation...
What if my nation/religion have "Dee" sacred word?
Should we rename D language to {some_GUID}, to never annoy any
nation/religion/etc?

Who cares about that feministic PC?
USA and Western Europe?
All ex-USSR space don't cares, most South America nations, Eastern
Europe too, i bet..
China, Japan, Korea - do trey care about this?  I think, no...

If some person, while reading technical texts, tries to find there some
"discrimination", i think, he/she will find it anyway.

"The pig will find the mud, anyway" - this is my (bad) translation of
Russian proverb.

Don't be a PC-extremist!

If you will follow that PC way, should you rewrite Holy Bible, for
example? Or, all pre-PC era writers, like Shakespeare, for example?



 Victor Tyurin:
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.

While adult women of other cultures/nations may be annoyed by your words. Bye, bearophile

Sep 24 2008
parent Victor Tyurin <eaglux gmail.com> writes:
And, anyway, this feminist PC is USA-specific only (maybe, Europe too,
not sure, but, anyway, not whole Europe).
The person of other culture just can't respect those PC language rules
properly, just because he don't knows those rules, and don't knows those
modern American culture issues...

 We can't please every nation...
 What if my nation/religion have "Dee" sacred word?
 Should we rename D language to {some_GUID}, to never annoy any
 nation/religion/etc?
 
 Who cares about that feministic PC?
 USA and Western Europe?

Sep 24 2008
prev sibling parent reply BCS <ao pathlink.com> writes:
Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.
 
 Don't be mad on this shit, i propose!
 

I find the gender neutral part funny as well, however once in a while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"
Sep 23 2008
next sibling parent reply Yigal Chripun <yigal100 gmail.com> writes:
BCS wrote:
 Reply to Victor,
 
 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.

 Don't be mad on this shit, i propose!

I find the gender neutral part funny as well, however once in a while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "
Sep 23 2008
parent reply Ary Borenszweig <ary esperanto.org.ar> writes:
Yigal Chripun wrote:
 BCS wrote:
 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.

 Don't be mad on this shit, i propose!

being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

I find it most interesting that four versions of "you" exist in hebrew, that are all combinations of "male/female" and "singular/plural".
Sep 23 2008
next sibling parent reply Yigal Chripun <yigal100 gmail.com> writes:
Ary Borenszweig wrote:
 Yigal Chripun wrote:
 BCS wrote:
 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.

 Don't be mad on this shit, i propose!

being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

I find it most interesting that four versions of "you" exist in hebrew, that are all combinations of "male/female" and "singular/plural".

Isn't it like this in most languages? at least I know that Russian has both singular and plural. actually I think I read once that English had the same distinction as well but it got deprecated or something.
Sep 23 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Yigal Chripun" wrote
 Ary Borenszweig wrote:
 Yigal Chripun wrote:
 BCS wrote:
 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.

 Don't be mad on this shit, i propose!

being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

I find it most interesting that four versions of "you" exist in hebrew, that are all combinations of "male/female" and "singular/plural".

Isn't it like this in most languages? at least I know that Russian has both singular and plural. actually I think I read once that English had the same distinction as well but it got deprecated or something.

Yes, in English version 2.023, gender specific 'you' was deprecated. If you wish to have a gender specific 'you', use enum: enum : you { she_you, he_you } -Steve
Sep 23 2008
parent reply Yigal Chripun <yigal100 gmail.com> writes:
Steven Schveighoffer wrote:
 "Yigal Chripun" wrote
 Ary Borenszweig wrote:
 Yigal Chripun wrote:
 BCS wrote:
 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.

 Don't be mad on this shit, i propose!

being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

that are all combinations of "male/female" and "singular/plural".

at least I know that Russian has both singular and plural. actually I think I read once that English had the same distinction as well but it got deprecated or something.

Yes, in English version 2.023, gender specific 'you' was deprecated. If you wish to have a gender specific 'you', use enum: enum : you { she_you, he_you } -Steve

that's a good one. but seriously, here's a Wikipedia quote for what I meant: "In standard English, you is both singular and plural; it always takes a verb form that originally marked the word as plural, such as you are. This was not always so. Early Modern English distinguished between the plural you and the singular thou. This distinction was lost in modern English due to the importation from France of a Romance linguistic feature which is commonly called the T-V distinction." there's also the "ye" form.
Sep 23 2008
next sibling parent reply BCS <ao pathlink.com> writes:
Reply to Yigal,

 LOL!
 that's a good one.
 but seriously, here's a Wikipedia quote for what I meant:
 
 "In standard English, you is both singular and plural; it always takes
 a verb form that originally marked the word as plural, such as you
 are. This was not always so. Early Modern English distinguished
 between the plural you and the singular thou. This distinction was
 lost in modern English due to the importation from France of a Romance
 linguistic feature which is commonly called the T-V distinction."
 

IIRC that shows up in the King James bible and as foot notes in the NIV. (please ignore an non literary/linguistic aspects of that comment, One Theological thread a year is enough!)
 there's also the "ye" form.
 

There was a thread on that a while ago that brought up "ye" as a mangled version of the via the þ char that turned into y. http://en.wikipedia.org/wiki/Ye_(pronoun) :þ
Sep 23 2008
parent reply Yigal Chripun <yigal100 gmail.com> writes:
BCS wrote:
 Reply to Yigal,
 
 LOL!
 that's a good one.
 but seriously, here's a Wikipedia quote for what I meant:

 "In standard English, you is both singular and plural; it always takes
 a verb form that originally marked the word as plural, such as you
 are. This was not always so. Early Modern English distinguished
 between the plural you and the singular thou. This distinction was
 lost in modern English due to the importation from France of a Romance
 linguistic feature which is commonly called the T-V distinction."

IIRC that shows up in the King James bible and as foot notes in the NIV.

I don't know what NIV is. I know that Shakespeare used it and it was generally used as a less formal form. today, Ironically, it can be considered as _more_ formal because it is no longer in day-to-day use.
 
 (please ignore an non literary/linguistic aspects of that comment, One
 Theological thread a year is enough!)

sure thing ;) I totally agree
 
 there's also the "ye" form.

There was a thread on that a while ago that brought up "ye" as a mangled version of the via the þ char that turned into y. http://en.wikipedia.org/wiki/Ye_(pronoun) :þ

Sep 24 2008
parent BCS <ao pathlink.com> writes:
Reply to Yigal,

 I don't know what NIV is.

It's a modern bible translation. http://en.wikipedia.org/wiki/NIV
Sep 24 2008
prev sibling parent reply Alix Pexton <alixD.TpextonNO SPAMgmailD.Tcom> writes:
Yigal Chripun wrote:
 Steven Schveighoffer wrote:
 "Yigal Chripun" wrote
 Ary Borenszweig wrote:
 Yigal Chripun wrote:
 BCS wrote:
 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.

 Don't be mad on this shit, i propose!

being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

that are all combinations of "male/female" and "singular/plural".

at least I know that Russian has both singular and plural. actually I think I read once that English had the same distinction as well but it got deprecated or something.

wish to have a gender specific 'you', use enum: enum : you { she_you, he_you } -Steve

that's a good one. but seriously, here's a Wikipedia quote for what I meant: "In standard English, you is both singular and plural; it always takes a verb form that originally marked the word as plural, such as you are. This was not always so. Early Modern English distinguished between the plural you and the singular thou. This distinction was lost in modern English due to the importation from France of a Romance linguistic feature which is commonly called the T-V distinction." there's also the "ye" form.

"Thou" maybe dead in written English, but it is still there in the spoken (at least around my neck o' woods.) "What is tha doing" and "tha is gonna be late" for example (somewhere else it might still be closer to "thou" in pronunciation.) Use of "thy" or "thi" (second person possessive pronoun as in "what as tha done with thi hair?") might also still be heard. A...
Sep 24 2008
next sibling parent reply BCS <ao pathlink.com> writes:
Reply to Alix,

 (at least around my neck o' woods.)
 

Where's that? :)
Sep 24 2008
parent reply Alix Pexton <alixD.TpextonNO SPAMgmailD.Tcom> writes:
BCS wrote:
 Reply to Alix,
 
 (at least around my neck o' woods.)

Where's that? :)

The North Riding of the county that is Yorkshire. A...
Sep 24 2008
parent reply Paul D. Anderson <paul.d.removethis.anderson comcast.andthis.net> writes:
Alix Pexton Wrote:

 BCS wrote:
 Reply to Alix,
 
 (at least around my neck o' woods.)

Where's that? :)

The North Riding of the county that is Yorkshire. A...

Or you could just watch "The Last of the Summer Wine"... ;-) Paul
Sep 25 2008
parent Alix Pexton <alixD.TpextonNO SPAMgmailD.Tcom> writes:
Paul D. Anderson wrote:
 Alix Pexton Wrote:
 
 BCS wrote:
 Reply to Alix,

 (at least around my neck o' woods.)


A...

Or you could just watch "The Last of the Summer Wine"... ;-) Paul

Not since I was about 12 ^^ A...
Sep 25 2008
prev sibling parent Christopher Wright <dhasenan gmail.com> writes:
Alix Pexton wrote:
 "Thou" maybe dead in written English, but it is still there in the 
 spoken (at least around my neck o' woods.) "What is tha doing" and "tha 
 is gonna be late" for example (somewhere else it might still be closer 
 to "thou" in pronunciation.) Use of "thy" or "thi" (second person 
 possessive pronoun as in "what as tha done with thi hair?") might also 
 still be heard.
 
 A...

I think I'm in love.
Sep 24 2008
prev sibling next sibling parent reply BCS <ao pathlink.com> writes:
Reply to Ary,

 Yigal Chripun wrote:
 
 BCS wrote:
 
 Reply to Victor,
 
 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and
 spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.
 Don't be mad on this shit, i propose!
 

while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

hebrew, that are all combinations of "male/female" and "singular/plural".

I wonder if any language have the full tensor of pronouns? 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral If you don't omit any as impossible that would be 24 words. That wold be a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 9 in English (add on me, you and them).
Sep 23 2008
next sibling parent reply Paul D. Anderson <paul.d.removethis.anderson comcast.andthis.net> writes:
BCS Wrote:


 I wonder if any language have the full tensor of pronouns?
 
 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral
 
 If you don't omit any as impossible that would be 24 words. That wold be 
 a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 
 9 in English (add on me, you and them).
 
 

FWIW, your list isn't long enough -- Maori (along with most other Polynesian languages) has a dual case as well -- singular/dual/plural. The language also distinguishes between the inclusive and exclusive use of "we" -- including or excluding the person being spoken to. "We're going to the baseball game" (And you're not!) vs. "We should get together sometime." (You and I should get together.) You also overlooked the reflexive pronouns -- myself, ourselves, itself, themselves, etc. English can be a little ragged in that area, again with regard to gender. If a person of indeterminate gender should take some reflexive action does he/she do it himself? herself? itself? themself? -- Even the otherwise servicable "they" doesn't work since it is invariable plural, "themselves", when used reflexively. And interrogatives are sometimes considered pronouns -- who/whom, etc. Do even the artificial languages (Esperanto, LogLan, etc.) fill all these slots?? Paul
Sep 23 2008
next sibling parent BCS <ao pathlink.com> writes:
Dang I like this group!

<G>
Sep 23 2008
prev sibling next sibling parent Paul D. Anderson <paul.d.removethis.anderson comcast.andthis.net> writes:
Paul D. Anderson Wrote:

 BCS Wrote:
 
 
 I wonder if any language have the full tensor of pronouns?
 
 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral
 
 If you don't omit any as impossible that would be 24 words. That wold be 
 a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 
 9 in English (add on me, you and them).
 
 

FWIW, your list isn't long enough -- Maori (along with most other Polynesian languages) has a dual case as well -- singular/dual/plural. The language also distinguishes between the inclusive and exclusive use of "we" -- including or excluding the person being spoken to. "We're going to the baseball game" (And you're not!) vs. "We should get together sometime." (You and I should get together.) You also overlooked the reflexive pronouns -- myself, ourselves, itself, themselves, etc. English can be a little ragged in that area, again with regard to gender. If a person of indeterminate gender should take some reflexive action does he/she do it himself? herself? itself? themself? -- Even the otherwise servicable "they" doesn't work since it is invariable plural, "themselves", when used reflexively. And interrogatives are sometimes considered pronouns -- who/whom, etc. Do even the artificial languages (Esperanto, LogLan, etc.) fill all these slots?? Paul

For completeness I should add that Maori has two categories of nouns, a-nouns and o-nouns, that take different verbal particles including pronouns. The categories are hard to keep straight for the non-native speaker (me) but seem to have something to do with portability. An interesting discussion of linguistic categories is found in George Lakoff's "Women, Fire, and Dangerous Things". The title describes one of three categories of nouns used in an Australian native language. See also: http://www.multicians.org/thvv/borges-animals.html Paul
Sep 23 2008
prev sibling next sibling parent Ary Borenszweig <ary esperanto.org.ar> writes:
Paul D. Anderson wrote:
 BCS Wrote:
 
 
 I wonder if any language have the full tensor of pronouns?

 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral

 If you don't omit any as impossible that would be 24 words. That wold be 
 a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 
 9 in English (add on me, you and them).

FWIW, your list isn't long enough -- Maori (along with most other Polynesian languages) has a dual case as well -- singular/dual/plural. The language also distinguishes between the inclusive and exclusive use of "we" -- including or excluding the person being spoken to. "We're going to the baseball game" (And you're not!) vs. "We should get together sometime." (You and I should get together.) You also overlooked the reflexive pronouns -- myself, ourselves, itself, themselves, etc. English can be a little ragged in that area, again with regard to gender. If a person of indeterminate gender should take some reflexive action does he/she do it himself? herself? itself? themself? -- Even the otherwise servicable "they" doesn't work since it is invariable plural, "themselves", when used reflexively. And interrogatives are sometimes considered pronouns -- who/whom, etc. Do even the artificial languages (Esperanto, LogLan, etc.) fill all these slots??

I can't speak for LogLan, but Esperanto is very simplified in this sense: mi (I), vi (you, both singular and plural), sxi (she), li (he), gxi (it), ni (we), ili (they). And reflexive pronouns use those same words, although you can say "mi mem" (I myself, sort of...). I sometimes miss a distinction between the signular and plural "you" in it (in English I've noticed many people say "you guys" when they want to say "not the singular you!"). So it doesn't fill all those slots, but many times you don't need to be that specific. Anyway, Esperanto is expressive in other ways... I'd also like to agree with BCS: you can learn anything in this newsgroup!
 
 Paul
 

Sep 23 2008
prev sibling parent Christopher Wright <dhasenan gmail.com> writes:
Paul D. Anderson wrote:
 BCS Wrote:
 
 
 I wonder if any language have the full tensor of pronouns?

 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral

 If you don't omit any as impossible that would be 24 words. That wold be 
 a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 
 9 in English (add on me, you and them).

FWIW, your list isn't long enough -- Maori (along with most other Polynesian languages) has a dual case as well -- singular/dual/plural. The language also distinguishes between the inclusive and exclusive use of "we" -- including or excluding the person being spoken to. "We're going to the baseball game" (And you're not!) vs. "We should get together sometime." (You and I should get together.)

Pedant: Dual is number, not case.
 You also overlooked the reflexive pronouns -- myself, ourselves, itself,
themselves, etc. English can be a little ragged in that area, again with regard
to gender. If a person of indeterminate gender should take some reflexive
action does he/she do it himself? herself? itself? themself? -- Even the
otherwise servicable "they" doesn't work since it is invariable plural,
"themselves", when used reflexively.
 
 And interrogatives are sometimes considered pronouns -- who/whom, etc. Do even
the artificial languages (Esperanto, LogLan, etc.) fill all these slots??
 
 Paul

And there's also case. Nominative, accusative, dative, genitive, allative, locative, and ablative are all I remember, but you could come up with a couple dozen others, I'm sure. Some languages have a fourth person, so you can unambiguously talk about two distinct groups of people who are not present. There are languages, I suspect, that cover the whole gamut, but they're going to be agglutinative, so you only need to learn a small number of parts to get the whole set.
Sep 23 2008
prev sibling parent Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
BCS wrote:
 Reply to Ary,
 
 Yigal Chripun wrote:

 BCS wrote:

 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and
 spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.
 Don't be mad on this shit, i propose!

while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

hebrew, that are all combinations of "male/female" and "singular/plural".

I wonder if any language have the full tensor of pronouns? 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral If you don't omit any as impossible that would be 24 words. That wold be a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 9 in English (add on me, you and them).

Hum, seems I got here before Bill Baxter. :P And if you go into Japanese, you'll see even more variations. Basically Japanese has variations that depend on the tone of the speech (formal or not) Like: watashi - I (genderless and formal) atashi - I (used by females and a bit less formal) boku - I (used by males and informal) ore - I (used by males in vulgar and arrogant-sounding tone) But even freakier, sometimes, in the case of the 2nd person, they depend not on the *target* of the pronoun (the 2nd person), but also the gender of the speaker! Like: anata - you (genderless target, formal) kimi - you (genderless target, semi-formal, *used by males*) temee - you (genderless target, vulgar and insulting, *used by males*) There are probably many other variants, but I'm nowhere near an expert in Japanese. So basically you can insult someone in Japanese with just one word! So "temee" can be translated something like "You bastard!", but I always chuckle when I see anime fansubs which translate it to just the more literal "You!!!" ^^ -- Bruno Medeiros - Software Developer, MSc. in CS/E graduate http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Sep 23 2008
prev sibling next sibling parent reply "Jarrett Billingsley" <jarrett.billingsley gmail.com> writes:
On Tue, Sep 23, 2008 at 3:25 PM, BCS <ao pathlink.com> wrote:
 Reply to Ary,

 Yigal Chripun wrote:

 BCS wrote:

 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and
 spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.
 Don't be mad on this shit, i propose!

while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

I find it most interesting that four versions of "you" exist in hebrew, that are all combinations of "male/female" and "singular/plural".

I wonder if any language have the full tensor of pronouns? 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral If you don't omit any as impossible that would be 24 words. That wold be a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 9 in English (add on me, you and them).

You forgot inclusive vs. exclusive 3rd person plural ;) (that is, "me and other people but not you" versus "me, you, and possible other people")
Sep 23 2008
parent reply BCS <ao pathlink.com> writes:
Reply to Jarrett,

 On Tue, Sep 23, 2008 at 3:25 PM, BCS <ao pathlink.com> wrote:
 
 Reply to Ary,
 
 Yigal Chripun wrote:
 
 BCS wrote:
 
 Reply to Victor,
 
 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear
 those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and
 spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.
 Don't be mad on this shit, i propose!

while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

hebrew, that are all combinations of "male/female" and "singular/plural".

1st/2nd/3rd person X singular/plural X male/female/mixed/neutral If you don't omit any as impossible that would be 24 words. That wold be a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 9 in English (add on me, you and them).

and other people but not you" versus "me, you, and possible other people")

For that matter there should be 8 versions (me/not me X you/not you X Someone Else/No one Else)
Sep 23 2008
next sibling parent BCS <ao pathlink.com> writes:
Reply to Benjamin,

 For that matter there should be 8 versions (me/not me X you/not you X
 Someone Else/No one Else)
 

Correction; 7 unless you count "no one at all" as a pronoun.
Sep 23 2008
prev sibling parent Benji Smith <dlanguage benjismith.net> writes:
BCS wrote:
 For that matter there should be 8 versions (me/not me X you/not you X 
 Someone Else/No one Else)

And many languages have formal/informal versions as well (tu & vous, in french). --benji
Sep 27 2008
prev sibling next sibling parent "Jarrett Billingsley" <jarrett.billingsley gmail.com> writes:
On Tue, Sep 23, 2008 at 4:48 PM, Jarrett Billingsley
<jarrett.billingsley gmail.com> wrote:
 On Tue, Sep 23, 2008 at 3:25 PM, BCS <ao pathlink.com> wrote:
 Reply to Ary,

 Yigal Chripun wrote:

 BCS wrote:

 Reply to Victor,

 I think only stupid American feminists will tread word "he" as
 "discrimination".
 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.
 This is correct for all Russian girls/women, which i know and
 spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.
 Don't be mad on this shit, i propose!

while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

everything is either male, female or (rarely) both. That included stuff like chair, table (both male), shirt (female) etc. No such problems as you describe occur in practice (in Hebrew) - either you use the male form (which is the default): "I saw someone (in the male form) steal the bag" - is understood to be someone either male or female. this is because when you say "him", someone, etc, you refer to a "person" which is a male noun. if you want to specify that it was indeed a man than just say: "I saw a _man_ ... "

I find it most interesting that four versions of "you" exist in hebrew, that are all combinations of "male/female" and "singular/plural".

I wonder if any language have the full tensor of pronouns? 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral If you don't omit any as impossible that would be 24 words. That wold be a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count 9 in English (add on me, you and them).

You forgot inclusive vs. exclusive 3rd person plural ;) (that is, "me and other people but not you" versus "me, you, and possible other people")

I of course meant *1st* person plural!
Sep 23 2008
prev sibling next sibling parent "Jarrett Billingsley" <jarrett.billingsley gmail.com> writes:
On Tue, Sep 23, 2008 at 3:42 PM, Paul D. Anderson
<paul.d.removethis.anderson comcast.andthis.net> wrote:
 BCS Wrote:


 I wonder if any language have the full tensor of pronouns?

 1st/2nd/3rd person X singular/plural X male/female/mixed/neutral

 If you don't omit any as impossible that would be 24 words. That wold be
 a mouth full, including duplicates (him/her vs. he/she, we vs. us) I count
 9 in English (add on me, you and them).

FWIW, your list isn't long enough -- Maori (along with most other Polynesian languages) has a dual case as well -- singular/dual/plural. The language also distinguishes between the inclusive and exclusive use of "we" -- including or excluding the person being spoken to. "We're going to the baseball game" (And you're not!) vs. "We should get together sometime." (You and I should get together.) You also overlooked the reflexive pronouns -- myself, ourselves, itself, themselves, etc. English can be a little ragged in that area, again with regard to gender. If a person of indeterminate gender should take some reflexive action does he/she do it himself? herself? itself? themself? -- Even the otherwise servicable "they" doesn't work since it is invariable plural, "themselves", when used reflexively. And interrogatives are sometimes considered pronouns -- who/whom, etc. Do even the artificial languages (Esperanto, LogLan, etc.) fill all these slots?? Paul

I need to start reading other posts before posting my own... someone already beat me to the inclusive/exclusive we, it seems :S
Sep 23 2008
prev sibling next sibling parent "Bill Baxter" <wbaxter gmail.com> writes:
On Wed, Sep 24, 2008 at 7:33 AM, Bruno Medeiros
<brunodomedeiros+spam com.gmail> wrote:

 Hum, seems I got here before Bill Baxter. :P

:-) Hadn't even occurred to me to chime in.
 And if you go into Japanese, you'll see even more variations. Basically
 Japanese has variations that depend on the tone of the speech (formal or
 not) Like:

 watashi - I (genderless and formal)
 atashi - I (used by females and a bit less formal)
 boku - I (used by males and informal)
 ore - I (used by males in vulgar and arrogant-sounding tone)

"ore" is more rough, but it's not really vulgar and arrogant. Maybe "macho" is a better description for it. It's "I with testosterone". One interesting thing I noticed, just because I happen to have a young son here, is that often people will substitute "I" for "you" when talking to children. For instance people will ask my son "boku ikutsu?" literally "how old am I" instead of "how old are you?". But since they generally wouldn't call themselves "boku" and since really in Japanese you wouldn't normally need to specify the "you" or the "I" in that situation, it's clear that they really mean "you" when they say "I" in this case. But I guess that's not so different from the "royal we" in English ("Aren't we looking smart today?"). You know from context that the speaker can't possibly really mean "we", so it must mean either you or I.
 But even freakier, sometimes, in the case of the 2nd person, they depend not
 on the *target* of the pronoun (the 2nd person), but also the gender of the
 speaker! Like:

 anata - you (genderless target, formal)
 kimi - you (genderless target, semi-formal, *used by males*)
 temee - you (genderless target, vulgar and insulting, *used by males*)

temee is actually "temae" with slangy pronunciation. -ai and -ae endings get turned into -ee (pronounced like A as in "Kate") omae - is another one. used by males casually in a non-honorific context. Then you can put suffixes on some of those, like -san or -chan. For instance "omae-chan" is a sort of cutesy way to say "you" to a child. Then there's "kisama". It has the very polite -sama ending usually used for royalty and honored guests, but "kisama" is actually very insulting for some reason.
 There are probably many other variants, but I'm nowhere near an expert in
 Japanese.

Yeh, I'm no where close to actually knowing how to use all those properly. I try to stick with the safest most generic ones for fear of accidentally insulting someone.
 So basically you can insult someone in Japanese with just one word! So
 "temee" can be translated something like "You bastard!", but I always
 chuckle when I see anime fansubs which translate it to just the more literal
 "You!!!" ^^

"Temee" is pretty much exclusively for insults, but even "omae", which is used all the time in conversation, is pretty insulting if used on a superior. All these things certainly make it very hard to translate certain Japanese humor into English. --bb
Sep 23 2008
prev sibling parent "Simen Kjaeraas" <simen.kjaras gmail.com> writes:
Christopher Wright wrote:

 And there's also case. Nominative, accusative, dative, genitive,  
 allative, locative, and ablative are all I remember, but you could come  
 up with a couple dozen others, I'm sure.

If you want a lot of cases, try finnish - nominative, genitive, accusative, partitive, locative (with the subdivisions inessive, elative, illative, adessive, ablative, allative), essive, exessive, translative, instructive, abessive, and comitative. In addition, they have three forms of plural. Part of me really wants to learn a language that seems that weird. Other parts of me say I already have enough to do, and I'll probably not have much use for that specific language ("Go work on learning LISP instead!") -- Simen
Sep 24 2008
prev sibling parent reply John H. Guillory <johng communicomm.com> writes:
On Tue, 23 Sep 2008 18:41:48 +0000 (UTC), BCS <ao pathlink.com> wrote:
 I think only stupid American feminists will tread word "he" as
 "discrimination".


 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.


the feminist having their rights to everything having "He/She", when the masculinist would just as well assume that a woman doesn't exist on the face of the earth. What about our rights? Everyone's got a right to modify how people talk except the Men! Satanics can take the word God out of everything, Women can add the word She to everything.... Damn, if you have to add "She", why not at least put the word "SheMAle" in .... How about "He/She/SheMale" or "He/She/Trans"? Would the damn women like that?
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.
 
 Don't be mad on this shit, i propose!
 

I find the gender neutral part funny as well, however once in a while being able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"

Sep 24 2008
parent Victor Tyurin <eaglux gmail.com> writes:
Stupid hypocritical American toys used to confuse the USA and World People!

By the way, in Russian language, if you say about somebody "it/that",
trying to use gender-neutral form, you _will_ annoy he (or she).
Because in Russian, gender-neutral form is masculine, by language rules.
(Example: Petrova the doctor, Ivanova the driver, Sidorova the
President...  ==> doctor/driver/president are masculine nouns).

If you say "it", then you mean something hermaphrodite-like, this is
very bad to anybody.

 On Tue, 23 Sep 2008 18:41:48 +0000 (UTC), BCS <ao pathlink.com> wrote:
 I think only stupid American feminists will tread word "he" as
 "discrimination".


 I'm sure that Russian girls-programmers just laugh when hear those
 language perversions for sexual polit-correctness.


the feminist having their rights to everything having "He/She", when the masculinist would just as well assume that a woman doesn't exist on the face of the earth. What about our rights? Everyone's got a right to modify how people talk except the Men! Satanics can take the word God out of everything, Women can add the word She to everything.... Damn, if you have to add "She", why not at least put the word "SheMAle" in .... How about "He/She/SheMale" or "He/She/Trans"? Would the damn women like that?
 This is correct for all Russian girls/women, which i know and spoke...
 Also, for persons speaking English badly (as me) it will be very
 difficult to use correct USA-specific PC-words.

 Don't be mad on this shit, i propose!

able to explicitly differentiate between gender neutral and either gender can be handy: "Officer, I saw him steal the bag,.. Er, it might have bean a woman but I'm really don't know"


Sep 25 2008
prev sibling parent "Bruce Adams" <tortoise_74 yeah.who.co.uk> writes:
On Mon, 22 Sep 2008 19:37:06 +0100, Saaa <empty needmail.com> wrote:

 sie
 hir

ver ve vis I'm thought Ursala le Guinn had some suggestions too but I can't find them on google. see also: http://everything2.com/e2node/gender-neutral%2520pronoun http://en.wikipedia.org/wiki/Gender-neutral_pronoun But it remains the case that there is no commonly accepted solution (yet). The battle is still being fought by use (and mostly by lack of use) in the real world.
Sep 25 2008
prev sibling parent reply Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
Walter Bright wrote:
 http://www.reddit.com/r/programming/comments/72r6q/walter_bright_
ure_functions_in_d/ 
 

Interesting.
Parameters to a pure function can be mutable, but calls cannot be 

references to mutable data. Cool, this amounts the same to the "partial pure"/"contextually pure" idea Don and I discussed some time ago. Good to see you thought of the same. A few questions: If a pure function can throw, is it required that it always throws given the same inputs (and throwing the same Exception?). Will memory allocation be considered pure?
Pure functions can be executed asynchronously.

own when it is worthwhile to perform such asynchronous call? Will it be okay for the compiler to create and destroy threads under the hood, without programmer intervention? -- Bruno Medeiros - Software Developer, MSc. in CS/E graduate http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Sep 23 2008
next sibling parent reply Christopher Wright <dhasenan gmail.com> writes:
Bruno Medeiros wrote:
 Walter Bright wrote:
 http://www.reddit.com/r/programming/comments/72r6q/walter_bright_
ure_functions_in_d/ 

Interesting. >Parameters to a pure function can be mutable, but calls cannot be cached or executed asynchronously if the arguments contain any references to mutable data. Cool, this amounts the same to the "partial pure"/"contextually pure" idea Don and I discussed some time ago. Good to see you thought of the same. A few questions: If a pure function can throw, is it required that it always throws given the same inputs (and throwing the same Exception?). Will memory allocation be considered pure?

Allocating heap memory affects global state, to whit, the garbage collector's state. I can't see how you can allow memory allocation. You can call new, though, in a pure function, provided it's placement new or scope.
Sep 23 2008
next sibling parent bearophile <bearophileHUGS lycos.com> writes:
Christopher Wright:
 Will memory allocation be considered pure?

Allocating heap memory affects global state, to whit, the garbage collector's state. I can't see how you can allow memory allocation.

The CPU isn't pure, asm changes states all the time. So even if you want to create the purest Haskell language, you have to perform impure operations at some level. This means that while your code can be pure as snow (except for I/O, done if you want using monads), the things that make it run can be impure. So it all becomes a matter of drawing a line, over that line your system/language is pure, under that line (with the microcode and transistors at the bottom) it's impure. So where's the D GC? Over or under the line? If it's considered under the line, them you may malloc memory keeping purity :-) Bye, bearophile
Sep 23 2008
prev sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Christopher Wright"  wrote
 Bruno Medeiros wrote:
 Walter Bright wrote:
 http://www.reddit.com/r/programming/comments/72r6q/walter_bright_pure_functions_in_d/

Interesting. >Parameters to a pure function can be mutable, but calls cannot be cached or executed asynchronously if the arguments contain any references to mutable data. Cool, this amounts the same to the "partial pure"/"contextually pure" idea Don and I discussed some time ago. Good to see you thought of the same. A few questions: If a pure function can throw, is it required that it always throws given the same inputs (and throwing the same Exception?). Will memory allocation be considered pure?

Allocating heap memory affects global state, to whit, the garbage collector's state. I can't see how you can allow memory allocation. You can call new, though, in a pure function, provided it's placement new or scope.

I think memory allocation is an exception, and possibly the only exception, to the global-state rule. If you don't have memory allocation, string operations cannot be pure, you can't return classes, etc. So that limits pure to simple math stuff where you can only return structs or primary types (int, double, etc.), which IMO would be a waste of time. Not a lot of code deals with only math, most code never does. -Steve
Sep 23 2008
prev sibling next sibling parent "Bill Baxter" <wbaxter gmail.com> writes:
On Wed, Sep 24, 2008 at 10:10 AM, Christopher Wright <dhasenan gmail.com> wrote:

 Will memory allocation be considered pure?

Allocating heap memory affects global state, to whit, the garbage collector's state. I can't see how you can allow memory allocation.

You could potentially work out some limited form of allocation to make life easier. Just thinking out loud here, but what if you could specify that all calls in a particular pure function should alloc memory from a particular thread local pool? That would mean you could continue using conveniences like ~= type operations inside the function. You'd have to be forbidden from returning pointers into that memory, though.
 You can call new, though, in a pure function, provided it's placement new or
 scope.

And provided the constructor is pure. --bb
Sep 23 2008
prev sibling next sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
Bruno Medeiros wrote:
 A few questions:
 
 If a pure function can throw, is it required that it always throws given 
 the same inputs (and throwing the same Exception?).

Yes.
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.
  >Pure functions can be executed asynchronously.
 Do you realistically expect the compiler to be able to determine on its 
 own when it is worthwhile to perform such asynchronous call? Will it be 
 okay for the compiler to create and destroy threads under the hood, 
 without programmer intervention?

If threads/cores get cheap enough, I think this can be done. In the meantime, pure functions make great arguments to 'futures' calls.
Sep 26 2008
next sibling parent reply Jason House <jason.james.house gmail.com> writes:
Walter Bright Wrote:

 Bruno Medeiros wrote:
 
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

Pure functions allocating memory is a nice feature to have. A lot of D code wants to allocate memory. It would certainly allow more return values from pure functions. I don't know what impacts that'd have on the memory model. I've had the impression that parallelizing pure functions could be lockless.
Sep 27 2008
parent reply Leandro Lucarella <llucax gmail.com> writes:
Jason House, el 27 de septiembre a las 07:32 me escribiste:
 Walter Bright Wrote:
 
 Bruno Medeiros wrote:
 
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

Pure functions allocating memory is a nice feature to have. A lot of D code wants to allocate memory. It would certainly allow more return values from pure functions. I don't know what impacts that'd have on the memory model. I've had the impression that parallelizing pure functions could be lockless.

But I don't see how a function can be pure if allocates, for example: pure Image rotate(Image original) { Image img = new Image(original.size) // some rotation logic return img; } If this "pure" function is called with enough memory, it will return a copy of the original image, rotated. If there is no enough memory, the function will throw (note that the input is exactly the same for both calls, but the result is different). You can add some try/catch to make it nonthrow, but if you have no memory, you can't possibly return the same image as it would be returned when memory is available. What about stack allocation? I don't even know what's the current behaviour. Can you get out of stack? Is an exception raised? The program aborted? Anything else? This is a really tricky issue indeed, because not being able to allocate in a pure function would reduce their utility greatly. -- Leandro Lucarella (luca) | Blog colectivo: http://www.mazziblog.com.ar/blog/ ---------------------------------------------------------------------------- GPG Key: 5F5A8D05 (F8CD F9A7 BF00 5431 4145 104C 949E BFB6 5F5A 8D05) ---------------------------------------------------------------------------- El techo de mi cuarto lleno de cometas
Sep 27 2008
parent reply Jason House <jason.james.house gmail.com> writes:
Leandro Lucarella wrote:

 Jason House, el 27 de septiembre a las 07:32 me escribiste:
 Walter Bright Wrote:
 
 Bruno Medeiros wrote:
 
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

Pure functions allocating memory is a nice feature to have. A lot of D code wants to allocate memory. It would certainly allow more return values from pure functions. I don't know what impacts that'd have on the memory model. I've had the impression that parallelizing pure functions could be lockless.

But I don't see how a function can be pure if allocates, for example: pure Image rotate(Image original) { Image img = new Image(original.size) // some rotation logic return img; } If this "pure" function is called with enough memory, it will return a copy of the original image, rotated. If there is no enough memory, the function will throw (note that the input is exactly the same for both calls, but the result is different). You can add some try/catch to make it nonthrow, but if you have no memory, you can't possibly return the same image as it would be returned when memory is available. What about stack allocation? I don't even know what's the current behaviour. Can you get out of stack? Is an exception raised? The program aborted? Anything else? This is a really tricky issue indeed, because not being able to allocate in a pure function would reduce their utility greatly.

You're missing the subtleties in what Walter said: "If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory." That means that if an out of memory exception occurs, the pure function (possibly even the whole program) can not catch the out of memory exception. Either a pure function will operate normally and predictably, or it has a non-recoverable error. This has to be handled differently than recoverable errors/exceptions which are predictable/repeatable.
Sep 27 2008
parent reply BCS <ao pathlink.com> writes:
Reply to Jason,

 You're missing the subtleties in what Walter said:
 "If memory allocation failure is a non-recoverable exception,
 then pure functions can allocate memory."
 That means that if an out of memory exception occurs, the pure
 function (possibly even the whole program) can not catch the out of
 memory exception.  Either a pure function will operate normally and
 predictably, or it has a non-recoverable error.  This has to be
 handled differently than recoverable errors/exceptions which are
 predictable/repeatable.
 

Ditto. To argue the point by taking it to the ridiculous: *Any* function can fail for any number of reasons that aren't related the to arguments; stack overflows, un-handled external signals (SIGKILL), loss of power to the the CPU, arbitrary hardware failure. The line has to be drawn somewhere, the question is only where.
Sep 28 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Regarding the pure function topic: is it possible to have, just at debug time,
the possibility to add special debugging printing statements into pure
functions? :-)
Maybe now I am asking something silly... because the order of their prints and
the number of times such function is called isn't defined by the compiler, and
it may even change.
Another possible way to debug is for the programmer to temporary remove the
"pure" statement(s), add some debugging writefln/putr/stdios, compile, run, see
the output, put the "pure"(s) back, etc, etc... :-)

Bye,
bearophile
Sep 29 2008
next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Sorry, I have forgotten to add a small thing. In Haskell they have solved the
debugging problem in some ways, like this:

http://cvs.haskell.org/Hugs/pages/libraries/base/Debug-Trace.html

But that solution may require installing the concept of monads into the brain
of most D programmers first :-)

Bye,
bearophile
Sep 29 2008
parent reply renoX <renosky free.fr> writes:
bearophile a écrit :
 Sorry, I have forgotten to add a small thing. In Haskell they have
 solved the debugging problem in some ways, like this:
 
 http://cvs.haskell.org/Hugs/pages/libraries/base/Debug-Trace.html
 
 But that solution may require installing the concept of monads into
 the brain of most D programmers first :-)

Sure, D should have monads as soon as Haskell programmers are able to explain this concept to 'normal' programmers (and no cheating such as the classical handwaving, this is a way to wrap side effects..) So probably never then. That said, I agree very much that allowing debug output and memory allocation in pure function makes them much more useful while keeping their 'purity'. So I vote +1 Bye, renoX
 Bye, bearophile

Oct 02 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
renoX:
 Sure, D should have monads as soon as Haskell programmers are able to 
 explain this concept to 'normal' programmers (and no cheating such as 
 the classical handwaving, this is a way to wrap side effects..)
 So probably never then.

You can try reading this: http://en.wikipedia.org/wiki/Monad_(functional_programming) If D wants to add some functional-style features to itself, then I think D programmers have to learn some functional-style idioms and style, otherwise those changes/additions D become useless. Do you agree? On the other hand I presume many D programmers know some functional programming, from Haskell, Scheme, or even Python... Bye, bearophile
Oct 02 2008
next sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
 renoX:
 Sure, D should have monads as soon as Haskell programmers are able to 
 explain this concept to 'normal' programmers (and no cheating such as 
 the classical handwaving, this is a way to wrap side effects..)
 So probably never then.


You can also read this, it's quite easy: http://www.reddit.com/r/programming/comments/64th1/monads_in_python_in_production_code_you_can_and/c02u9mb It also shows how they have already solved the problem of exceptions in languages with pure functions, with the Maybe monad :-) As I've said in the past, functional programming doesn't work alone, it works in an ecology of features. So adding a single thing isn't enough. For example you may need a compiler able of tail call elimination (GCC is able to do this sometimes), have a short lambda syntax (like the C# one: x => x*2 ), have more type inferencing (a stronger type system), closures, simple ways to manage immutability, pure functions, plus other smaller things. Among the smaller things I'd like there's a generic len() function similar to the Python one and the one I've put in my libs. It's able to call the length attribute if present, and to count items in a lazy iterable too. You can use it this way: auto b = sorted(a, &len!(BaseType1!(typeof(a)))); That works, and sorts the items of the a iterable according to the length of its items. BaseType1 is a template that returns the type of the items at the first level that the given type contains/yields. That shows the type system isn't strong enough yet for higher order functional programming, because len is a function template, and you have to specialize it manually to find its pointer/delegate. In a language with a more powerful type system you may use: auto b = sorted(a, len) Bye, bearophile
Oct 02 2008
parent Fawzi Mohamed <fmohamed mac.com> writes:
On 2008-10-03 01:37:40 +0200, bearophile <bearophileHUGS lycos.com> said:

 renoX:
 Sure, D should have monads as soon as Haskell programmers are able to
 explain this concept to 'normal' programmers (and no cheating such as
 the classical handwaving, this is a way to wrap side effects..)
 So probably never then.


You can also read this, it's quite easy: http://www.reddit.com/r/programming/comments/64th1/monads_in_python_in_production_code_you_can_and/c02u9mb

It
 
 also shows how they have already solved the problem of exceptions in 
 languages with pure functions, with the Maybe monad :-)
 
 As I've said in the past, functional programming doesn't work alone, it 
 works in an ecology of features. So adding a single thing isn't enough. 
 For example you may need a compiler able of tail call elimination (GCC 
 is able to do this sometimes), have a short lambda syntax (like the C# 
 one: x => x*2 ), have more type inferencing (a stronger type system), 
 closures, simple ways to manage immutability, pure functions, plus 
 other smaller things.
 
 Among the smaller things I'd like there's a generic len() function 
 similar to the Python one and the one I've put in my libs. It's able to 
 call the length attribute if present, and to count items in a lazy 
 iterable too.
 You can use it this way:
 auto b = sorted(a, &len!(BaseType1!(typeof(a))));
 That works, and sorts the items of the a iterable according to the 
 length of its items. BaseType1 is a template that returns the type of 
 the items at the first level that the given type contains/yields.
 That shows the type system isn't strong enough yet for higher order 
 functional programming, because len is a function template, and you 
 have to specialize it manually to find its pointer/delegate. In a 
 language with a more powerful type system you may use:
 auto b = sorted(a,  len)
 
 Bye,
 bearophile

Functional programming doesn't necessarily need a stronger type system, it might also have a weaker one, don't forget lisp & co, you just move things to the runtime... Fawzi
Oct 03 2008
prev sibling parent reply renoX <renosky free.fr> writes:
bearophile a écrit :
 renoX:
 Sure, D should have monads as soon as Haskell programmers are able
 to explain this concept to 'normal' programmers (and no cheating
 such as the classical handwaving, this is a way to wrap side
 effects..) So probably never then.

You can try reading this: http://en.wikipedia.org/wiki/Monad_(functional_programming)

Sorry, but this is still above my level of understanding, and I've been programming for quite a long time (and have been curious of many things in programming)..
 If D wants to add some functional-style features to itself, then I
 think D programmers have to learn some functional-style idioms and
 style, otherwise those changes/additions D become useless. Do you
 agree?

In general yes, in this case no: AFAIK, monads are only useful for "pure" functional language which D isn't and won't ever be. IMHO, functional programming has some good stuff which are easy to use and understand that D should steal such as "pure functions" but monads aren't such thing: they're very hard to understand, so their correct usage isn't obvious and in an impure language I fail to see their interest.. Regards, Renaud.
 On the other hand I presume many D programmers know some
 functional programming, from Haskell, Scheme, or even Python...
 
 Bye, bearophile

Oct 08 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
renoX:
 Sorry, but this is still above my level of understanding, and I've been 
 programming for quite a long time (and have been curious of many things 
 in programming)..

Around the net there are many tutorials on them, this is very simple: http://www.reddit.com/r/programming/comments/64th1/monads_in_python_in_production_code_you_can_and/c02u9mb To understand them I think you can: - I think you have to "unlearn" some of the things you know; - read explanations about them - to install Haskell and start learning it, with time you will learn.
 In general yes, in this case no: AFAIK, monads are only useful for 
 "pure" functional language which D isn't and won't ever be.

If you say you don't undestand monads, how can you tell they can't be useful for the future D? As far as we today know, monads allow you to use pure functions in the most effective way. For example using monads is the best known way to solve the logging and the exception problems of pure fuctions. So I think they can be useful for the future D too.
 IMHO, functional programming has some good stuff which are easy to use 
 and understand that D should steal such as "pure functions" but monads 
 aren't such thing: they're very hard to understand, so their correct 
 usage isn't obvious and in an impure language I fail to see their interest..

They aren't so hard to understand. In C++ there are several concepts that are as much or more difficult to understand. Bye, bearophile
Oct 08 2008
parent reply renoX <renosky free.fr> writes:
bearophile a écrit :
 renoX:
 Sorry, but this is still above my level of understanding, and I've
 been programming for quite a long time (and have been curious of
 many things in programming)..

Around the net there are many tutorials on them, this is very simple: http://www.reddit.com/r/programming/comments/64th1/monads_in_python_in_production_code_you_can_and/c02u9mb

I've read it too, without success also.
 To understand them I think you can: - I think you have to "unlearn"
 some of the things you know; - read explanations about them - to
 install Haskell and start learning it, with time you will learn.

No, I'm not interested in Haskell, as long as I can't learn monads I'm not interested plus there's D, Scala, F#, Ruby, etc, already lots of interesting language to learn..
 In general yes, in this case no: AFAIK, monads are only useful for
  "pure" functional language which D isn't and won't ever be.

If you say you don't undestand monads, how can you tell they can't be useful for the future D? As far as we today know, monads allow you to use pure functions in the most effective way. For example using monads is the best known way to solve the logging and the exception problems of pure fuctions.

First I'm not convinced that pure functions have an issue with exceptions, second if you can cast an output function as a pure function (lying to the compiler in some way) then the logging issue is solved: this is something that I can understand easily, no need for weird monads.
 So I think they can be useful for the
 future D too.
 
 
 IMHO, functional programming has some good stuff which are easy to
 use and understand that D should steal such as "pure functions" but
 monads aren't such thing: they're very hard to understand, so their
 correct usage isn't obvious and in an impure language I fail to see
 their interest..

They aren't so hard to understand. In C++ there are several concepts that are as much or more difficult to understand.

C++ isn't simple I agree, but usually the things really hard to understand are weird corner case, that one can mostly ignore but monads are a fundamental concepts for Haskell (otherwise no IO). renoX
 
 Bye, bearophile

Oct 09 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
renoX:

No, I'm not interested in Haskell, as long as I can't learn monads I'm not
interested<

My idea is that you can start learning Haskell, doing practice, learning how you do I/O, etc, even if you don't know what they are. You use monads everywhere from the beginning, but to do basic I/O you don't need to understand them. With time your mind starts to generalize what they are and what they can do. It may take several months, but it's fun :-)
plus there's D, Scala, F#, Ruby, etc, already lots of interesting language to
learn..<

Note that monads are used in F# too, and I presume in few months/years we'll see them in Scala too ;-) And currently Haskell is one of the most interesting languages to learn, even more interesting than Prolog :-) Bye, bearophile
Oct 09 2008
parent renoX <renosky free.fr> writes:
bearophile a écrit :
 renoX:
 
 No, I'm not interested in Haskell, as long as I can't learn monads
 I'm not interested<

My idea is that you can start learning Haskell, doing practice, learning how you do I/O, etc, even if you don't know what they are.

I don't like magic, perhaps it's because I learned assembly language too early but I had the same issue with OO languages: until I managed to understand how inheritance worked, it was always bugging me.. Unfortunately monads are *way harder* to understand than inheritance! [cut]
 Note that monads are used in F# too, and I presume in few
 months/years we'll see them in Scala too ;-)

F# being impure, I wonder if monads are used often in F#?
And currently Haskell is
 one of the most interesting languages to learn, even more interesting
 than Prolog :-)

YMMV: Learned Prolog and Lisp at school, never used those and didn't get any interest in using them from the school lessons, and I feel the same about Haskell: a language for researchers, nice for melting your brain sure, but not something I'm interested in: functional language are not my thing. D's users being practical guys, I doubt that I'm alone in my desinterest in Haskell. renoX
Oct 10 2008
prev sibling next sibling parent reply Ary Borenszweig <ary esperanto.org.ar> writes:
bearophile escribió:
 Regarding the pure function topic: is it possible to have, just at debug time,
the possibility to add special debugging printing statements into pure
functions? :-)
 Maybe now I am asking something silly... because the order of their prints and
the number of times such function is called isn't defined by the compiler, and
it may even change.
 Another possible way to debug is for the programmer to temporary remove the
"pure" statement(s), add some debugging writefln/putr/stdios, compile, run, see
the output, put the "pure"(s) back, etc, etc... :-)

Can't a debugger enter pure functions?
 
 Bye,
 bearophile

Sep 29 2008
parent Sergey Gromov <snake.scaly gmail.com> writes:
Mon, 29 Sep 2008 18:38:19 -0300,
bearophile escribio:
 Regarding the pure function topic: is it possible to have, just at
 debug time, the possibility to add special debugging printing
 statements into pure functions? :-)

I think you can pretend that a debug trace is pure if it can't fail and is internally synchronized. Also see below. Ary Borenszweig wrote:
 Can't a debugger enter pure functions?

Can a debugger enter a new thread? I think not unless you've set a breakpoint there. Though I think in debug mode (no -O option) pure functions should be executed sequentially and in a single thread so that they can be traditionally debugged. This also solves the out-of-order tracing problem.
Sep 29 2008
prev sibling parent reply Sean Kelly <sean invisibleduck.org> writes:
== Quote from bearophile (bearophileHUGS lycos.com)'s article
 Regarding the pure function topic: is it possible to have, just at debug time,
the possibility to add special

 Maybe now I am asking something silly... because the order of their prints and
the number of times such

 Another possible way to debug is for the programmer to temporary remove the
"pure" statement(s), add

Monads ;-) Otherwise, something like this should work: void debugln_(...) { /* forward to writefln */ } alias pure void function(...) SomeFn; SomeFn debugln = cast(pure SomeFn) &debugln_; Sean
Sep 29 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Sean Kelly:
 Otherwise, something like this should work:
 void debugln_(...) { /* forward to writefln */ }
 alias pure void function(...) SomeFn;
 SomeFn debugln = cast(pure SomeFn) &debugln_;

I think you have written a static cast from the function pointer of an impure function to a function pointer of a pure function. I kind of hope the compiler will forbid a cast like that, I think it may give troubles :-) This topic makes me more and more amused as time passes :-) Bye, bearophile
Sep 29 2008
next sibling parent Sean Kelly <sean invisibleduck.org> writes:
== Quote from bearophile (bearophileHUGS lycos.com)'s article
 Sean Kelly:
 Otherwise, something like this should work:
 void debugln_(...) { /* forward to writefln */ }
 alias pure void function(...) SomeFn;
 SomeFn debugln = cast(pure SomeFn) &debugln_;


troubles :-) The compiler allows one to add "invariant" with a cast, so why not "pure?" Casting is basically a sledgehammer emblazoned with the label "trust me, I know what I'm doing." Sean
Sep 29 2008
prev sibling parent reply BCS <ao pathlink.com> writes:
Reply to bearophile,

 Sean Kelly:
 
 Otherwise, something like this should work:
 void debugln_(...) { /* forward to writefln */ }
 alias pure void function(...) SomeFn;
 SomeFn debugln = cast(pure SomeFn) &debugln_;

impure function to a function pointer of a pure function. I kind of hope the compiler will forbid a cast like that, I think it may give troubles :-) This topic makes me more and more amused as time passes :-) Bye, bearophile

To forbid such a cast, you would need to forbid pointers to pure functions. You can subvert the type system with unions if nothing else and for something like pure, there is no point in limiting casts if there are ways around it. union Cast (R, T...) { R function(T) nonPure; pure R function(T) pure; }
Sep 29 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
BCS:
 To forbid such a cast, you would need to forbid pointers to pure functions. 
 You can subvert the type system with unions if nothing else and for something 
 like pure, there is no point in limiting casts if there are ways around it.

If it turns out that casting impure => pure is very dangerous (and I don't know yet how much dangerous it can be), then it may be useful anyway to forbid the simple impure => pure cast, forcing the programmers to perform that cast with a union. So it becomes a way to tell the programmer that operation is very discouraged :-) Bye, bearophile
Sep 29 2008
parent BCS <ao pathlink.com> writes:
Reply to bearophile,

 BCS:
 
 To forbid such a cast, you would need to forbid pointers to pure
 functions. You can subvert the type system with unions if nothing
 else and for something like pure, there is no point in limiting casts
 if there are ways around it.
 

don't know yet how much dangerous it can be), then it may be useful anyway to forbid the simple impure => pure cast, forcing the programmers to perform that cast with a union. So it becomes a way to tell the programmer that operation is very discouraged :-) Bye, bearophile

If the correct way is to use a cast, you can grep for it, if you need to use a union, it will be extremely hard to find such casts. Thus the reason to allow the cast or make it totally impossible.
Sep 29 2008
prev sibling next sibling parent reply Michel Fortin <michel.fortin michelf.com> writes:
On 2008-09-27 02:07:59 -0400, Walter Bright <newshound1 digitalmars.com> said:

 Bruno Medeiros wrote:
 A few questions:
 
 If a pure function can throw, is it required that it always throws 
 given the same inputs (and throwing the same Exception?).

Yes.
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

Or you could go in between: allow memory allocation exceptions to be caught, but only when not in a pure function. This way pure functions still always give the same result, or fail and allow non-pure code to handle gracefully the situation (displaying an error message for instance). Making pure functions completely non-recoverable would mean that in a GUI app, for instance, every time you'd call a pure function allocating some memory you'd run the risk of terminating the app, which is not really acceptable. And I think memory allocation is a must, given that without it you can't create, or append to, arrays or strings, and you make pure functions limited to working with pre-existing buffers (which would be then passed by reference, preventing hoisting). -- Michel Fortin michel.fortin michelf.com http://michelf.com/
Sep 27 2008
parent reply dsimcha <dsimcha yahoo.com> writes:
== Quote from Michel Fortin (michel.fortin michelf.com)'s article
 On 2008-09-27 02:07:59 -0400, Walter Bright <newshound1 digitalmars.com> said:
 Bruno Medeiros wrote:
 A few questions:

 If a pure function can throw, is it required that it always throws
 given the same inputs (and throwing the same Exception?).

Yes.
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

caught, but only when not in a pure function. This way pure functions still always give the same result, or fail and allow non-pure code to handle gracefully the situation (displaying an error message for instance). Making pure functions completely non-recoverable would mean that in a GUI app, for instance, every time you'd call a pure function allocating some memory you'd run the risk of terminating the app, which is not really acceptable. And I think memory allocation is a must, given that without it you can't create, or append to, arrays or strings, and you make pure functions limited to working with pre-existing buffers (which would be then passed by reference, preventing hoisting).

What about stack overflows, etc.? Calling a pure function can also bring down your app if you're out of stack space. I think it's important to remember that any notion of functional purity exists at the level of the language abstraction, not at the bare metal level. Therefore, anything that breaks the language abstraction is going to break any concept of functional purity. Heck, given the proper hardware or compiler bugs, even functions that are pure by the strictest definitions can have side effects.
Sep 27 2008
parent Sergey Gromov <snake.scaly gmail.com> writes:
Sun, 28 Sep 2008 07:28:19 +0900,
Bill Baxter wrote:
 But I think a stack overflow is something that doesn't usually occur
 in a properly written program, and they are also are not something you
 can recover from.  Insufficient memory errors can be and often are
 recovered from.   E.g. you try to create a giant image in an image
 editing program, if there's not enough memory your image editor
 *should* realize the image alloc failed and bail out gracefully
 telling you there's not enough memory for that operation.

My thoughts so far. Since a real purity is unachievable, there are different grades of purity which make a practical difference: A. Independence of an external state in the sense that a pure function can be executed in parallel without the need for synchronization. This is the simplest, most obvious and a must have kind of purity. It also allows for an arbitrary execution order of functions with independent arguments and results. Even malloc() conforms to this kind of purity because memory management is thread-safe at the low level anyway so it can be executed in parallel without compiler taking additional precautions. B. Repeatability of the result that allows to cache parameters and reuse the same result if the same parameters are given. This type of purity is way stricter than the first and is harder to check and utilize. What happens if an exception is thrown? Purity of type A is perfectly preserved. Naturally, an exception can happily be thrown in parallel and in any order. Purity of type B can also be preserved if an exception is thrown consistently with function parameters and compiler is able to prove that. If another kind of exception is thrown, the purity B is broken. What does it mean, broken purity? It means that any results of a B-pure computation are invalid and must be discarded. I think that a smart compiler should catch exceptions from B-pure functions and, if an exception is unexpected, wrap them in a PurityError exception which B- pure functions must never catch. Yet this exception does no harm to the purity of A-pure functions and can be handled there. Now to exception handling. Any exceptions from A-pure functions and selected exceptions from B-pure functions are considered the function result. Therefore try { localState = pureFun(); } catch(...) { localState = ... } is a valid pure statement, it can be executed in parallel and in any order with the surrounding statements and localState can be completely replaced with a cached or pre-computed value if pureFunc is B-pure. This is actually valid for any try-catch statement with an important note: the statements inside the try block can never be executed in parallel to each other, though B-pure functions still can be replaced with their cached values/exceptions. Also a try-catch block in a B-pure function can never catch a PurityError. The image creation routine in your example is A-pure because it creates new image every time it is called with the same arguments. It can safely throw OutOfMemory which you catch and report to the user via something completely unpure.
Sep 27 2008
prev sibling next sibling parent bearophile <bearophileHUGS lycos.com> writes:
Walter Bright:
 Bruno Medeiros:
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

Walter, I think you may ask that question here: http://lambda-the-ultimate.org/ If the questions are asked honestly (and you explain that it is a quite important question, because it may determine part of the functional future of D), they are generally happy to answer all they know. Bye, bearophile
Sep 27 2008
prev sibling next sibling parent Russell Lewis <webmaster villagersonline.com> writes:
Walter Bright wrote:
 Bruno Medeiros wrote:
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

Another option is for pure functions to use a blocking, never-fail allocator. That is, when a pure function allocates and we don't have enough memory, then instead of returning an out-of-memory exception, that thread will block until memory is freed. Of course, that would mean deadlock if we only had one thread, or if all threads blocked in this same situation, so we might want to have "kill the application" code to handle that case.
Sep 29 2008
prev sibling parent Bruno Medeiros <brunodomedeiros+spam com.gmail> writes:
Walter Bright wrote:
 Bruno Medeiros wrote:
 
  >Pure functions can be executed asynchronously.
 Do you realistically expect the compiler to be able to determine on 
 its own when it is worthwhile to perform such asynchronous call? Will 
 it be okay for the compiler to create and destroy threads under the 
 hood, without programmer intervention?

If threads/cores get cheap enough, I think this can be done. In the meantime, pure functions make great arguments to 'futures' calls.

What if a function is pure but memory expensive? Say we are in loop, and the compiler spawns, say, 8 threads to run that function asynchronously... that could increase the program's memory consumption 8 fold, all under the hood. -- Bruno Medeiros - Software Developer, MSc. in CS/E graduate http://www.prowiki.org/wiki4d/wiki.cgi?BrunoMedeiros#D
Oct 03 2008
prev sibling parent "Bill Baxter" <wbaxter gmail.com> writes:
On Sun, Sep 28, 2008 at 7:12 AM, dsimcha <dsimcha yahoo.com> wrote:
 == Quote from Michel Fortin (michel.fortin michelf.com)'s article
 On 2008-09-27 02:07:59 -0400, Walter Bright <newshound1 digitalmars.com> said:
 Bruno Medeiros wrote:
 A few questions:

 If a pure function can throw, is it required that it always throws
 given the same inputs (and throwing the same Exception?).

Yes.
 Will memory allocation be considered pure?

I don't know yet. If memory allocation failure is a non-recoverable exception, then pure functions can allocate memory.

caught, but only when not in a pure function. This way pure functions still always give the same result, or fail and allow non-pure code to handle gracefully the situation (displaying an error message for instance). Making pure functions completely non-recoverable would mean that in a GUI app, for instance, every time you'd call a pure function allocating some memory you'd run the risk of terminating the app, which is not really acceptable. And I think memory allocation is a must, given that without it you can't create, or append to, arrays or strings, and you make pure functions limited to working with pre-existing buffers (which would be then passed by reference, preventing hoisting).

What about stack overflows, etc.? Calling a pure function can also bring down your app if you're out of stack space. I think it's important to remember that any notion of functional purity exists at the level of the language abstraction, not at the bare metal level. Therefore, anything that breaks the language abstraction is going to break any concept of functional purity. Heck, given the proper hardware or compiler bugs, even functions that are pure by the strictest definitions can have side effects.

But I think a stack overflow is something that doesn't usually occur in a properly written program, and they are also are not something you can recover from. Insufficient memory errors can be and often are recovered from. E.g. you try to create a giant image in an image editing program, if there's not enough memory your image editor *should* realize the image alloc failed and bail out gracefully telling you there's not enough memory for that operation. --bb
Sep 27 2008