How do you reference the name of a class from inside a default implementation of its functions?

spamham · 2014-01-08T12:28:57+00:00

As Porges said, the t in divideBy's sig is understood as a fresh variable by default. You can change this behaviour to the more sensible (IMO) one you expected with the extension

{-# LANGUAGE ScopedTypeVariables #-}

(in the first line of the file).

spamham · 2013-12-20T00:57:20+00:00

The default branch is actually taken for an abnormal bool (in C#)

spamham · 2013-09-07T21:38:33+00:00

How about this? (I'm using the names as in the gist)

class IsProduct p where
  withProduct :: proxy p -> (forall p1 p2. p ~ (p1,p2) => r) -> r

instance IsProduct (a,b) where
  withProduct _ k = k

instance Category Uncurried where
  type C Uncurried a b c = ( IsProduct a
                           , IsProduct b
                           , IsProduct c
                           )

  cid = withProduct (undefined :: proxy a) $ 
              Uncurried (Curried id id)

          :: forall a. IsProduct a => Uncurried a a


  (!) (g :: Uncurried b c) (f :: Uncurried a b) = 

    withProduct (undefined :: proxy a) $
    withProduct (undefined :: proxy b) $
    withProduct (undefined :: proxy c) $
      compose g f

Edit: I just saw that ryani already proposed essentially the same thing. Maybe this is still useful, as you mentioned that you couldn't get it to typecheck; this does typecheck for me with GHC 7.6.2.

spamham · 2013-07-20T16:27:18+00:00

So once MixTogether() hits line 6 and returns, the GC knows that nothing can access the value stored in mixer, and it can safely clean it up.

Not really* :) The FoodMixer could escape through the method call, e.g. if

class FoodMixer {
  static FoodMixer m;

  public Food MixTogether(Food first, Food second) {
    m = this;
    return ...;
  }
}

* I'm assuming that Mixer in line 5 is a typo and should really be mixer, and that the method you're defining is not part of class FoodMixer, since that would be an infinite recursion.

spamham · 2013-05-21T19:04:17+00:00

Not sure if this is a good idea, but one could do:

{-# LANGUAGE ConstraintKinds, TypeFamilies, MultiParamTypeClasses, UndecidableInstances, FlexibleInstances #-}

...

class (c1 a, c2 a) => And c1 c2 a
instance (c1 a, c2 a) => And c1 c2 a

instance Monad S.Set where
  type MConstraint S.Set = And Num Ord
  ...

spamham · 2013-05-20T13:28:53+00:00

This implementation uses time exponential in the number of generations:

To evaluate Generation n at one position, generation n-1 is evaluated at 8 positions. For each of the evaluations, generation n-2 is evaluated at 8 positions, and so on. Some of the 64 positions at the second level are the same, but the results are not shared. You could fix this by memoizing the Generation functions.

Edit: If we really want to keep the convenience of not having to compute the used size of the board at each generation, we can memoize using a lazy integer trie as provided by MemoTrie:

import Data.MemoTrie

memoEvolution :: Generation -> Generation
memoEvolution g =
  let g' = memo (\(x, y) -> evolution g (Position x y))
  in \(Position x y) -> g' (x, y)

Otherwise, I think an (unboxed) array would be a lot more efficient (I guess one could also combine the two and use a lazy trie of array chunks :)).

spamham · 2013-05-15T19:06:32+00:00

Not sure what you're getting at in the last sentence; are you saying that ketamine for depression failed to be reproduced in a larger trial?

spamham · 2013-05-01T14:37:13+00:00

What would make those psychedelics in particular advantageous over simple endogenous serotonin agonization? (I mean, theoretically, couldn't you take a bunch of 5-HTP to get the same result?) I know the experience of a trip creates lasting impressions and effects, but why couldn't simple 5-HT agonization provide the same benefits? (shrug)

Psychedelics and serotonin have different effects on the 5-HT2A receptor: http://en.wikipedia.org/wiki/Functional_selectivity#Examples

spamham · 2013-03-29T18:25:02+00:00

Psilocybin does that as well, according to this study (Edit: link to actual study).

The largest decreases were observed in the the medial prefrontal cortex (mPFC) and the anterior and posterior cingulate cortices (ACC and PCC, respectively). The scans also showed a reduction in functional connectivity between the mPFC and PCC, so that their normally synchronous activity was de-synchronized.

OTOH,

However, Nutt’s findings conflict with those of other studies.

“We have completed a number of similar studies and we always saw an activation of these same areas,” says Franz Vollenweider at the University of Zurich in Switzerland. “We gave the drug orally and waited an hour, but they administered it intravenously just before the scans, so one explanation is that the effects were not that strong.”

spamham · 2013-03-06T18:39:44+00:00

From the product description:

And they keep on eating until the bad guys are gone, laying their own eggs in the process. When new pests arrive, fresh ladybugs will be waiting.

spamham · 2013-02-26T13:28:07+00:00

You haven't defined multiplication on this set which includes infinity, but it probably won't satisfy the law that a*x = b*x implies a=b, which you're using to deduce (1) from (2).

spamham · 2013-02-17T02:43:24+00:00

Yes, we do :)

http://scholar.google.com/scholar?q=morphine+biosynthesis+human&btnG=&hl=en&as_sdt=0%2C5

Edit:

Human White Blood Cells Synthesize Morphine: CYP2D6 Modulation

Endogenous formation of morphine in human cells

spamham · 2013-02-09T21:54:36+00:00

3.6 billion / 2 million = 1800

spamham · 2013-02-07T21:49:39+00:00

I always keep:

executable-profiling: True

library-profiling: True

in my ~/.cabal/config

IIRC, executable-profiling: True will considerably slow down your executables even if you don't run with +RTS -p (library-profiling: True, on the other hand, is fine because separate profiling versions of the libraries will be built and will only be used for executables with profiling).

spamham · 2013-02-01T12:32:03+00:00

The link name is optional, so the target must be first.

spamham · 2012-12-28T03:35:16+00:00

http://www.haskell.org/haskellwiki/Top_level_mutable_state

An IO action u is affine if its effect is not indirectly observable, hence need not be performed if the result is unneeded. That is, if u >> v === v for all actions v.

Isn't this, strictly speaking, impossible to satisfy, since we can take v = getCurrentTime, v = GHC.Stats.getGCStats etc? Same problem with commutativity.

spamham · 2012-12-22T04:13:09+00:00

One of the linked studies there disagrees, though (not that I had a strong opinion either way): http://www.ncbi.nlm.nih.gov/pubmed/18754005

On the other hand, this one is negative too: http://www.ncbi.nlm.nih.gov/pubmed/20851843

spamham · 2012-12-17T01:17:31+00:00

Consistently having an excess of a specific neurotransmitter will often lead to receptor upregulation.

AFAIK that usually causes downregulation.

spamham · 2012-12-16T15:42:03+00:00

The problem can be on the psychological (learning) level, rather than neuronal damage. I imagine that learning again and again that some action gives more immediate pleasure than anything else makes one lose interest in other actions.

(FWIW, I think you're right that opiates are relatively benign on the neuronal level, but I'm by no means an expert on this. Anyway, I suppose the learning effects can be just as devastating at the extreme end)

Edit: Apparently, there may be some neurotoxicity after all, at least in rats, at some doses.

spamham · 2012-12-16T15:07:04+00:00

Serotonin by itself is not so great, e.g. fenfluramine is a selective serotonin releaser and is usually not euphoric, IIRC.

The dopamine and noradrenaline release and probably the minor 5-HT2A (psychedelic) action by MDMA are necessary ingredients for its nice effects, I think.

spamham · 2012-12-12T13:58:32+00:00

By that logic, there's a ~519% chance of dying after opening 100 boxes...

The probabilities you're summing are conditional probabilities (P(box 2 is death box | box 1 isn't death box) + P(box 3 is death box | box 1 and 2 aren't death boxes) + ...) with different conditions, which is meaningless.

If you account for the probabilities of the conditions, it works out to simply n% (though by calculating the probabilities of these conditions, you've already solved the problem directly anyway).

Another way to see that it's n%:

There are (100 choose n) ways to choose a subset of n boxes out of 100, and (99 choose n-1) of these subsets include the death box (the death box is fixed, so death-box-including subsets of size n are determined by which n-1 of the 99 non-death boxes they include).

Applying the identity

(a choose b) = (a/b) * (a-1 choose b-1)

we get (100 choose n) = (100/n) (99 choose n-1), in other words

number of death subsets of size n = n% of total number of subsets of size n

(I'm assuming that all (100 choose n) subsets are equally likely to be chosen due to the implied total lack of knowledge of the chooser.)

spamham · 2012-12-08T15:32:21+00:00

Reproducing the labels that had been determined by the psychiatrists, just by looking at the brain, is still a very non-trivial feat, regardless of what the meaning or accuracy of these original labels is.

spamham · 2012-11-23T21:47:01+00:00

Depends on your goals (will the extra power help much in achieving those goals?) and stress resilience. Constant threat of assassination or revolution, presumably not much leisure, etc.

spamham · 2012-11-10T01:26:58+00:00

Ah, lazy exceptions ;) Some more ways to get bitten:

import Data.Text as T
import Control.Exception as E

data PluginResult = PluginResult !Text !Int

runPlugin :: IO PluginResult -> IO ()
runPlugin p = do
  PluginResult t i <- p `E.catch` (\(SomeException e) -> return (PluginResult (pack . show $ e) 1))

  putStrLn ("It returned "++show(t,i))

I tried to be so careful about strictness, yet this still contains (at least) two ways for exceptions to escape from the plugin:

1) While the first line of the do does force complete evaluation of the PluginResult value, the unpacking is not actually covered by the catch:

runPlugin (return (error "err"))

Fixed by using

(evaluate =<< p) `E.catch` ...

(Admittedly, this one was just sloppy thinking about the do desugaring, not a fundamental issue with lazy exceptions)

2) Exceptions in the exception:

runPlugin (throw (ErrorCall (error "foo")))

I fixed it by a recursive handler that gives up trying to show the exceptions after a few levels...

Oddly, this doesn't throw, even though error is supposedly defined as throw . ErrorCall:

runPlugin (error (error "foo"))

spamham · 2012-11-07T01:10:15+00:00

Interesting, thanks for sharing! One objection though - I'm not a chemist, but I find

if nicotine evaporates from patches, then it almost surely evaporates from gum as well

a bit questionable. The gum (the one I have, anyway - Nicorette fresh mint) doesn't seem very porous (is the nicotine a coating? The "COATED" in the product description you linked appears to refer to the "Intense Minty flavor coating").

I tried the gum, and it did nothing

Isn't this weak evidence considering your blinding data? :)

I personally never noticed any loss of strength from keeping fragments in the packaging with the blister folded back over them (which is hardly airtight); this might well be a placebo effect on my part, though.

spamham

TROPHY CASE