How about this: change the code so that you name the members. The layout in memory is the same so that it will be binary compatible. You would have to do this patch for each version of the lib.

  
    struct monome_event {
    	monome_t *monome;
    	monome_event_type_t event_type;
    
    	/* __extension__ for anonymous unions in gcc */
    	__extension__ union {
    		struct me_grid {
    			unsigned int x;
    			unsigned int y;
    		} grid;
    
    		struct me_encoder {
    			unsigned int number;
    			int delta;
    		} encoder;
    
    		struct me_tilt {
    			unsigned int sensor;
    			int x;
    			int y;
    			int z;
    		} tilt;
    	};
    };

I am trying to write a paper in IPython notebook, but encountered some issues with display format. Say I have following dataframe `df`, is there any way to format `var1` and `var2` into 2 digit decimals and `var3` into percentages.

	       var1	       var2         var3	
    id												
    0	 1.458315	 1.500092	-0.005709	
    1	 1.576704	 1.608445	-0.005122	 
    2	 1.629253	 1.652577	-0.004754	 
    3	 1.669331	 1.685456	-0.003525	
    4	 1.705139	 1.712096	-0.003134	
    5	 1.740447	 1.741961	-0.001223	
    6	 1.775980	 1.770801	-0.001723	 
    7	 1.812037	 1.799327	-0.002013	 
    8	 1.853130	 1.822982	-0.001396	 
    9	 1.943985	 1.868401	 0.005732

The numbers inside are not multiplied by 100, e.g.  -0.0057=-0.57%.

Format certain floating dataframe columns into percentage in pandas

I am using annotations to configure my spring environment like this:

    @Configuration
    ...
    @PropertySource(&quot;classpath:/config/default.properties&quot;)
    ...
    public class GeneralApplicationConfiguration implements WebApplicationInitializer 
    {
        @Autowired
        Environment env;
    }

This leads to my properties from `default.properties` being part of the `Environment`. I want to use the `@PropertySource` mechanism here, because it already provides the possibility to overload properties through several fallback layers and different dynamic locations, based on the environment settings (e.g. config_dir location). I just stripped the fallback to make the example easier.

However, my problem now is that I want to configure for example my datasource properties in `default.properties`. You can pass the settings to the datasource without knowing in detail what settings the datasource expects using 

    Properties p = ...
    datasource.setProperties(p);

However, the problem is, the `Environment` object is neither a `Properties` object nor a `Map` nor anything comparable. From my point of view it is simply not possible to access all values of the environment, because there is no `keySet` or `iterator` method or anything comparable. 

    Properties p &lt;=== Environment env?

Am I missing something? Is it possible to access all entries of the `Environment` object somehow? If yes, I could map the entries to a `Map` or `Properties` object, I could even filter or map them by prefix - create subsets as a standard java `Map` ... This is what I would like to do. Any suggestions?

Access all Environment properties as a Map or Properties object

How would one go about encoding this chunk of C code in a .chs file so that c2hs can transform it to something relatively nice?

    typedef enum {
    	MONOME_BUTTON_UP        = 0x00,
    	MONOME_BUTTON_DOWN      = 0x01,
    	MONOME_ENCODER_DELTA    = 0x02,
    	MONOME_ENCODER_KEY_UP   = 0x03,
    	MONOME_ENCODER_KEY_DOWN = 0x04,
    	MONOME_TILT             = 0x05,
    
    	/* update this if you add event types */
    	MONOME_EVENT_MAX        = 0x06
    } monome_event_type_t;

    typedef struct monome monome_t; /* opaque data type */
    typedef struct monome_event monome_event_t;
    
    typedef void (*monome_event_callback_t)
    	(const monome_event_t *event, void *data);
    
    struct monome_event {
    	monome_t *monome;
    	monome_event_type_t event_type;
    
    	/* __extension__ for anonymous unions in gcc */
    	__extension__ union {
    		struct {
    			unsigned int x;
    			unsigned int y;
    		} grid;
    
    		struct {
    			unsigned int number;
    			int delta;
    		} encoder;
    
    		struct {
    			unsigned int sensor;
    			int x;
    			int y;
    			int z;
    		} tilt;
    	};
    };

Interfacing with structs and anonymous unions with c2hs

