diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,33 @@ +Copyright (c) 2009, 2010, 2011, 2012, wren ng thornton. +ALL RIGHTS RESERVED. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the copyright holders nor the names of + other contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,7 @@ +#!/usr/bin/env runhaskell + +module Main (main) where +import Distribution.Simple + +main :: IO () +main = defaultMain diff --git a/pointless-fun.cabal b/pointless-fun.cabal new file mode 100644 --- /dev/null +++ b/pointless-fun.cabal @@ -0,0 +1,50 @@ +---------------------------------------------------------------- +-- wren ng thornton ~ 2012.01.06 +---------------------------------------------------------------- + +Name: pointless-fun +Version: 1.1.0 +Stability: provisional +Homepage: http://code.haskell.org/~wren/ +Author: wren ng thornton +Maintainer: wren@community.haskell.org +Copyright: Copyright (c) 2009--2012 wren ng thornton +License: BSD3 +License-File: LICENSE + +Category: Combinators, Composition, Utils +Synopsis: Some common point-free combinators. +Description: Some common point-free combinators. + +-- By and large Cabal >=1.2 is fine; but >= 1.6 gives tested-with: +-- and source-repository:. +Cabal-Version: >= 1.6 +Build-Type: Simple +Tested-With: GHC == 6.12.1, GHC == 6.12.3 + +Source-Repository head + Type: darcs + Location: http://community.haskell.org/~wren/pointless-fun + +---------------------------------------------------------------- +Flag base4 + Default: True + Description: base-4.0 emits "Prelude deprecated" messages in + order to get people to be explicit about which + version of base they use. + +-- TODO: add flags for compiling against haskell98 or haskell2010 +-- instead of base? + +---------------------------------------------------------------- +Library + Hs-Source-Dirs: src + Exposed-Modules: Data.Function.Pointless + + if flag(base4) + Build-Depends: base >= 4 && < 5 + else + Build-Depends: base < 4 + +---------------------------------------------------------------- +----------------------------------------------------------- fin. diff --git a/src/Data/Function/Pointless.hs b/src/Data/Function/Pointless.hs new file mode 100644 --- /dev/null +++ b/src/Data/Function/Pointless.hs @@ -0,0 +1,147 @@ +{-# OPTIONS_GHC -Wall -fwarn-tabs #-} +---------------------------------------------------------------- +-- 2012.01.06 +-- | +-- Module : Data.Function.Pointless +-- Copyright : Copyright (c) 2009--2012 wren ng thornton +-- License : BSD +-- Maintainer : wren@community.haskell.org +-- Stability : provisional +-- Portability : Haskell98 +-- +-- Pointless fun :) +---------------------------------------------------------------- +module Data.Function.Pointless + ( + -- * Multicomposition + -- | Based on . + -- These combinators allow you to easily modify the types of a + -- many-argument function with syntax that looks like giving + -- type signatures. For example, + -- + -- > foo :: A -> B -> C + -- > + -- > albert :: A -> X + -- > beth :: B -> Y + -- > carol :: C -> Z + -- > + -- > bar :: X -> Y -> Z + -- > bar = foo $:: albert ~> beth ~> carol + ($::), (~>), (!~>) + + -- * Composition for arity 2 + , (.:), (.^) + + -- * Strict composition + , (.!) + ) where +---------------------------------------------------------------- +---------------------------------------------------------------- +{- TODO: actually put this in. +-- Note: @pl had nothing to do with the invention of this combinator. I constructed it by hand after noticing a common pattern. -- Cale + +swing :: (((a -> b) -> b) -> c -> d) -> c -> a -> d +swing = flip . (. flip id) +swing f = flip (f . runCont . return) +swing f c a = f ($ a) c + +-- Some examples of use: + +swing map :: forall a b. [a -> b] -> a -> [b] +swing any :: forall a. [a -> Bool] -> a -> Bool +swing foldr :: forall a b. b -> a -> [a -> b -> b] -> b +swing zipWith :: forall a b c. [a -> b -> c] -> a -> [b] -> [c] +swing find :: forall a. [a -> Bool] -> a -> Maybe (a -> Bool) + -- applies each of the predicates to the given value, returning the first predicate which succeeds, if any +swing partition :: forall a. [a -> Bool] -> a -> ([a -> Bool], [a -> Bool]) +-} +---------------------------------------------------------------- + + +-- | Lift a function for multicomposition. This is like the @::@ +-- of a type signature. + +($::) :: (a -> b) -> ((a -> b) -> (c -> d)) -> (c -> d) +($::) = flip ($) +{-# INLINE ($::) #-} +infixl 1 $:: + + +-- | Multicompose a function on the appropriate argument. This is +-- like the @->@ arrows in a type signature. + +(~>) :: (a -> b) -> (c -> d) -> ((b -> c) -> (a -> d)) +f ~> g = (. f) . (g .) +{-# INLINE (~>) #-} +infixr 2 ~> + + +-- | Multicompose a function on the appropriate argument, calling +-- the left function eagerly. That is, the resulting function will +-- be strict in @a@ if the left argument is strict in @a@ (assuming +-- the final function of the multicomposition, the one applied to +-- the return value, is also strict). + +(!~>) :: (a -> b) -> (c -> d) -> ((b -> c) -> (a -> d)) +f !~> g = (.! f) . (g .) +{-# INLINE (!~>) #-} +infixr 2 !~> + + +---------------------------------------------------------------- +-- | Binary composition: pass two args to the right argument before +-- composing. +-- +-- > (f .: g) x y = f (g x y) +-- +-- or, +-- +-- > f .: g = curry (f . uncurry g) +-- +-- This is the same as the common idiom @(f .) . g@ but more easily +-- extended to multiple uses, due to the fixity declaration. + +(.:) :: (c -> d) -> (a -> b -> c) -> (a -> b -> d) +(.:) = (.) . (.) +{-# INLINE (.:) #-} +infixl 8 .: + + +-- | Secondary composition: compose the right argument on the second +-- arg of the left argument. +-- +-- > (f .^ g) x y = f x (g y) + +(.^) :: (a -> c -> d) -> (b -> c) -> (a -> b -> d) +(.^) = flip .: (.) . flip +{-# INLINE (.^) #-} +infix 9 .^ + + +-- | Function composition which calls the right-hand function +-- eagerly; i.e., making the left-hand function strict in its first +-- argument. +-- +-- > (f .! g) x = f $! g x +-- +-- This defines the composition for the sub-category of strict +-- Haskell functions. If the 'Functor' class were parameterized by +-- the domain and codomain categories (e.g., a regular @Functor f@ +-- would be @CFunctor (->) (->) f@ instead) then this would allow +-- us to define functors @CFunctor (->) (!->) f@ where +-- @fmap f . fmap g = fmap (f .! g)@. + +(.!) :: (b -> c) -> (a -> b) -> a -> c +(.!) = (.) . ($!) +{-# INLINE (.!) #-} +infixr 9 .! +-- For some reason this definition is significantly faster than the +-- pointful version in the documentation. Even after INLINE. Who knew? +-- +-- cf vs @($!) .: (.)@ == @\f g x -> f . g $! x@ which stictifies +-- the first argument of RH-function. However, this doesn't behave +-- the way you may think it should; i.e., it isn't compositional +-- in the way you think it should be. + +---------------------------------------------------------------- +----------------------------------------------------------- fin.