Send Beginners mailing list submissions to beginners@haskell.org To subscribe or unsubscribe via the World Wide Web, visit http://www.haskell.org/mailman/listinfo/beginners or, via email, send a message with subject or body 'help' to beginners-requ...@haskell.org
You can reach the person managing the list at beginners-ow...@haskell.org When replying, please edit your Subject line so it is more specific than "Re: Contents of Beginners digest..." Today's Topics: 1. Re: help with types and composition (Geoffrey Marchant) 2. Re: Help with "20 intermediate haskell exercises" (Patrick LeBoutillier) 3. When did Haskell become fun for you? (aditya siram) 4. Re: Help with "20 intermediate haskell exercises" (Daniel Fischer) 5. Re: help with types and composition (Dan Douglas) 6. Re: help with types and composition (Daniel Fischer) ---------------------------------------------------------------------- Message: 1 Date: Sat, 4 Jul 2009 12:53:27 -0600 From: Geoffrey Marchant <geoffrey.march...@gmail.com> Subject: Re: [Haskell-beginners] help with types and composition To: Troy Pracy <tro...@gmail.com> Cc: beginners@haskell.org Message-ID: <79e6290e0907041153k45938b7fm2043facbac7ac...@mail.gmail.com> Content-Type: text/plain; charset="iso-8859-1" Found it: compose21 = Data.Function.on Which makes the complete list, with Thomas Davie's changes: hook = liftA2 fmap mhook = <*> fork = liftA2 dyfork = liftA2 . liftA2 compose12 = fmap . fmap compose21 = on On Sat, Jul 4, 2009 at 3:15 AM, Geoffrey Marchant < geoffrey.march...@gmail.com> wrote: > Functions in Haskell aren't distinguished as 1-arg of 2-arg functions. > Usually we don't even think of them as such -- rather we think of the type > of the function or operator. > But there is a wide array of combinators available: > > K = const > I = id > B = (.) > C = flip > S = Monad.ap -- instance Monad (->) a - the Reader Monad > W = Monad.join -- also for the Reader Monad > Y = Control.Monad.Fix.fix > > and the list goes on and on... Using only S and K, a great many functions > can be expressed, though it does get rather ugly. > > Perhaps the most significant reason that Haskell doesn't have more > composition operators is that composing functions is the least part of what > we compose. Using some standard class functions often yields exactly what > you're looking for: > > hook = liftM2 (.) > mhook = ap > fork = liftM2 > dyfork = liftM2 . liftM2 > compose12 = (.) (.) (.) -- as previously shown > > Written in this form, the first four become far more general: > > "hook" is function composition within a monad; > "mhook" is function application within a monad; > "fork" raises a function for application on monads; and > "dyfork" -- absolutely beautiful, BTW -- raises a function for application > upon nested monads. > > BTW, if anyone has a reasonably concise form for a point-free compose21, > I'd like to see it. > > > On Fri, Jul 3, 2009 at 7:15 PM, Troy Pracy <tro...@gmail.com> wrote: > >> I've just started learning Haskell and I've been wondering about this >> issue as well. I can usually work out a point-free version by carefullty >> deriving it step-by-step, but I was wondering if Haskell had composition >> operators/functions for dealing with the various forms of composition where >> a 2-arg function is involved. >> >> I've played around with J (APL's successor) a little and noticed that J >> has various options for composing two functions (Ponit-free, or "implicit" >> style is very important in J). Some of the distinctions have to do with J's >> native array operations and aren't relevant here, but many are. Here are >> Haskell versions... >> (note: "monadic" below isn't used in the Haskell/CT sense - "monadic" and >> "dyadic" in J jsut refer to how many arguments an operator acts on) >> >> -- hook is the J dyadic hook as a function. >> hook :: (a->b->c) -> (d->b) -> a -> d -> c >> hook f g = \x y -> f x (g y) >> -- J's monadic hook >> mhook :: (a->b->c) -> (a->b) -> a -> c >> mhook f g = \x -> (hook f g) x x >> -- J's monadic fork >> fork :: (a->b->c) -> (d->a) -> (d->b) -> d -> c >> fork f g h = \x -> f (g x) (h x) >> -- J's dyadic fork >> dyfork :: (a->b->c) -> (d->e->a) -> (d->e->b) -> d -> e -> c >> dyfork f g h = \x y -> f (g x y) (h x y) >> -- J's dyadic @ or @: - composition of 1-arg fn with 2-arg fn >> compose12 :: (a->b) -> (c->d->a) -> c -> d -> b >> compose12 f g = \x y -> f (g x y) >> (@:) = compose12 >> {- J's dyadic & or &: - composition of 2-arg fn with 1-arg fn, resulting >> in a >> 2-arg fn (f&:g) which applies g to *both* args before passing them to f. >> Haskell's composition operator and partial application allow a >> composition >> of such fns (f . g) where g is applied only to the first arg. -} >> compose21 :: (a->a->b) -> (c->a) -> c -> c -> b >> compose21 f g = \x y -> f (g x) (g y) >> (&:) = compose21 >> >> >> / /I know a lot of Haskell is written in point-free style and I would have >> thought Haskell would have operators for some of this, but judging from the >> previous responses, it looks like it might not. That surprises me, since >> some of this seems to crop up a lot, but as I said I've just started >> learning Haskell, so I guess I'll have to give myself some time to absorb >> the Haskell way of doing things. >> _______________________________________________ >> Beginners mailing list >> Beginners@haskell.org >> http://www.haskell.org/mailman/listinfo/beginners >> >> > -------------- next part -------------- An HTML attachment was scrubbed... URL: http://www.haskell.org/pipermail/beginners/attachments/20090704/871bec0a/attachment-0001.html ------------------------------ Message: 2 Date: Sun, 5 Jul 2009 15:05:20 -0400 From: Patrick LeBoutillier <patrick.leboutill...@gmail.com> Subject: Re: [Haskell-beginners] Help with "20 intermediate haskell exercises" To: beginners@haskell.org Message-ID: <b217a64f0907051205l15f4f44bm328ff7feb87df...@mail.gmail.com> Content-Type: text/plain; charset=ISO-8859-1 Hi, Thanks for the help. I figured it out after that. I'm having a hard time with the other exercises though, I'm currently stuck at 14: class Misty m where banana :: (a -> m b) -> m a -> m b unicorn :: a -> m a -- Exercise 14 -- Relative Difficulty: 6 moppy :: (Misty m) => [a] -> (a -> m b) -> m [b] moppy = error "todo" Does anyone know if the solutions are posted anywhere? Patrick On Fri, Jul 3, 2009 at 12:08 PM, Daniel Fischer<daniel.is.fisc...@web.de> wrote: > Am Freitag 03 Juli 2009 17:58:22 schrieb Patrick LeBoutillier: >> Hi, >> >> I'm running through these Haskell exercises: >> >> >> http://dibblego.wordpress.com/2008/09/18/20-intermediate-haskell-exercises/ >> >> and I'm stuck at number 9: >> >> >> class Misty m where >> banana :: (a -> m b) -> m a -> m b >> unicorn :: a -> m a >> >> -- Exercise 9 >> -- Relative Difficulty: 6 >> instance Misty ((->) t) where >> banana = ??? >> unicorn x = (\t -> x) >> >> >> I can picture it when m is "[]" or "Maybe", but I can't wrap my head >> around the banane implementation for "((->) t)". >> I can see that this somewhat looks like a Monad, with unicorn = return >> and banana = (flip >>=) or something. Perhaps some kind of reader >> Monad? > > Exactly. > > You want > > banana :: (a -> (t -> b)) -> (t -> a) -> (t -> b) > banana fun af = \tval -> ??? > > There's not much choice what you can do with those types and data. > >> Can anyone offer any insight? >> >> >> Patrick > > _______________________________________________ > Beginners mailing list > Beginners@haskell.org > http://www.haskell.org/mailman/listinfo/beginners > -- ===================== Patrick LeBoutillier Rosemère, Québec, Canada ------------------------------ Message: 3 Date: Sun, 5 Jul 2009 14:16:03 -0500 From: aditya siram <aditya.si...@gmail.com> Subject: [Haskell-beginners] When did Haskell become fun for you? To: beginners <beginners@haskell.org> Message-ID: <594f78210907051216n46fdd655qe32d41ef078b2...@mail.gmail.com> Content-Type: text/plain; charset="iso-8859-1" Hi all, I have been pursuing Haskell for about a year now and the community has been awesome. The learning curve has been ( and is still ) steep for me because of the sheer density of the concepts, but it has changed the way I think about programming. Relating it to music, Haskell is like jazz, the concepts are heady and the entry into that world requires a high level of patience and discipline. But in the end, you want to zone out and play. How long was it before you could just play Haskell? Thanks ... -deech -------------- next part -------------- An HTML attachment was scrubbed... URL: http://www.haskell.org/pipermail/beginners/attachments/20090705/aa5558c1/attachment-0001.html ------------------------------ Message: 4 Date: Sun, 5 Jul 2009 21:44:56 +0200 From: Daniel Fischer <daniel.is.fisc...@web.de> Subject: Re: [Haskell-beginners] Help with "20 intermediate haskell exercises" To: beginners@haskell.org Message-ID: <200907052144.56436.daniel.is.fisc...@web.de> Content-Type: text/plain; charset="iso-8859-1" Am Sonntag 05 Juli 2009 21:05:20 schrieb Patrick LeBoutillier: > Hi, > > Thanks for the help. I figured it out after that. I'm having a hard > time with the other exercises though, I'm currently stuck at 14: > > > class Misty m where > banana :: (a -> m b) -> m a -> m b > unicorn :: a -> m a > > -- Exercise 14 > -- Relative Difficulty: 6 > moppy :: (Misty m) => [a] -> (a -> m b) -> m [b] > moppy = error "todo" moppy [] mop = ? moppy (a:as) mop = (mop a) ?? (moppy as mop) use (among other things) banana and unicorn to replace the question marks > > > Does anyone know if the solutions are posted anywhere? They're (under different names) in the standard libraries :) > > > Patrick ------------------------------ Message: 5 Date: Mon, 06 Jul 2009 06:53:01 CDT From: Dan Douglas <doug0...@metnet.edu> Subject: Re: [Haskell-beginners] help with types and composition To: beginners@haskell.org Message-ID: <200907061153.n66br1f4021...@tove.metnet.edu> Content-Type: TEXT/plain; CHARSET=US-ASCII Hello everyone! first post here. I'm working through YAHT and Real World Haskell sort of in parallel. I have a somewhat related question. Assume we have a binary operator which is not a higher order function. The "greater than" relation for example: Prelude List> :t (>) (>) :: forall a. (Ord a) => a -> a -> Bool Type classes and variables make sense - I assume since we have quantifiers, the type classes must be essentially predicates, and the type variables are bound to them as expected. Also I assume whenever we see (a -> b) this means roughly f:(<domain> -> <codomain>) a -> a -> Bool could therefore mean either: "a function whose domain is an 'a' and whose codomain is a function from a to bool"; or "a function which takes a function from type 'a' to 'a' and returns a bool. According to YAHT: "NOTE The parentheses are not necessary; in function types, if you have a -> b -> y it is assume that b -> y is grouped. If you want the other way, with a -> b grouped, you need to put parentheses around them." I'm confused by this. A function which takes multiple arguments should be equivalent to a predicate bound to some n-tuple. Or in this case of a binary infix operator, equivalent to a prefix operator which takes a tuple. But, (a, a) is not equivalent to (a -> a), and (a -> Bool) just doesn't make sense as a range. It should be something like: (>) :: forall a. (Ord a) => (a, a) -> Bool Someone on freenode told me that if you had: foo :: a -> b bar :: b -> c baz :: c -> d and: bork = (baz . bar . foo) then: bork :: a -> d Which, if correct means Haskell should always chain types for first-order functions. And since (>) is transitive, it should satisfy ∀x∀y∀z(((x,y) ∈ R & (y,z) ∈ R) -> (x,z) ∈ R) and omit the case for (y,z). How it is possible to express a function which takes multiple arguments (or any first-order function at all) with more than one arrow/map symbol? How does this even make sense? It gets even worse with more complicated examples: Prelude List> :t foldl foldl :: forall a b. (a -> b -> a) -> a -> [b] -> a Prelude List> :t (>>=) (>>=) :: forall (m :: * -> *) a b. (Monad m) => m a -> (a -> m b) -> m b How do the non-existent associativity rules make complex function types seemingly without enough parentheses have unique meaning? Nearly every example in every tutorial on types I can find has this unexplained phenomenon, or I'm really not reading carefully. ------------------------------ Message: 6 Date: Mon, 6 Jul 2009 14:44:31 +0200 From: Daniel Fischer <daniel.is.fisc...@web.de> Subject: Re: [Haskell-beginners] help with types and composition To: beginners@haskell.org Message-ID: <200907061444.31275.daniel.is.fisc...@web.de> Content-Type: text/plain; charset="iso-8859-1" Am Montag 06 Juli 2009 13:53:01 schrieb Dan Douglas: > Hello everyone! first post here. I'm working through YAHT and Real World > Haskell sort of in parallel. I have a somewhat related question. > > Assume we have a binary operator which is not a higher order function. The > "greater than" relation for example: > > Prelude List> :t (>) > (>) :: forall a. (Ord a) => a -> a -> Bool > > Type classes and variables make sense - I assume since we have quantifiers, > the type classes must be essentially predicates, and the type variables are > bound to them as expected. Also I assume whenever we see (a -> b) this > means roughly f:(<domain> -> <codomain>) Correct. > > a -> a -> Bool could therefore mean either: "a function whose domain is an > 'a' and whose codomain is a function from a to bool"; Yes, that's it. > or "a function which > takes a function from type 'a' to 'a' and returns a bool. That would be the type (a -> a) -> Bool. > > According to YAHT: > > "NOTE The parentheses are not necessary; in function types, if you > have a -> b -> y it is assume that b -> y is grouped. If you want the > other way, with a -> b grouped, you need to put parentheses around > them." In short: (->) is right associative, a -> b -> c -> d === a -> (b -> (c -> d)) > > I'm confused by this. A function which takes multiple arguments should be > equivalent to a predicate bound to some n-tuple. Or in this case of a > binary infix operator, equivalent to a prefix operator which takes a tuple. Correct. > But, (a, a) is not equivalent to (a -> a), Indeed it isn't, the two sets don't even have the same cardinality (except a contains only one element). But (a -> a) -> Bool is *not* equivalent to a -> (a -> Bool). > and (a -> Bool) just doesn't make sense as a range. But it does. (a -> Bool) is a perfectly reasonable set/Haskell type. Functions whose result is a function are very common in functional programming. > It should be something like: > > (>) :: forall a. (Ord a) => (a, a) -> Bool Note that, (ignoring _|_ and partial functions), the types ((a,b) -> c) and (a -> (b -> c)) are isomorphic. The isomorphism is given by curry :: ((a,b) -> c) -> (a -> (b -> c)) curry f = \x y -> f (x,y) and uncurry :: (a -> (b -> c)) -> ((a,b) -> c) uncurry g = \(x,y) -> g x y > > Someone on freenode told me that if you had: > > foo :: a -> b > bar :: b -> c > baz :: c -> d > > and: > > bork = (baz . bar . foo) > > then: > > bork :: a -> d Yup. > > Which, if correct means Haskell should always chain types for first-order > functions. And since (>) is transitive, it should satisfy > ∀x∀y∀z(((x,y) ∈ R & (y,z) ∈ R) -> (x,z) > ∈ R) and omit the case for (y,z). ??? > > How it is possible to express a function which takes multiple arguments (or > any first-order function at all) with more than one arrow/map symbol? How > does this even make sense? > > It gets even worse with more complicated examples: > > Prelude List> :t foldl > foldl :: forall a b. (a -> b -> a) -> a -> [b] -> a > > Prelude List> :t (>>=) > (>>=) > > :: forall (m :: * -> *) a b. (Monad m) => m a -> (a -> m b) -> m b > > How do the non-existent associativity rules make complex function types > seemingly without enough parentheses have unique meaning? The associativity rules exist: (->) associates to the right. Hence, fully parenthesised: foldl :: (a -> (b -> a)) -> (a -> ([b] -> a)) Due to the right associativity, you can omit three pairs of parentheses. > > Nearly every example in every tutorial on types I can find has this > unexplained phenomenon, or I'm really not reading carefully. ------------------------------ _______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners End of Beginners Digest, Vol 13, Issue 4 ****************************************