How would one go about encoding this chunk of C code in a .chs file so that c2hs can transform it to something relatively nice?
<pre><code class="hljs language-arduino">typedef enum {
	MONOME_BUTTON_UP = 0x00,
	MONOME_BUTTON_DOWN = 0x01,
	MONOME_ENCODER_DELTA = 0x02,
	MONOME_ENCODER_KEY_UP = 0x03,
	MONOME_ENCODER_KEY_DOWN = 0x04,
	MONOME_TILT = 0x05,

	/* update this if you add event types */
	MONOME_EVENT_MAX = 0x06
} monome_event_type_t;

typedef struct monome monome_t; /* opaque data type */
typedef struct monome_event monome_event_t;

typedef void (*monome_event_callback_t)
	(const monome_event_t *event, void *data);

struct monome_event {
	monome_t *monome;
	monome_event_type_t event_type;

	/* __extension__ for anonymous unions in gcc */
	__extension__ union {
		struct {
			unsigned int x;
			unsigned int y;
		} grid;

		struct {
			unsigned int number;
			int delta;
		} encoder;

		struct {
			unsigned int sensor;
			int x;
			int y;
			int z;
		} tilt;
	};
};
</code></pre>

In the chapter 19 of *Real World Haskell* a lot of the examples now fail due to the change of `Control.Exception`.

That makes me think maybe some of the stuff in this book is actually obsolete and not worth studying anymore, after all it&#39;s been 6 years. My only other reference is *Learn You a
Haskell For Great Good*, though it&#39;s a great book, it&#39;s much more basic compared with RWH. 

Can anyone who have read the book before please give some advice on which parts of it are no longer relevant? Especially the chapters in the second half of the book, for example, software transactional memory, concurrent programming, socket programming, etc.

EDIT: This is about the edition of the book that&#39;s published on Dec 2008, which is the only known edition as of today (Nov 2017) 

Which parts of Real World Haskell are now obsolete or considered bad practice?

Haskell has an identity function which returns the input unchanged. The definition is simple:

    id :: a -&gt; a
    id x = x

So for fun, this should output `8`:

    f = id id id id id id id id id id id id id id id id id id id id id id id id id id id
    main = print $ f 8

After a few seconds (and about 2 gb of memory according to Task Manager), compilation fails with `ghc: out of memory`. Similarly, the interpreter says `ghci: out of memory`.

Since `id` is a pretty simple function, I wouldn&#39;t expect it to be a memory burden at run time or compile time. What is all the memory being used for?

Why does Haskell&#39;s &quot;do nothing&quot; function, id, consume tons of memory?

I have data types defined as:

    data ComitteeView = CommitteeView { committeeId :: CommitteeId
                                      , committeeMembers :: [Person] 
                                      }

    data CommitteesView = CommitteesView { committeeView :: [CommitteeView] }
    
Now, as it stands, I have a Persistent model defined as:

    Person
      name  Text

    Committee
      name  Text

    CommitteePerson
      personId    PersonId
      committeeId CommitteeId

I can pretty easily create a query to populate a CommitteeView, using Esqueleto.  It would go something like this:

    getCommitteeView cid = 
      CommitteeView &lt;$&gt; runDB $ 
        select $
          from (person `InnerJoin` pxc `InnerJoin` committee) -&gt; do
            on  (committee ^. CommitteeId ==. pxc ^. CommitteePersonCommitteeId)
            on  (person ^. PersonId       ==. pxc ^. CommitteePersonPersonId)
            where_ (committee ^. CommitteePersonCommitteeId ==. val cid)
            return person
  
Now, consider the problem of populating `CommitteesView`.  In principle, we get enough data to populate by running subquery in the above query.  Okay, fair enough. Now how can I use &quot;group by Haskell-list&quot; like `group by` in SQL? How can I fold rows so that I can end up with a list of lists of people?

I get the impression that `esqueleto` can&#39;t handle the case as such (i.e., it doesn&#39;t have a combinator that would do it).  And my underlying database obviously doesn&#39;t support Haskell lists as a column.  But, surely, I can&#39;t be the only person to face this issue.  What is an effective strategy?  Folding an n-list of lists into a n-list?  Or running `n+1` queries?  Are there any other options?  

Handling List-types with Esqueleto

There is a well known issue that [we cannot use `forall` types in the `Cont` return type][1].

