Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://mail.haskell.org/cgi-bin/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: Code golf (Tilmann)
----------------------------------------------------------------------
Message: 1
Date: Sat, 21 May 2016 16:03:50 +0200
From: Tilmann <t_g...@gmx.de>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Code golf
Message-ID: <945a8287-ddd0-4ef6-d105-a975a31dc...@gmx.de>
Content-Type: text/plain; charset="utf-8"; Format="flowed"
Thank you so much! That was very enlightening!
Am 20.05.16 um 21:09 schrieb Silent Leaf:
> yes, this definition of bind2 looks kinda "frightening". if fact it's
> simpler than it looks: (.::) merely takes two functions, then the
> three next parameters applied to the result of this special
> composition, will be applied to the second parameter, before the
> result be given as input for the first parameter.
>
> it must be compared with (.), which only allows the second function to
> get one single parameter, before the result of this application
> becomes the first parameter of the first function of the composition,
> after which any supplementary parameter applied to the whole will go
> to the left function:
> > (left . right) a b c d e = left (right a) b c d e
> By comparison:
> > (left .:: right) a b c d e = left (right a b c) d e
>
> in the first equation above, defining (.), let's say `right` has type
> a -> b -> c -> d. then `left` will get as first parameter, a partial
> function, aka (right a :: b -> c -> d). but, in the second equation,
> `right` gets all of its three parameters (a, b and c), returning a
> value of type `d`, before `left` gets said result-value as its own
> first parameter, and then possibly get other parameters of its own
> (here, d and e).
>
> thus with bind2:
> bind2 f ma mb = (join .:: liftM2) f ma mb = join (liftM2 f ma mb)
>
> Now, in my opinion, the point-free style definition of (.::), aka
> composition of (.) with itself, three time, is way overkill (better
> use a lambda to clarify the purpose), but maybe is it better in terms
> of performance or whatever. it's certainly shorter, and when you know
> what it entails, it's simple, but it can easily frighten anyone else.
>
> if one wants to understand this (subjectively overkill) point-free
> definition,
> (.::) = (.) . (.) .(.)
> better do the opposite action that leads to point free style, aka,
> better name and reveal variables. To make it more readable, i'll
> define first:
> dot = (.)
> f .:: g = (dot . dot . dot) f g
> = (dot . dot) (dot f) g
> = (dot . dot) (f .) g
> = dot (dot (f .)) g
> = dot ((f .).) g
> = ((f . ) .) . g
> this expansion (or whatever you call it), solely uses the basic rule
> (a . b) c = a (b c), or, with "pollution" around, (w . a . b) c d = (w
> . a) (b c) d = w (a (b c)) d.
> in the case of b = dot = (.), and c = f, you get (dot f) = (f .), aka,
> partially applied composition of f with "something" (the implicit
> parameter).
>
> now, this weird
> ((f .) .) . g = f .:: g
> is as we said, directly equivalent to
> \f g a b c -> f (g a b c)
> indeed:
> > f .:: g
> > = (((f .) .) . g) a b c -- structure equivalent to (x.g) a b c
> > = ((f .) .) (g a) b c -- to (w .) (g a) b c [with x = (w.) and w
> = (f .)]
> > = ((f .) . (g a)) b c -- to (w . (g a)) b c = (w . v) a b
> > = (f .) ((g a) b) c -- to (f.) (v b) c = (f.) (g a b) c -- as v
> = g a
> > = (f . (g a b)) c -- to (f . k) c [with k = (g a b)]
> > = f ((g a b) c) = f (g a b c) -- to f (k c)
> which is what we thought (.::) was.
> simply put, every dot in
> > (((f .) .) . g) a b c
> will allow, first, with the dot to the right, that g, as right side of
> a function composition, take the first argument that follows (here a),
> becoming a binary partial app (g a);
> > ((f .) . (g a)) b c -- first dot was used
> then, this binary partial app (g a) being now the right side of
> another composition (second, aka middle dot), will get a new argument
> of its own (b), making it an unary partial app (g a b)
> > (f . (g a b)) c -- second dot was used
> and the last dot the the extreme left, at last, allows (g a b) to take
> its last argument before finally the result be inputed to the function f:
> > f (g a b c)
>
> I hope it clarifies everything for anyone interested and that didn't
> know it already, of course.
>
>
>
> Le vendredi 20 mai 2016, Tilmann <t_g...@gmx.de
> <mailto:t_g...@gmx.de>> a ?crit :
> > Thank you for the references. I like the term 'bind2'. I had a look
> at Prelude.Generalized. Wow!
> >
> > bind2 = join .:: liftM2;
> > (.::) = (.) . (.) . (.)
> >
> > Am 20.05.16 um 04:50 schrieb Silent Leaf:
> >
> > The interesting bit is, the following function > \? ma mb -> join
> (pure ? <*> ma <*> mb) which i like to write as follows using ((&) =
> flip ($)) [infixl 1] > \? ma mb -> pure ? <*> ma <*> mb & join (but
> it's just personal taste) is very similar to (=<<), aka (flip (>>=))
> except the first argument (here ?) has type (a -> b -> m c) instead of
> (a -> m b), and of course the lambda above takes an added argument too
> (mb). Some could call it "bind2" (even if it's the flipped version of
> (>>=) that is being generalized), and well, some do. For those
> interested, there are several options are available to import it
> (along possibly with some of its siblings), from several libraries.
> (List possibly non exhaustive.)
> http://hackage.haskell.org/package/prelude-generalize-0.4/docs/Prelude-Generalize.html#v:bind2
>
> http://hackage.haskell.org/package/SimpleH-1.2/docs/Algebra-Monad.html#v:bind2
>
> http://hackage.haskell.org/package/definitive-base-2.3/docs/Algebra-Monad-Base.html#v:bind2
>
> your problem become btw then: > doIt = bind2 update a b
> >
> > _______________________________________________
> > Beginners mailing list
> > Beginners@haskell.org <mailto:Beginners@haskell.org>
> > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
> >
>
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://mail.haskell.org/pipermail/beginners/attachments/20160521/335a7db9/attachment-0001.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 95, Issue 28
*****************************************
