Point-free style and using $

前端 未结 5 1691
生来不讨喜
生来不讨喜 2021-01-11 19:10

How does one combine using $ and point-free style?

A clear example is the following utility function:

times :: Int -> [a] -> [a]
t         


        
相关标签:
5条回答
  • 2021-01-11 19:56

    You can use this combinator: (The colon hints that two arguments follow)

    (.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
    (.:) = (.) . (.)
    

    It allows you to get rid of the n:

    time = concat .: replicate
    
    0 讨论(0)
  • 2021-01-11 19:58

    By extending FUZxxl's answer, we got

    (.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
    (.:) = (.).(.)
    
    (.::) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
    (.::) = (.).(.:)
    
    (.:::) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
    (.:::) = (.).(.::)
    
    ...
    

    Very nice.

    Bonus

    (.:::) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
    (.:::) = (.:).(.:)
    

    Emm... so maybe we should say

    (.1) = .
    
    (.2) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
    (.2) = (.1).(.1)
    
    (.3) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
    (.3) = (.1).(.2)
    -- alternatively, (.3) = (.2).(.1)
    
    (.4) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
    (.4) = (.1).(.3)
    -- alternative 1 -- (.4) = (.2).(.2)
    -- alternative 2 -- (.4) = (.3).(.1)
    

    Even better.

    We can also extend this to

    fmap2 :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
    fmap2 f = fmap (fmap f)
    
    fmap4 :: (Functor f, Functor g, Functor h, functro i) 
       => (a -> b) -> f (g (h (i a))) -> f (g (h (i b)))
    fmap4 f = fmap2 (fmap2 f)
    

    which follows the same pattern.

    It would be even better to have the times of applying fmap or (.) parameterized. However, those fmap or (.)s are actually different on type. So the only way to do this would be using compile time calculation, for example TemplateHaskell.

    For everyday uses, I would simply suggest

    Prelude> ((.).(.)) concat replicate 5 [1,2]
    [1,2,1,2,1,2,1,2,1,2]
    Prelude> ((.).(.).(.)) (*10) foldr (+) 3 [2,1]
    60
    
    0 讨论(0)
  • 2021-01-11 20:06

    You can easily write an almost point-free version with

    times n  =  concat . replicate n
    

    A fully point-free version can be achieved with explicit curry and uncurry:

    times  =  curry $ concat . uncurry replicate
    
    0 讨论(0)
  • 2021-01-11 20:12

    Get on freenode and ask lambdabot ;)

    <jleedev> @pl \n xs -> concat $ replicate n xs
    <lambdabot> (join .) . replicate
    
    0 讨论(0)
  • 2021-01-11 20:12

    In Haskell, function composition is associative¹:

    f . g . h == (f . g) . h == f . (g . h)
    

    Any infix operator is just a good ol' function:

    2 + 3 == (+) 2 3
    f 2 3 = 2 `f` 3
    

    A composition operator is just a binary function too, a higher-order one, it accepts 2 functions and returns a function:

    (.) :: (b -> c) -> (a -> b) -> (a -> c)
    

    Therefore any composition operator can be rewritten as such:

    f . g == (.) f g
    f . g . h == (f . g) . h == ((.) f g) . h == (.) ((.) f g) h
    f . g . h == f . (g . h) == f . ((.) g h) == (.) f ((.) g h)
    

    Every function in Haskell can be partially applied due to currying by default. Infix operators can be partially applied in a very concise way, using sections:

    (-) == (\x y -> x - y)
    (2-) == (-) 2 == (\y -> 2 - y)
    (-2) == flip (-) 2 == (\x -> (-) x 2) == (\x -> x - 2)
    (2-) 3 == -1
    (-2) 3 == 1
    

    As composition operator is just an ordinary binary function, you can use it in sections too:

    f . g == (.) f g == (f.) g == (.g) f
    

    Another interesting binary operator is $, which is just function application:

    f x == f $ x
    f x y z == (((f x) y) z) == f x y z
    f(g(h x)) == f $ g $ h $ x == f . g . h $ x == (f . g . h) x
    

    With this knowledge, how do I transform concat $ replicate n xs into point-free style?

    times n xs = concat $ replicate n xs
    times n xs = concat $ (replicate n) xs
    times n xs = concat $ replicate n $ xs
    times n xs = concat . replicate n $ xs
    times n    = concat . replicate n
    times n    = (.) concat (replicate n)
    times n    = (concat.) (replicate n) -- concat is 1st arg to (.)
    times n    = (concat.) $ replicate n
    times n    = (concat.) . replicate $ n
    times      = (concat.) . replicate
    

    ¹Haskell is based on category theory. A category in category theory consists of 3 things: some objects, some morphisms, and a notion of composition of morphisms. Every morphism connects a source object with a target object, one-way. Category theory requires composition of morphisms to be associative. A category that is used in Haskell is called Hask, whose objects are types and whose morphisms are functions. A function f :: Int -> String is a morphism that connects object Int to object String. Therefore category theory requires Haskell's function compositions to be associative.

    0 讨论(0)
提交回复
热议问题