However it should be OK to have the following definition:

    class Monad m =&gt; MonadCont&#39; m where
        callCC&#39; :: ((a -&gt; forall b. m b) -&gt; m a) -&gt; m a
        shift :: (forall r.(a -&gt; m r) -&gt; m r) -&gt; m a
        reset :: m a -&gt; m a

and then find an instance that makes sense. In [this paper][2] the author claimed that we can implement `MonadFix` on top of `ContT r m` providing that `m` implemented `MonadFix` and `MonadRef`. But I think if we do have a `MonadRef` we can actually implement `callCC&#39;` above like the following:

    --satisfy law: mzero &gt;&gt;= f === mzero
    class Monad m =&gt; MonadZero m where
        mzero :: m a

    instance (MonadZero m, MonadRef r m) =&gt; MonadCont&#39; m where
        callCC&#39; k = do
            ref &lt;- newRef Nothing
            v &lt;- k (\a -&gt; writeRef ref (Just a) &gt;&gt; mzero)
            r &lt;- readRef ref
            return $ maybe v id r
        shift = ...
        reset = ...

(Unfortunately I am not familiar with the semantic of `shift` and `reset` so I didn&#39;t provide implementations for them)

This implementation seems OK for me. Intuitively, when `callCC&#39;` being called, we feed `k` which a function that its own effect is always fail (although we are not able to provide a value of arbitrary type `b`, but we can always provide `mzero` of type `m b` and according to the law it should effectively stop all further effects being computed), and it captures the received value as the final result of `callCC&#39;`.

So my question is:

Is this implementation works as expected for an ideal `callCC`? Can we implement `shift` and `reset` with proper semantic as well?

In addition to the above, I want to know:

To ensure the proper behaviour we have to assume some property of `MonadRef`. So what would the laws a `MonadRef` to have in order to make the above implementation behave as expected?

**UPDATE**

It turn out that the above naive implementation is not good enough. To make it satisfy &quot;Continuation current&quot;

    callCC $\k -&gt; k m === callCC $ const m === m

We have to adjust the implementation to

    instance (MonadPlus m, MonadRef r m) =&gt; MonadCont&#39; m where
        callCC&#39; k = do 
           ref &lt;- newRef mzero
           mplus (k $ \a -&gt; writeRef ref (return a) &gt;&gt; mzero) (join (readRef ref))

In other words, the original `MonadZero` is not enough, we have to be able to combind a `mzero` value with a normal computation without cancelling the whole computation.

**The above does not answer the question, it is just adjusted as the original attempt was falsified to be a candidate. But for the updated version, the original questions are still questions. Especially, `reset` and `shift` are still up to be implemented.**  

           
           

  [1]: https://stackoverflow.com/questions/7178919/how-to-make-callcc-more-dynamic/7180154#7180154
  [2]: http://www.carlssonia.org/ogi/mdo-callcc.pdf

Use MonadRef to implement MonadCont

So far, every monad (that can be represented as a data type) that I have encountered had a corresponding monad transformer, or could have one. Is there such a monad that can&#39;t have one? Or **do all monads have a corresponding transformer?**

By a _transformer `t` corresponding to monad `m`_ I mean that `t Identity` is isomorphic to `m`. And of course that it satisfies the monad transformer laws and that `t n` is a monad for any monad `n`.

I&#39;d like to see either a proof (ideally a constructive one) that every monad has one, or an example of a particular monad that doesn&#39;t have one (with a proof). I&#39;m interested in both more Haskell-oriented answers, as well as (category) theoretical ones.

As a follow-up question, is there a monad `m` that has two distinct transformers `t1` and `t2`? That is, `t1 Identity` is isomorphic to `t2 Identity` and to `m`, but there is a monad `n` such that `t1 n` is not isomorphic to `t2 n`.

(`IO` and `ST` have a special semantics so I don&#39;t take them into account here and let&#39;s disregard them completely. Let&#39;s focus only on &quot;pure&quot; monads that can be constructed using data types.)

Content Type	Original Author	Original Content on Stackoverflow
Question	user1908597	View Question on Stackoverflow
Solution 1 - Haskell	h4ck3rm1k3	View Answer on Stackoverflow

Interfacing with structs and anonymous unions with c2hs

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Access all Environment properties as a Map or Properties object

Format certain floating dataframe columns into percentage in pandas

Attributions