pointfree

I believe I understand fmap . fmap for Functors, but on functions it's hurting my head for months now. I've seen that you can just apply the definition of (.) to (.) . (.) , but I've forgot how to do that. When I try it myself it always turns out wrong: (.) f g = \x -> f (g x) (.) (.) (.) = \x -> (.) ((.) x) \x f -> (.) ((.) x) f \x f y -> (((.)(f y)) x) \x f y g-> (((.)(f y) g) x) \x f y g-> ((f (g y)) x) \x f y g-> ((f (g y)) x):: t2 -> (t1 -> t2 -> t) -> t3 -> (t3 -> t1) -> t If "just applying the definition" is the only way of doing it, how did anybody come up with (.) . (.) ? There must

I know that in some languages (Haskell?) the striving is to achieve point-free style, or to never explicitly refer to function arguments by name. This is a very difficult concept for me to master, but it might help me to understand what the advantages (or maybe even disadvantages) of that style are. Can anyone explain? I believe the purpose is to be succinct and to express pipelined computations as a composition of functions rather than thinking of threading arguments through. Simple example (in F#) - given: let sum = List.sum let sqr = List.map (fun x -> x * x) Used like: > sum [3;4;5] 12 >

I try to write a program which will count the frequency of each element in a list. In: "aabbcabb" Out: [("a",3),("b",4),("c",1)] You can view my code in the following link: http://codepad.org/nyIECIT2 In this code the output of unique function would be like this In: "aabbcabb" Out: "abc" Using the output of unique we wil count the frequency of the target list. You can see the code here also: frequencyOfElt xs=ans where ans=countElt(unique xs) xs unique []=[] unique xs=(head xs):(unique (filter((/=)(head xs))xs)) countElt ref target=ans' where ans'=zip ref lengths lengths=map length $ zipWith($

I'm trying to write a variadic function composition function. Which is basically the (.) except that the second argument function is variadic. This should allow expressions like: map even . zipWith (+) or just map even . zipWith Currently what I've reached works if I add IncoherentInstances and requires a non-polymorphic instance for the first argument function. {-# LANGUAGE FlexibleInstances, OverlappingInstances, MultiParamTypeClasses, FunctionalDependencies, UndecidableInstances, KindSignatures #-} class Comp a b c d | c -> d where comp :: (a -> b) -> c -> d instance Comp a b (a :: *) (b ::

I am learning Haskell. I'm sorry for asking a very basic question but I cant seem to find the answer. I have a function f defined by : f x = g x x where g is an already defined function of 2 arguments. How do I write this pointfree style? Edit : without using a lambda expression. Thanks ehird f can be written with Control.Monad.join : f = join g join on the function monad is one of the primitives used when constructing point-free expressions , as it cannot be defined in a point-free style itself (its SKI calculus equivalent, SII — ap id id in Haskell — doesn't type) . This is known as "W"