Google is not the best search engine for Haskell. Try [Hoogle](https://www.haskell.org/hoogle/?hoogle=%3C%24%3E) &lt;del&gt;or [Hayoo](http://hayoo.fh-wedel.de/?query=%3C%24%3E)&lt;/del&gt;&lt;sup&gt;†&lt;/sup&gt;, both will point you right away [to this:](http://hackage.haskell.org/package/base-4.8.2.0/docs/Data-Functor.html#v:-60--36--62-)

    (&lt;$&gt;) :: Functor f =&gt; (a-&gt;b) -&gt; f a -&gt; f b

It&#39;s merely an infix synonym for [`fmap`](http://hackage.haskell.org/package/base-4.8.2.0/docs/Data-Functor.html#v:fmap), so you can write e.g.

    Prelude&gt; (*2) &lt;$&gt; [1..3]
    [2,4,6]
    Prelude&gt; show &lt;$&gt; Just 11
    Just &quot;11&quot;

Like most infix functions, it is _not_ built-in syntax, just a function definition. But functors are such a fundamental tool that `&lt;$&gt;` is found pretty much everywhere.

&lt;hr&gt;

&lt;sup&gt;†&lt;/sup&gt;&lt;sub&gt;Hayoo has been offline for quite a while now.&lt;/sub&gt;

Every time I build a project using the new .NET Core RC2 templates I am **not** provided with a runnable .**EXE** file. If I hit F5 for debugging my console application it runs fine through the 

    C:\Program Files\dotnet\dotnet.exe 
application. And if I use the 

    dotnet run 
command in the folder, it runs fine as well. But I see no way to run the application without the .NET Core CLI tools.

The contents of my 

     bin\Debug\netcoreapp1.0\
folder looks like this:

[![Bin folder structure][1]][1]


  [1]: http://i.stack.imgur.com/mbAkN.png

As you can see there is no .**EXE** file available. Just the dll.

Am I overlooking something? Or is there something wrong with my project.json file?

    {
      &quot;version&quot;: &quot;1.0.0-*&quot;,
      &quot;buildOptions&quot;: {
        &quot;emitEntryPoint&quot;: true
      },
    
      &quot;dependencies&quot;: {
        &quot;Microsoft.NETCore.App&quot;: {
          &quot;type&quot;: &quot;platform&quot;,
          &quot;version&quot;: &quot;1.0.0-rc2-3002702&quot;
        }
      },

      &quot;frameworks&quot;: {
        &quot;netcoreapp1.0&quot;: {
          &quot;imports&quot;: &quot;dnxcore50&quot;
        }
      }
    }

Thanks!




Build .exe file in .NET Core RC2

I am a beginner with Python. Before I start, here&#39;s my Python folder structure

    -project
    ----src
    ------model
    --------order.py
    ------hello-world.py

Under `src` I have a folder named `model` which has a Python file called `order.py` which contents follow:

    class SellOrder(object):
    	def __init__(self,genericName,brandName):
    		self.genericName = genericName
    		self.brandName = brandName

Next my `hello-world.py` is inside the `src` folder, one level above `order.py`: 

    import model.order.SellOrder
    
    order = SellOrder(&quot;Test&quot;,&quot;Test&quot;)
    
    print order.brandName



Whenever I run `python hello-world.py` it results in the error

    Traceback (most recent call last):
      File &quot;hello-world.py&quot;, line 1, in &lt;module&gt;
        import model.order.SellOrder
    ImportError: No module named model.order.SellOrder


Is there anything I missed?







Python - Module Not Found

While reading a piece of Haskell code I came upon this: `&lt;$&gt;`. What does it mean in Haskell? After some google searches I remain in the dark.

What does &lt;$&gt; mean in Haskell?

<p>While reading a piece of Haskell code I came upon this: <code>&#x3C;$></code>. What does it mean in Haskell? After some google searches I remain in the dark.</p>


Haskell version(1.03s):

&lt;!-- language: haskell --&gt;

    module Main where
      import qualified Data.Text as T
      import qualified Data.Text.IO as TIO
      import Control.Monad
      import Control.Applicative ((&lt;$&gt;))
      import Data.Vector.Unboxed (Vector,(!))
      import qualified Data.Vector.Unboxed as V
    
      solve :: Vector Int -&gt; Int
      solve ar =
        V.foldl&#39; go 0 ar&#39; where
          ar&#39; = V.zip ar (V.postscanr&#39; max 0 ar)
          go sr (p,m) = sr + m - p
    
      main = do
        t &lt;- fmap (read . T.unpack) TIO.getLine -- With Data.Text, the example finishes 15% faster.
        T.unlines . map (T.pack . show . solve . V.fromList . map (read . T.unpack) . T.words)
          &lt;$&gt; replicateM t (TIO.getLine &gt;&gt; TIO.getLine) &gt;&gt;= TIO.putStr

F# version(0.17s):

&lt;!-- language: f# --&gt;

    open System
    
    let solve (ar : uint64[]) =
        let ar&#39; = 
            let t = Array.scanBack max ar 0UL |&gt; fun x -&gt; Array.take (x.Length-1) x
            Array.zip ar t
        
        let go sr (p,m) = sr + m - p
        Array.fold go 0UL ar&#39;
    
    let getIntLine() =
        Console.In.ReadLine().Split [|&#39; &#39;|]
        |&gt; Array.choose (fun x -&gt; if x &lt;&gt; &quot;&quot; then uint64 x |&gt; Some else None)    
    
    let getInt() = getIntLine().[0]
    
    let t = getInt()
    for i=1 to int t do
        getInt() |&gt; ignore
        let ar = getIntLine()
        printfn &quot;%i&quot; (solve ar)

The above two programs are the solutions for the [Stock Maximize problem](https://www.hackerrank.com/challenges/stockmax/) and times are for the first test case of the `Run Code` button.

For some reason the F# version is roughly 6x faster, but I am pretty sure that if I replaced the slow library functions with imperative loops that I could speed it up by at least 3 times and more likely 10x.

Could the Haskell version be similarly improved?

I am doing the above for learning purposes and in general I am finding it difficult to figure out how to write efficient Haskell code.

Why is the F# version of this program 6x faster than the Haskell one?

I&#39;m wondering what is the best way to express smart contracts in typed languages such as Haskell or Idris (so you could, for example, compile it to run on the Ethereum network). My main concern is: what is the type that captures everything that a contract could do?

### Naive solution: EthIO

A naive solution would be to define a contract as a member of an `EthIO` type. Such type would be like Haskell&#39;s `IO`, but instead of enabling system calls, it would include blockchain calls, i.e., it would enable reading from and writing to the blockchain&#39;s state, calling other contracts, getting block data and so on.

    -- incrementer.contract
    
    main: EthIO
    main = do
       x &lt;- SREAD 0x123456789ABCDEF
       SSTORE (x + 1) 0x123456789ABCDEF

This is clearly sufficient to implement any contract, but:

 1. Would be too powerful.

 2. Would be very coupled to the Ethereum blockchain specifically.


### Conservative solution: event sourcing pattern

Under that idea, a contract would be defined as fold over a list of actions:

    type Contract action state = {
        act  : UserID -&gt; action -&gt; state -&gt; state,
        init : state
    }

So, a program would look like:
    
    incrementer.contract

    main : Contract
    main = {
        act _ _ state = state + 1,
        init          = 0
    }

That is, you define an initial state, a type of action, and how that state changes when a user submits an action. That would allow one to define any arbitrary contract that doesn&#39;t involve sending/receiving money. Most blockchains have some kind of currency and most useful contracts involve money somehow, so that type would be way too restrictive.

### Less conservative solution: events + currency

We can make the type above aware of currencies by hardcoding a currency logic into the type above. We&#39;d, thus, get something like:

    type Contract action state = {
        act        : UserID -&gt; action -&gt; state -&gt; state,
        init       : state,
        deposit    : UserID -&gt; Amount -&gt; state -&gt; state,
        withdrawal : UserID -&gt; Amount -&gt; state -&gt; Maybe state
    }

I.e., the contract developer would need to explicitly define how to deal with monetary deposits and withdrawals. That type would be enough to define any self-contained contract which can interact with the host blockchain&#39;s currency. Sadly, **such a contract wouldn&#39;t be able to interact with other contracts**. In practice, contracts often interact with each other. An Exchange, for example, needs to communicate with its exchanged Token contracts to query balances and so on.

### Generalization: global state?

So, let&#39;s take a step back and rewrite the conservative solution as this:

    type Contract = {
        act  : UserID -&gt; Action -&gt; Map ContractID State -&gt; State,
        init : State
    }

Under this definition, the `act` function would have access not only to the contract&#39;s own state but the state of every other contract on the same blockchain. Since every contract can read each other&#39;s state, one could easily implement a communication protocol on top of this, and, thus, such type is sufficient to implement arbitrarily interacting contracts. Also, if the blockchain&#39;s currency was itself implemented as a contract (possibly using a wrapper), then that type would also be sufficient to deal with money, despite not having it hardcoded on the type. But that solution has 2 problems:

1. Peeking at the other contract&#39;s state looks like a very &quot;hacky&quot; way to enable communication;

2. A contract defined this way wouldn&#39;t be able to interact with existing contracts which aren&#39;t aware of that solution. 

### What now?

Now I&#39;m in the dark. I know I&#39;m not in the right abstraction for this problem, but I&#39;m not sure what it would be. *It looks like the root of the problem is that I&#39;m not able to capture the phenomenon of cross-contract communications properly.* What concrete type would be more suitable to define arbitrary smart-contracts?

What is an appropriate type for smart contracts?

I&#39;m trying to implement a neural network architecture in Haskell, and use it on MNIST.

I&#39;m using the `hmatrix` package for linear algebra.
My training framework is built using the `pipes` package.

My code compiles and doesn&#39;t crash. But the problem is, certain combinations of layer size (say, 1000), minibatch size, and learning rate give rise to `NaN` values in the computations. After some inspection, I see that extremely small values (order of `1e-100`) eventually appear in the activations. But, even when that doesn&#39;t happen, the training still doesn&#39;t work. There&#39;s no improvement over its loss or accuracy.

I checked and rechecked my code, and I&#39;m at a loss as to what the root of the problem could be.

Here&#39;s the backpropagation training, which computes the deltas for each layer:

    backward lf n (out,tar) das = do
        let δout = tr (derivate lf (tar, out)) -- dE/dy
            deltas = scanr (\(l, a&#39;) δ -&gt;
                             let w = weights l
                             in (tr a&#39;) * (w &lt;&gt; δ)) δout (zip (tail $ toList n) das)
        return (deltas)

`lf` is the loss function, `n` is the network (`weight` matrix and `bias` vector for each layer), `out` and `tar` are the actual output of the network and the `target` (desired) output, and `das` are the activation derivatives of each layer.

In batch mode, `out`, `tar` are matrices (rows are output vectors), and `das` is a list of the matrices.

Here&#39;s the actual gradient computation:


      grad lf (n, (i,t)) = do
        -- Forward propagation: compute layers outputs and activation derivatives
        let (as, as&#39;) = unzip $ runLayers n i
            (out) = last as
        (ds) &lt;- backward lf n (out, t) (init as&#39;) -- Compute deltas with backpropagation
        let r  = fromIntegral $ rows i -- Size of minibatch
        let gs = zipWith (\δ a -&gt; tr (δ &lt;&gt; a)) ds (i:init as) -- Gradients for weights
        return $ GradBatch ((recip r .*) &lt;$&gt; gs, (recip r .*) &lt;$&gt; squeeze &lt;$&gt; ds)

Here, `lf` and `n` are the same as above, `i` is the input, and `t` is the target output (both in batch form, as matrices).

`squeeze` transforms a matrix into a vector by summing over each row. That is, `ds` is a list of matrices of deltas, where each column corresponds to the deltas for a row of the minibatch. So, the gradients for the biases are the average of the deltas over all the minibatch. The same thing for `gs`, which corresponds to the gradients for the weights.

Here&#39;s the actual update code:

    move lr (n, (i,t)) (GradBatch (gs, ds)) = do
        -- Update function
        let update = (\(FC w b af) g δ -&gt; FC (w + (lr).*g) (b + (lr).*δ) af)
            n&#39; = Network.fromList $ zipWith3 update (Network.toList n) gs ds
        return (n&#39;, (i,t))

`lr` is the learning rate. `FC` is the layer constructor, and `af` is the activation function for that layer.

The gradient descent algorithm makes sure to pass in a negative value for the learning rate. The actual code for the gradient descent is simply a loop around a composition of `grad` and `move`, with a parameterized stop condition.

Finally, here&#39;s the code for a mean square error loss function:

    mse :: (Floating a) =&gt; LossFunction a a
    mse = let f (y,y&#39;) = let gamma = y&#39;-y in gamma**2 / 2
              f&#39; (y,y&#39;) = (y&#39;-y)
          in  Evaluator f f&#39;

`Evaluator` just bundles a loss function and its derivative (for calculating the delta of the output layer).

The rest of the code is up on GitHub: [NeuralNetwork][2].

So, if anyone has an insight into the problem, or even just a sanity check that I&#39;m correctly implementing the algorithm, I&#39;d be grateful.

  [1]: http://briandolhansky.com/blog/2014/10/30/artificial-neural-networks-matrix-form-part-5
  [2]: https://github.com/DrPyser/NeuralNetwork




Extremely small or NaN values appear in training neural network

Is there any way to define a sum type in Java? Java seems to naturally support product types directly, and I thought enums might allow it to support sum types, and inheritance looks like maybe it could do it, but there is at least one case I can&#39;t resolve.
To elaborate, a sum type is a type which can have exactly one of a set of different types, like a tagged union in C.
In my case, I&#39;m trying to implement haskell&#39;s Either type in Java:

    data Either a b = Left a | Right b

but at the base level I&#39;m having to implement it as a product type, and just ignore one of its fields:

    public class Either&lt;L,R&gt;
    {
        private L left = null;
        private R right = null;

        public static &lt;L,R&gt; Either&lt;L,R&gt; right(R right)
        {
            return new Either&lt;&gt;(null, right);
        }

        public static &lt;L,R&gt; Either&lt;L,R&gt; left(L left)
        {
            return new Either&lt;&gt;(left, null);
        }

        private Either(L left, R right) throws IllegalArgumentException
        {
            this.left = left;
            this.right = right;
            if (left != null &amp;&amp; right != null)
            {
                throw new IllegalArgumentException(&quot;An Either cannot be created with two values&quot;);
            }
            if (left == right)
            {
                throw new IllegalArgumentException(&quot;An Either cannot be created without a value&quot;);
            }
        }

        .
        .
        .
    }

I tried implementing this with inheritance, but I have to use a wildcard type parameter, or equivalent, which Java generics won&#39;t allow:

    public class Left&lt;L&gt; extends Either&lt;L,?&gt;

I haven&#39;t used Java&#39;s Enums much, but while they seem the next best candidate, I&#39;m not hopeful.  
At this point, I think this might only be possible by type-casting `Object` values, which I would hope to avoid entirely, unless there&#39;s a way to do it once, safely, and be able to use that for all sum types.

Java tagged union / sum types

Asking this question to clarify my understanding of type classes and higher kinded types, I&#39;m not looking for workarounds in Java.

---

In Haskell, I could write something like

&lt;!-- language: haskell --&gt;

    class Negatable t where
        negate :: t -&gt; t

    normalize :: (Negatable t) =&gt; t -&gt; t
    normalize x = negate (negate x)

Then assuming `Bool` has an instance of `Negatable`, 

&lt;!-- language: haskell --&gt;

    v :: Bool
    v = normalize True

And everything works fine.

---

In Java, it does not seem possible to declare a proper `Negatable` interface. We could write:

    interface Negatable {
        Negatable negate();
    }

    Negatable normalize(Negatable a) {
        a.negate().negate();
    }

But then, unlike in Haskell, the following would not compile without a cast (assume `MyBoolean` implements `Negatable`):

    MyBoolean val = normalize(new MyBoolean()); // does not compile; val is a Negatable, not a MyBoolean

**Is there a way to refer to the implementing type in a Java interface, or is this a fundamental limitation of the Java type system?** If it is a limitation, is it related to higher-kinded type support? I think not: it looks like this is another sort of limitation. If so, does it have a name?

Thanks, and please let me know if the question is unclear!

Content Type	Original Author	Original Content on Stackoverflow
Question	prometheus21	View Question on Stackoverflow
Solution 1 - Haskell	leftaroundabout	View Answer on Stackoverflow

What does <$> mean in Haskell?

Haskell Problem Overview

Haskell Solutions

Solution 1 - Haskell

Python - Module Not Found

Build .exe file in .NET Core RC2

Attributions