Databases
StackOverflow2013
Postsdbo
POIterated substitution in Haskell via the Identity Monad
 

Note that there are some explanatory texts on larger screens.

plurals
  1. POIterated substitution in Haskell via the Identity Monad
    primarykey
    data
    text
    <p>As far as I can tell, one of the big uses of the monadic bind operation is to do variable substitution such as</p> <pre><code>do x &lt;- maybeComputeSomething y &lt;- maybeComputeSomethingElse maybeDoStuff x y </code></pre> <p>This is all well and good if maybeComputeSomething, maybeComputeSomethingElse, and maybeDoStuff all return Maybe values, but I feel like this form of iterated substitution would be useful in computations even if there wasn't the possibility of a returned Nothing. Since the identity is a monad, I would in some sense expect to be able to do something such as</p> <pre><code>do x &lt;- computeSomething y &lt;- computeSomethingElse doStuff x y </code></pre> <p>which would expand to something looking like</p> <pre><code>computeSomething &gt;&gt;= (\x -&gt; computeSomethingElse &gt;&gt;= (\y -&gt; doStuff x y)) </code></pre> <p>and since bind in the identity monad is simply x >>= f = f x, this would act as</p> <pre><code>doStuff computeSomething computeSomethingElse </code></pre> <p>if >>= were treated as the identity monad's bind, but this (unsurprisingly) fails, because after all I never explicitly stated a monad (unlike the Maybe example when the types are clearly of the form Maybe a) and if Haskell assumed the identity monad everywhere the majority of cases would get cluttered up quite fast by the required disambiguations.</p> <p>So this leads me to my question. I want some code that feels like</p> <pre><code>do x &lt;- computeSomething y &lt;- computeSomethingElse doStuff x y </code></pre> <p>and that does the same thing as</p> <pre><code>doStuff computeSomething computeSomthingElse </code></pre> <p>I understand that I could do this by explicitly defining an Id monad which looks like Maybe except without the Nothing possibility, but this takes types a -> Id a, and so doesn't really define the identity monad. Furthermore, my functions now have to have types a -> Id b, whereas I would really like them to still be of the form a -> b. Is there a way to create the repeated substitution feel without introducing complexity in the types involved?</p>
    singulars
    1. PO
      singulars
      1. PTAnswer
    1. This table or related slice is empty.
    1. PTQuestion
    1. This table or related slice is empty.
    1. USBrian Hamrick
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. PO
      singulars
      1. PTAnswer
    2. PO
      singulars
      1. PTAnswer
    1. VO
      singulars
      1. POIterated substitution in Haskell via the Identity Monad
      1. This table or related slice is empty.
      1. VTDownMod
    2. VO
      singulars
      1. POIterated substitution in Haskell via the Identity Monad
      1. This table or related slice is empty.
      1. VTUpMod
    3. VO
      singulars
      1. POIterated substitution in Haskell via the Identity Monad
      1. This table or related slice is empty.
      1. VTUpMod
    1. COForgive my ignorance, but what's wrong with just `let x = computeSomething; y = computeSomethingElse in doStuff x y`?
      singulars
      1. POIterated substitution in Haskell via the Identity Monad
      1. USjho
    2. COReally not much, only that it breaks symmetry with other code, but if that's necessary then it's necessary. I was more wondering whether it's necessary. Also, if I bind to the same variable more than once it looks weird semantically to write `let x = computeSomething; x = workWith x in workMoreWith x` although I guess that would work?
      singulars
      1. POIterated substitution in Haskell via the Identity Monad
      1. USBrian Hamrick
    3. COActually I tested the code `let a = 1; a = a+1 in a` and it didn't compile, which doesn't make sense to me since it should seem to expand to `(\a -> (\a -> a) a+1) 1`, which is fine, but the code `do a <- Just 1; a <- Just (a+1); Just (a+1)` gives `Just 3`, as expected, since that is actually `Just 1 >>= (\a -> Just (a+1) >>= (\a -> Just (a+1)))`. This is a pretty big advantage which comes from the fact that the bind operator separates the lambda expressions enough to allow for reuse of the variable name.
      singulars
      1. POIterated substitution in Haskell via the Identity Monad
      1. USBrian Hamrick
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload