Template-template parameters?

    template &lt;template &lt;typename&gt; class m&gt;
    struct Monad {
    	template &lt;typename a&gt;
    	static m&lt;a&gt; mreturn(const a&amp;);
    	
    	template &lt;typename a, typename b&gt;
    	static m&lt;b&gt; mbind(const m&lt;a&gt;&amp;, m&lt;b&gt;(*)(const a&amp;));
    };
    
    template &lt;typename a&gt;
    struct Maybe {
    	bool isNothing;
    	a value;
    };
    
    template &lt;&gt;
    struct Monad&lt;Maybe&gt; {
    	template &lt;typename a&gt;
    	static Maybe&lt;a&gt; mreturn(const a&amp; v) {
    		Maybe&lt;a&gt; x;
    		x.isNothing = false;
    		x.value = v;
    		return x;
    	}
    	
    	template &lt;typename a, typename b&gt;
    	static Maybe&lt;b&gt; mbind(const Maybe&lt;a&gt;&amp; action, Maybe&lt;b&gt;(*function)(const a&amp;)) {
    		if (action.isNothing)
    			return action;
    		else
    			return function(action.value);
    	}
    };

Isn&#39;t usually a normal template already a higher-kinded type? For example `std::vector` takes a type parameter to create an actual type like `std::vector&lt;int&gt;`, so it has kind `* -&gt; *`.


I use bit.ly to shorten my urls.
My problem - paramters are not passed.
Let me explain I use http://bit.ly/MYiPhoneApps which redirects (let&#39;s say) to http://iphone.pp-p.net/default.aspx
Now when I try http://bit.ly/MYiPhoneApps?param=xx this param is not added to the resulting url.
I know I could create an extra &quot;short url&quot; including a paramter - so http://bit.ly/WithParam would result in http://www.mysite.com/somepath/apage.aspx?Par1=yy and so forth.

But what I want is to have a short URL directing to a page - and then I want to add a parameter to this shortened url - which shoul (of course) land at my page.

Is this a shortcome of bit.ly (and others are maybe able to do it) - or does &quot;parameter forwarding&quot; not work with 301 redirections?

Manfred

Can an URL shortener pass parameters?

Ok.  I have looked EVERYWHERE and my little brain just can&#39;t understand a better way to refresh an activity.  Any suggestions that I can understand would be great.  :)

Here is the java code:

    package com.dge.dges;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.view.View;
    import android.webkit.WebView;
    import android.widget.Button;
    
    public class dgeActivity extends Activity {

        WebView mWebView;

        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
    
            mWebView = (WebView) findViewById(R.id.webview);
            mWebView.getSettings();
            mWebView.loadUrl(&quot;http://www.websitehere.php&quot;);
            
            Button newButton = (Button)findViewById(R.id.new_button);
            newButton.setOnClickListener(new View.OnClickListener() {
                public void onClick(View v) {
                    Intent intent = new Intent(dgeActivity.this, dgeActivity.class);
                    startActivity(intent);
                }
            });
        }
    }

And here is the `main.xml`


    &lt;?xml version=&quot;1.0&quot; encoding=&quot;utf-8&quot;?&gt;
    &lt;RelativeLayout
        xmlns:android=&quot;http://schemas.android.com/apk/res/android&quot;
        android:id=&quot;@+id/RelativeLayout&quot;
        android:layout_width=&quot;fill_parent&quot;
        android:layout_height=&quot;fill_parent&quot;
        android:background=&quot;#000000&quot;&gt;
    
        &lt;WebView
            android:id=&quot;@+id/webview&quot;
            android:layout_width=&quot;fill_parent&quot; 
            android:layout_height=&quot;wrap_content&quot;
            android:scrollbars=&quot;none&quot;/&gt;

        &lt;Button
            android:id=&quot;@+id/new_button&quot;
            android:layout_width=&quot;fill_parent&quot;
            android:layout_height=&quot;wrap_content&quot;
            android:layout_alignParentBottom=&quot;true&quot;
            android:layout_centerHorizontal=&quot;true&quot;
            android:text=&quot;Refresh&quot;/&gt;

    &lt;/RelativeLayout&gt;


