composition | 易学教程

Publishing Non-Thread Safe Object Fields in a Thread-Safe Manner

阅读更多关于 Publishing Non-Thread Safe Object Fields in a Thread-Safe Manner

问题 I've got a problem with Java concurrency. Yes, I looked at questions with almost the exact same title, but they all seemed to be asking subtly different things. Yes, I've read Java Concurrency in Practice . Yes, I can see why it's the defacto reference for the topic. Yes, I've read the section specifically on publishing fields in thread-safe classes. Yes, I'm still going to ask a concurrency question on Java regardless of the fact that I know someone will simply point me to that book. This

Composition/Inheritance/Factory - Best Pattern For This Case

阅读更多关于 Composition/Inheritance/Factory - Best Pattern For This Case

Good [your_time_of_day], Today I have been learning about composition and factory functions in javascript (es6). I understand that composition should be preferred over inheritance and have come to agree with that (at least in javascript). Then, I realised that I have a situation where I should be using composition... Question first: Is there a way I can change my complex, inherited structure so classes are composed of functions without having ridiculous numbers of decorators? Have I missed something about composition in general (I feel like I have)? Situation I have a base class AudioPlayer:

Using self-defined Cython code from other Cython code

阅读更多关于 Using self-defined Cython code from other Cython code

问题 I am currently trying to optimize my Python program and got started with Cython in order to reduce the function calling overhead and perhaps later on include optimized C-libraries functions. So I ran into the first problem: I am using composition in my code to create a larger class. So far I have gotten one of my Python classes converted to Cython (which was difficult enough). Here's the code: import numpy as np cimport numpy as np ctypedef np.float64_t dtype_t ctypedef np.complex128_t

Haskell Polymorphic Recursion with Composed Maps causes Infinite Type Error

阅读更多关于 Haskell Polymorphic Recursion with Composed Maps causes Infinite Type Error

问题 What is the right way to create a function that can dynamically create composed map? This results in an error (also happens with fmap): createComposedMaps list = accumulate list map where accumulate (x:xs) m = accumulate xs (m.map) accumulate [] m = m The list is irrelevant, it's just there to count the number of compositions. The error I get back is about "cannot construct infinite type": Occurs check: cannot construct the infinite type: a2 ~ [a2] Expected type: (a2 -> b1) -> a2 -> b1 Actual

Inheritance, composition and default methods

阅读更多关于 Inheritance, composition and default methods

问题 It is usually admitted that extending implementations of an interface through inheritance is not best practice, and that composition (eg. implementing the interface again from scratch) is more maintenable. This works because the interface contract forces the user to implement all the desired functionality. However in java 8, default methods provide some default behavior which can be "manually" overriden. Consider the following example : I want to design a user database, which must have the

Haskell Monad bind operator confusion

阅读更多关于 Haskell Monad bind operator confusion

问题 Okay, so I am not a Haskell programmer, but I am absolutely intrigued by a lot of the ideas behind Haskell and am looking into learning it. But I'm stuck at square one: I can't seem to wrap my head around Monads, which seem to be fairly fundamental. I know there are a million questions on SO asking to explain Monads, so I'm going to be a little more specific about what's bugging me: I read this excellent article (an introduction in Javascript), and thought that I understood Monads completely.

Haskell (.) for function with multiple operands

阅读更多关于 Haskell (.) for function with multiple operands

The (.) operator has the signature: (.) :: (b -> c) -> (a -> b) -> a -> c (.) f g x = f $ g x This looks a bit similar to the composition function in primitive recursive functions with one g . I'm not interested in extending the number of g -functions, but (a number of) functions that apply the (.) function on a function g with multiple operands. In other words something like: (..) :: (c -> d) -> (a -> b -> c) -> a -> b -> d (..) f g x y = f $ g x y A search on Hoogle doesn't result in any function. Is there a package that can handle this with an arbitrary number of operands? To answer-ify my

Can I redraw only part of a scene in OpenGL?

阅读更多关于 Can I redraw only part of a scene in OpenGL?

问题 I have a scene composed of many objects. Most of the objects are static, but some objects move. When a move happens it seems like I have to redraw the whole scene. It is possible for me to express some kind of compositing of the scene and redraw only some of the components of the scene? 回答1: Render the static parts to a FBO, blit that as needed to the framebuffer, and render dynamic objects on top. 来源： https://stackoverflow.com/questions/21763661/can-i-redraw-only-part-of-a-scene-in-opengl

Why do we need to set delegate to self? Why isn't it defaulted by the compiler?

阅读更多关于 Why do we need to set delegate to self? Why isn't it defaulted by the compiler?

问题 I think I fully understand the concept of delegation, my question is that when we do: class someViewController : UIViewController, UITableViewDelegate{ } would it ever be possible that we wouldn't want to set tableView.delegate to self ? If there isn't any chance then why is Xcode forcing us to do some extra work here? If there is a chance that tableView.delegate is set to something other than self ...well what is that? Can you please provide some examples? 回答1: When mentioning that tableView

Combining Predicates in F#

阅读更多关于 Combining Predicates in F#

Is there a standard way of logically combining predicates in F#? For example, let's say I have isCar x and isBlue x then I want something that gives me: let isBlueCar x = isCar x && isBlue x But using some sort of composition, rather than invocation, maybe like: let isBlueCar x = isCar && isBlue Preferably, that something would be able to accept a large/arbitrary number of predicates. You could define a combinator. let (<&>) f g = (fun x -> f x && g x) then do let isBlueCar = isCar <&> isBlue let meetsAll preds = preds |> Seq.fold (fun p q x -> p x && q x) (fun _ -> true) // or let meetsAll