function-composition

Just wondering if there's a syntax shortcut for taking two procs and joining them so that output of one is passed to the other, equivalent to: a = ->(x) { x + 1 } b = ->(x) { x * 10 } c = ->(x) { b.( a.( x ) ) } This would come in handy when working with things like method(:abc).to_proc and :xyz.to_proc More sugar, not really recommended in production code class Proc def *(other) ->(*args) { self[*other[*args]] } end end a = ->(x){x+1} b = ->(x){x*10} c = b*a c.call(1) #=> 20 a = Proc.new { |x| x + 1 } b = Proc.new { |x| x * 10 } c = Proc.new { |x| b.call(a.call(x)) } you could create a union

Is there a way to chain functions like withCString ? By that I mean any function that looks something like f :: Foo -> (CFoo -> IO a) -> IO a . For example, lets say there is a function cFunc :: CString -> CFoo -> CBar -> IO () Usualy, I would do something like: haskellFunc string foo bar = withCString string $ \ cString -> withCFoo foo $ \ cFoo -> withCBar bar $ \ cBar -> cFunc cString cFoo cBar But i would like to do something like: haskellFunc = (withCString |.| withCFoo |.| withCBar) cFunc with some appropriate composition operator |.| . I'm writing library with a lot of C bindings, and

I'm studying dynamical systems, particularly the logistic family g(x) = cx(1-x), and I need to iterate this function an arbitrary amount of times to understand its behavior. I have no problem iterating the function given a specific point x_0, but again, I'd like to graph the entire function and its iterations, not just a single point. For plotting a single function, I have this code: import numpy as np import scipy as sp import matplotlib.pyplot as plt def logplot(c, n = 10): dt = .001 x = np.arange(0,1.001,dt) y = c*x*(1-x) plt.plot(x,y) plt.axis([0, 1, 0, c*.25 + (1/10)*c*.25]) plt.show() I

Do anyone can give example of function composition? This is the definition of function composition operator? (.) :: (b -> c) -> (a -> b) -> a -> c f . g = \x -> f (g x) This shows that it takes two functions and return a function but i remember someone has expressed the logic in english like boy is human -> ali is boy -> ali is human What this logic related to function composition? What is the meaning of strong binding of function application and composition and which one is more strong binding than the other? Please help. Thanks. ( Edit 1: I missed a couple components of your question the

I want to do something fairly simple; I am using the operator (++) with Data.Map insertWith , and it works fine, but I want to eliminate duplicates in the value created, so want to compose it with nub. I tried (nub (++)), (nub $ (++)), (nub . (++)), all to no avail, in that the type of (++) does not match the expected type of nub ( [a] ). I could of course define an auxiliary function or a lambda, but I think that probably there is a composition which would be clearer. Hints please! You can write this as ((nub .) .) (++) Example: Prelude Data.List> ((nub .) .) (++) [1,2,3] [3,4,5] [1,2,3,4,5]