I don&#39;t like the idea of just re-stacking activity after activity.  There has to be an easier way to refresh the webview.  Please help.  :)


Is there a better way to refresh WebView?

This question is for the people who know both Haskell (or any other functional language that supports Higher-kinded Types) and C++...

Is it possible to model higher kinded types using C++ templates? If yes, then how?

**EDIT :**

From [this][1] presentation by Tony Morris:

**Higher-order Polymorphism :**

 - Languages such as Java and C# have
   first-order polymorphism because they
   allow us to abstract on types. e.g.
   `List&lt;A&gt;` can have a `reverse` function
   that works on any element type (the
   `A`).
   
 -  More practical programming languages
   and type systems allow us to
   abstract on type constructors as
   well.
   
 -  This feature is called higher-order
   (or higher-kinded) polymorphism.

**Example :** 

Pseudo-Java with an invented notation for higher-order polymorphism

    interface Transformer&lt;X, Y&gt; {
      Y transform(X x);
    }
    
    interface Monad&lt;M&gt; { // M :: * -&gt; *
      &lt;A&gt; M&lt;A&gt; pure(A a);
      &lt;A, B&gt; M&lt;B&gt; bind(Transformer&lt;A, M&lt;B&gt;&gt; t, M&lt;A&gt; a);
    }

  [1]: http://www.blumenfeld-maso.com/2010/01/what-does-monad-mean-by-tony-morris/

Higher-kinded Types with C++

This question is for the people who know both Haskell (or any other functional language that supports Higher-kinded Types) and C++...
Is it possible to model higher kinded types using C++ templates? If yes, then how?
EDIT :
From <a href="http://www.blumenfeld-maso.com/2010/01/what-does-monad-mean-by-tony-morris/" target="_blank" rel="noopener noreferrer">this</a> presentation by Tony Morris:
Higher-order Polymorphism :
<ul>
<li>
Languages such as Java and C# have
first-order polymorphism because they
allow us to abstract on types. e.g.
<code>List&#x3C;A></code> can have a <code>reverse</code> function
that works on any element type (the
<code>A</code>).
</li>
<li>
More practical programming languages
and type systems allow us to
abstract on type constructors as
well.
</li>
<li>
This feature is called higher-order
(or higher-kinded) polymorphism.
</li>
</ul>
Example :
Pseudo-Java with an invented notation for higher-order polymorphism
<pre><code class="hljs language-css">interface Transformer&#x3C;X, Y> {
 Y transform(X x);
}

interface Monad&#x3C;M> { // M :: * -> *
 &#x3C;A> M&#x3C;A> pure(A a);
 &#x3C;A, B> M&#x3C;B> bind(Transformer&#x3C;A, M&#x3C;B>> t, M&#x3C;A> a);
}
</code></pre>

While ASSERT_* macros cause termination of test case, EXPECT_* macros continue its evaluation.
I would like to know which is the criteria to decide whether to use one or the other.

Using ASSERT and EXPECT in GoogleTest

I’m looking for a good arbitrary precision math library in C or C++. Could you please give me some advices or suggestions?

The primary requirements:

1. It **must** handle arbitrarily big integers—my primary interest is on integers. In case that you don’t know what the word arbitrarily big means, imagine something like 100000! (the factorial of 100000).

2. The precision **must not need** to be specified during library initialization or object creation. The precision should **only** be constrained by the available resources of the system.

