functional-programming

问题 class App extends Component { constructor(props) { super(props); this.state = { Card: Card } } HandleEvent = (props) => { this.SetState({Card: Card.Active} } render() { return ( <Card Card = { this.state.Card } HandleEvent={ this.handleEvent }/> <Card Card = { this.state.Card } HandleEvent={ this.handleEvent }/> ) } } const Card = props => { return ( <div style={props.state.Card} onClick={ props.HandleEvent}>Example</div> ) } Every time I click on one of the cards all of my elements change

问题 class App extends Component { constructor(props) { super(props); this.state = { Card: Card } } HandleEvent = (props) => { this.SetState({Card: Card.Active} } render() { return ( <Card Card = { this.state.Card } HandleEvent={ this.handleEvent }/> <Card Card = { this.state.Card } HandleEvent={ this.handleEvent }/> ) } } const Card = props => { return ( <div style={props.state.Card} onClick={ props.HandleEvent}>Example</div> ) } Every time I click on one of the cards all of my elements change

问题 Is there a idiomatic / built-in way to flip the argument order that is passed to a function in Clojure? As I do here with the definition of a helper function: (defn flip [f & xs] (apply f (reverse xs))) (vector 1 2) ; [1 2] (flip vector 1 2) ; [2 1] 回答1: A flip function does exist in other functional languages, but it's easy enough to do in Clojure as well, and you've already done it! There are other ways to do it as well. And here is a discussion about it from the Clojure mailing list. 回答2:

问题 In a recent interview, I was asked to write a function that adds numbers and accepts parameters like this: add(1)(2)(3) // result is 6 add(1,2)(3,4)(5) // result is 15 The number of parameters is not fixed, and the arguments can be either passed in sets or individually. How can I implement this add function? 回答1: Given your examples, the number of parameters is fixed in some ways. As @ASDFGerte pointed out, your examples seem to return the result after three invocations. In this case a simple

问题 Having been tainted by Linq, I'm reluctant to give it up. However, for some things I just need to use C++. The real strength of linq as a linq-consumer (i.e. to me) lies not in expression trees (which are complex to manipulate), but the ease with which I can mix and match various functions. Do the equivalents of .Where , .Select and .SelectMany , .Skip and .Take and .Concat exist for C++-style iterators? These would be extremely handy for all sorts of common code I write. I don't care about

问题 I know that Scala has var (for mutable state) but pure functional programming discourages use of any mutable state and rather focuses on using val for everything. Coming from an imperative world it's hard to let go of mutable state. My question is when is it okay to use var in your Scala code ? Can all code really be done using just val. If yes, then why does Scala have vars? 回答1: Here are some reasons for vars in Scala: Scala is a multi-paradigm language, it encourages functional programming

问题 I'm experimenting with writing a game in a functional programming style, which implies representing the game state with a purely functional, immutable data structures. One of the most important data structures would be a 3D grid representing the world, where objects can be stored at any [x,y,z] grid location. The properties I want for this data structure are: Immutable Fast persistent updates - i.e. creation of a new version of the entire grid with small changes is cheap and achieved through

问题 I'm experimenting with writing a game in a functional programming style, which implies representing the game state with a purely functional, immutable data structures. One of the most important data structures would be a 3D grid representing the world, where objects can be stored at any [x,y,z] grid location. The properties I want for this data structure are: Immutable Fast persistent updates - i.e. creation of a new version of the entire grid with small changes is cheap and achieved through

问题 I have a list l:List[T1] and currently im doing the following: myfun : T1 -> Option[T2] val x: Option[T2] = l.map{ myfun(l) }.flatten.find(_=>true) The myfun function returns None or Some, flatten throws away all the None's and find returns the first element of the list if any. This seems a bit hacky to me. Im thinking that there might exist some for-comprehension or similar that will do this a bit less wasteful or more clever. For example: I dont need any subsequent answers if myfun returns

问题 I have a list l:List[T1] and currently im doing the following: myfun : T1 -> Option[T2] val x: Option[T2] = l.map{ myfun(l) }.flatten.find(_=>true) The myfun function returns None or Some, flatten throws away all the None's and find returns the first element of the list if any. This seems a bit hacky to me. Im thinking that there might exist some for-comprehension or similar that will do this a bit less wasteful or more clever. For example: I dont need any subsequent answers if myfun returns