3. It **should** utilize the full power of the platform, and should handle “small” numbers natively. That means on a 64-bit platform, calculating (2^33&#160;+ 2^32) should use the available 64-bit CPU instructions. The library **should not** calculate this in the same way as it does with (2^66&#160;+ 2^65) on the same platform.

4. It **must** efficiently handle addition&#160;(`+`), subtraction&#160;(`-`), multiplication&#160;(`*`), integer division&#160;(`/`), remainder&#160;(`%`), power&#160;(`**`), increment&#160;(`++`), decrement&#160;(`--`), GCD, factorial, and other common integer arithmetic calculations. The ability to handle functions like square root and logarithm that do not produce integer results is a plus. The ability to handle [symbolic computations](http://en.wikipedia.org/wiki/Symbolic_computation) is even better.

Here are what I found so far:

1. **Java**&#39;s **[BigInteger](http://java.sun.com/javase/6/docs/api/java/math/BigInteger.html)** and **[BigDecimal](http://java.sun.com/javase/6/docs/api/java/math/BigDecimal.html)** class: I have been using these so far. I have read the source code, but I don’t understand the math underneath. It may be based on theories and algorithms that I have never learnt.

2. The built-in integer type or in core libraries of **[bc](http://www.gnu.org/software/bc/manual/html_mono/bc.html)**, **[Python](http://docs.python.org/release/3.1.2/reference/lexical_analysis.html#integer-literals)**, **Ruby**, **Haskell**, **Lisp**, **Erlang**, **OCaml**, **PHP**, some other languages: I have used some of these, but I have no idea which library they are using, or which kind of implementation they are using.

What I have already known:

1. Using `char` for decimal digits and `char*` for decimal strings, and do calculations on the digits using a `for`-loop.

2. Using `int` (or `long int`, or `long long`) as a basic “unit” and an array of that type as an arbitrary long integer, and do calculations on the elements using a `for`-loop.

3. Using an integer type to store a decimal digit (or a few digits) as **[BCD (Binary-coded decimal)](http://en.wikipedia.org/wiki/Binary-coded_decimal)**.

4. **[Booth’s multiplication algorithm](http://en.wikipedia.org/wiki/Booth%27s_multiplication_algorithm)**.

What I don’t know:

1. Printing the binary array mentioned above in decimal without using naive methods. An example of a naive method: (1)&#160;add the bits from the lowest to the highest: 1, 2, 4, 8, 16, 32, … (2)&#160;use a `char*`-string mentioned above to store the intermediate decimal results).

What I appreciate:

1. Good comparisons on **[GMP](http://gmplib.org/)**, **[MPFR](http://www.mpfr.org/)**, **[decNumber](http://speleotrove.com/decimal/decnumber.html)** (or other libraries that are good in your opinion).

2. Good suggestions on books and articles that I should read. For example, an illustration with figures on how a **non-naive** binary-to-decimal conversion algorithm works would be good. The article “**[Binary to Decimal Conversion in Limited Precision](http://www.cs.uiowa.edu/~jones/bcd/decimal.html)**” by Douglas&#160;W. Jones is an example of a good article.

3. Any help in general.

Please **do not** answer this question if you think that using `double` (or `long double`, or `long long double`) can solve this problem easily. If you do think so, you don’t understand the issue in question.

What are the best (portable) cross-platform arbitrary-precision math libraries?

I am programming a GUI with Qt library. In my GUI I have a huge std::map&lt;int, MyType&gt;.

&quot;MyType&quot; is a class that has different kinds of fields.

I want to serialize the std::map. How can I do that? Does Qt provides us with neccesary features?


Serialization with Qt

I can&#39;t understand the usage of `glOrtho`. Can someone explain what it is used for?

Is it used to set the range of x y and z coordinates limit?

    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);

It means that the x, y and z range is from -1 to 1?


How to use glOrtho() in OpenGL?

    string s = &quot;おはよう&quot;;
    wstring ws = FUNCTION(s, ws);

How would i assign the contents of s to ws?

Searched google and used some techniques but they can&#39;t assign the exact content. The content is distorted.

C++ Convert string (or char*) to wstring (or wchar_t*)

I dislike the default Javadocs generated for me when I create a Class or methods, especially the @author variable, which is the current system username on my windows box.

I would like to change it. Is this possible?

How do I change the Javadocs template generated in Eclipse?

Can you tell me how to invoke template constructor explicitly (in initializer list)?
for example:

    struct T { 
        template&lt;class&gt; T();
    };
    
    struct U {
        U() : t&lt;void&gt;() {} //does not work
        T t;
    };

thanks




C++ invoke explicit template constructor

I have a class

    template&lt;size_t N, size_t M&gt;
    class Matrix {
        // ....
    };

I want to make a `typedef` which creates a `Vector` (column vector) which is equivalent to a `Matrix` with sizes N and 1. Something like that:

    typedef Matrix&lt;N,1&gt; Vector&lt;N&gt;;

Which produces compile error. The following creates something similar, but not exactly what I want:

    template &lt;size_t N&gt;
    class Vector: public Matrix&lt;N,1&gt;
    { };

Is there a solution or a not too expensive workaround / best-practice for it? 

C++ template typedef

I want to let a user sign in before seeing pages. Is there any built-in template for user sign in, so that I do not have to write my own sign in page?

Is there a built-in login template in Django?

How does the following code work?

    typedef char (&amp;yes)[1];
    typedef char (&amp;no)[2];
    
    template &lt;typename B, typename D&gt;
    struct Host
    {
      operator B*() const;
      operator D*();
    };
    
    template &lt;typename B, typename D&gt;
    struct is_base_of
    {
      template &lt;typename T&gt; 
      static yes check(D*, T);
      static no check(B*, int);
    
      static const bool value = sizeof(check(Host&lt;B,D&gt;(), int())) == sizeof(yes);
    };
    
    //Test sample
    class Base {};
    class Derived : private Base {};
    
    //Expression is true.
    int test[is_base_of&lt;Base,Derived&gt;::value &amp;&amp; !is_base_of&lt;Derived,Base&gt;::value];

1. Note that `B` is private base. How does this work? 

2. Note that `operator B*()` is const. Why is it important?

3. Why is `template&lt;typename T&gt; static yes check(D*, T);` better than `static yes check(B*, int);` ? 

**Note**: It is reduced version (macros are removed) of `boost::is_base_of`. And this works on wide range of compilers.

 


How does `is_base_of` work?

It seems that a `newtype` definition is just a `data` definition that obeys some restrictions (e.g., only one constructor), and that due to these restrictions the runtime system can handle `newtype`s more efficiently. And the handling of pattern matching for undefined values is slightly different. 

But suppose Haskell would only knew `data` definitions, no `newtype`s: couldn&#39;t the compiler find out for itself whether a given data definition obeys these restrictions, and automatically treat it more efficiently? 

I&#39;m sure I&#39;m missing out on something, there must be some deeper reason for this.

Why is there &quot;data&quot; and &quot;newtype&quot; in Haskell?

I&#39;ve recently caught the FP bug (trying to learn Haskell), and I&#39;ve been really impressed with what I&#39;ve seen so far (first-class functions, lazy evaluation, and all the other goodies).  I&#39;m no expert yet, but I&#39;ve already begun to find it easier to reason &quot;functionally&quot; than imperatively for basic algorithms (and I&#39;m having trouble going back where I have to).  

The one area where current FP seems to fall flat, however, is GUI programming.  The Haskell approach seems to be to just wrap imperative GUI toolkits (such as GTK+ or wxWidgets) and to use &quot;do&quot; blocks to simulate an imperative style.  I haven&#39;t used F#, but my understanding is that it does something similar using OOP with .NET classes.  Obviously, there&#39;s a good reason for this--current GUI programming is all about IO and side effects, so purely functional programming isn&#39;t possible with most current frameworks.  

My question is, is it possible to have a functional approach to GUI programming?  I&#39;m having trouble imagining what this would look like in practice.  Does anyone know of any frameworks, experimental or otherwise, that try this sort of thing (or even any frameworks that are designed from the ground up for a functional language)?  Or is the solution to just use a hybrid approach, with OOP for the GUI parts and FP for the logic?  (I&#39;m just asking out of curiosity--I&#39;d love to think that FP is &quot;the future,&quot; but GUI programming seems like a pretty large hole to fill.)  

Is functional GUI programming possible?

I can&#39;t figure out what the &quot;| m -&gt; w&quot;-part means in a class definition like this:

    class (Monoid w, Monad m) =&gt; MonadWriter w m | m -&gt; w

What additional information does this add to the class definition?


What&#39;s the &quot;|&quot; for in a Haskell class definition?

If functional programming languages cannot save any state, how do they do simple stuff like reading input from a user?  How do they &quot;store&quot; the input (or store any data for that matter?)

For example: how would this simple C thing translate to a functional programming language like Haskell?

    #include&lt;stdio.h&gt;
    int main() {
        int no;
        scanf(&quot;%d&quot;,&amp;no);
        return 0;
    }

*(My question was inspired by this excellent post: [&quot;Execution in the Kingdom of Nouns&quot;][1].  Reading it gave me some better understanding of what exactly object oriented programming is, how Java implements it in one extreme manner, and how functional programming languages are a contrast.)*
  [1]: http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html

How do functional programming languages work?

In my area of business - back office IT for a financial institution - it is very common for a software component to carry a global configuration around, to log its progress, to have some kind of error handling / computation short circuit... Things that can be modelled nicely by Reader-, Writer-, Maybe-monads and the like in Haskell and composed together with monad transformers. 

But there seem to some drawbacks: The concept behind monad transformers is quite tricky and hard to understand, monad transformers lead to very complex type signatures, and they inflict some performance penalty.

So I&#39;m wondering: Are monad transformers best practice when dealing with those common tasks  mentioned above?  

Has anyone ever encountered a Monad Transformer in the wild?

You can find the following on the web:

1. **Higher kinded type == type constructor?**

 &gt;&lt;!-- language: lang-scala --&gt;
 &gt;
 &gt;     class AClass[T]{...} // For example, class List[T]

 Some say this is a higher kinded type, because it
 abstracts over types which would be compliant with the definition.

 &gt; *Higher kinded types* are types which take other types and construct a new type

 These though are also known as *type constructor*. (For example, in [Programming in Scala][1]).

2. **Higher kinded type == type constructor which takes type constructor as a type parameter?**

 In the paper [Generics of a Higher Kind][2], you can read

 &gt; ... types that abstract over types that abstract over types
 &gt; (&#39;higher-kinded types&#39;) ...&quot;

 which suggests that

 &gt;&lt;!-- language: lang-scala --&gt;
 &gt;
 &gt;     class XClass[M[T]]{...} // or
 &gt;
 &gt;     trait YTrait[N[_]]{...} // e.g. trait Functor[F[_]]

 is a higher kinded type.

So with this in mind, it is difficult to distinguish between *type constructor*, *higher kinded type* and *type constructor which takes type constructors as type parameter*, therefore the question above.

 [1]: http://www.artima.com/pins1ed/type-parameterization.html#19.3
 [2]: http://adriaanm.github.com/files/higher.pdf

What is a higher kinded type in Scala?

I&#39;m only beginning to become familiar with the concept of kinds, so bear with me if I am not formulating my questions well...

**Values have Types:**

    3 :: Int
    [1,2,3] :: [Int]
    (&#39;c&#39;,True) :: (Char,Bool)

**Types have Kinds:**

    the type &#39;Int&#39; has kind *
    the type &#39;[Int]&#39; also has kind *
       but the type constructor [] has kind * -&gt; *
    similarly, the type (Char,Bool) has kind  *
       but the type constructor (,) has kind * -&gt; * -&gt; *

**What do Kinds have?**  

Do they kinds have ilk, or genres, or breeds, or varieties?

How far does this sequence of abstraction go?  Do we stop because we run out of words, or do we stop because going farther has no value?  Or, perhaps, because we quickly reach the limits of human cognition and just can&#39;t wrap our heads around higher-genred kinds?

A related question:  languages give us value-constructors (like a cons operator) to make values. Languages also give us type-constructors like (,) or [] to make types.  Are there any languages that expose kind-constructors to make kinds?  

Another edge case that I&#39;m curious about:  We apparently have a type that has no value, denoted as ⊥, called &quot;the bottom type&quot;.  Is there a kind that has no type:  a bottom kind?


values, types, kinds,... as an infinite sequence?

I&#39;ve been doing dev in F# for a while and I like it.  However one buzzword I know doesn&#39;t exist in F# is higher-kinded types.  I&#39;ve read material on higher-kinded types, and I think I understand their definition.  I&#39;m just not sure why they&#39;re useful.  Can someone provide some examples of what higher-kinded types make easy in Scala or Haskell, that require workarounds in F#?  Also for these examples, what would the workarounds be without higher-kinded types (or vice-versa in F#)?  Maybe I&#39;m just so used to working around it that I don&#39;t notice the absence of that feature.

(I think) I get that instead of `myList |&gt; List.map f` or `myList |&gt; Seq.map f |&gt; Seq.toList` higher kinded types allow you to simply write `myList |&gt; map f` and it&#39;ll return a `List`.  That&#39;s great (assuming it&#39;s correct), but seems kind of petty?  (And couldn&#39;t it be done simply by allowing function overloading?)  I usually convert to `Seq` anyway and then I can convert to whatever I want afterwards.  Again, maybe I&#39;m just too used to working around it. But is there any example where higher-kinded types *really* saves you either in keystrokes or in type safety?

When are higher kinded types useful?

I&#39;m trying to specify a concept to constrain a higher kinded type that has a member function template using Concepts Lite. However I am not able to find inside the [technical specification](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3929.pdf) or the [tutorial](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3701.pdf) a clause dealing with templated statements inside a concept.

How is this done?

Example: suppose I have the higher kinded type `HKT` with a member function template `F`:

    template&lt;class T&gt;
    struct HKT {
      template&lt;class U&gt; // this looks like e.g. rebind in std::allocators
      auto F(U) -&gt; HKT&lt;U&gt;;
    };

and that now I want to specify a concept for constraining these higher kinded types:

    template &lt;template &lt;class&gt; class HKT, class T&gt;
    concept HKTWithTemplateMemberFunctionF {
      return requires(HKT&lt;T&gt; h) { // HKT&lt;T&gt; is a type, h is an object
        // HKT&lt;T&gt; needs to have a member function template that 
        // returns HTK&lt;U&gt; where the type U is to be deduced and
        // it can be any type (it is unconstrained)
        template&lt;class U&gt;  // is there a syntax for this?
        h.F(std::declval&lt;U&gt;()) -&gt; HKT&lt;U&gt;; 
      }
    }

Note that I could do something like:

    template &lt;template &lt;class&gt; class HKT, class T, class U&gt;
    concept HKTWithTemplateMemberFunctionF {
      return requires(HKT&lt;T&gt; h) {
          h.F(std::declval&lt;U&gt;()) -&gt; HKT&lt;U&gt;;
      }
    }

but this means that I need to know `U` at constraint site. 

I don&#39;t really care if substitution for a given `U` fails or not although I can see why this could be a problem: e.g. apply a constraint to be sure your function doesn&#39;t fail and then fails cause the constraint was satisfied but at instantiation time substitution failed in the member function template (would it help if the member function template was constrained?).

Content Type	Original Author	Original Content on Stackoverflow
Question	Venkat Shiva	View Question on Stackoverflow
Solution 1 - C++	kennytm	View Answer on Stackoverflow
Solution 2 - C++	sth	View Answer on Stackoverflow

Higher-kinded Types with C++

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Is there a better way to refresh WebView?

Can an URL shortener pass parameters?

Attributions