PureScript | hot reload framework for Unity3D , based on Mono | Game Engine library

"Unknown data constructor Nothing" means just what it says: the compiler doesn't know what Nothing is, where it's defined.

And how do you let it know where it's defined? Same way as with all the other stuff you're using in your program - with an import!

You already have import Data.Maybe (Maybe), but that's not enough: this is importing only the type Maybe, but not its constructors.

To import the Nothing constructor, add it after the type in parens like this:

Here is a basic version just using URI.Extra.QueryPair with some helpers to parse stuff:

Here you need to import both the type \/ and the value \/.

The syntax for importing type operators is type (\/). The prefix type is necessary for disambiguation - that is, to let the compiler know that you're importing the type, not the value that might have the same name.

And the syntax for importing the value is as usual.

So the whole import would look like this:

The standard way to thread one context through another is traverse.

Look at the type signature:

ok let's see - as you've already noticed you get a Channel (from signal) back that will notify you about Messages

you should now be able to use Signal.Channel.subscribe to turn this into a Signal

Now the way Signal works is that you should provide a Signal signaling Effects (those will be executed/run) to runSignal - so you have to turn your Signal (Array Message) into a Signal (Effect Unit) first.

Luckily Signal is a Functor so you can use map or the provided ~> (flipped map) to do this. I would suggest using flattenArray first to make your life a bit easier:

I might program this as:

Whether treating ADP constructors as types is worth avoiding or not is a meaningless questions, because that's impossible. ADT constructors can't be types, and that's the end of that.

But if you wanted to have Circle and Rectangle available as their own types, but still keep Shape as an ADT, there is nothing impossible about that:

As with everything in life, there is no recipe. It's a spectrum. No type safety at all on one extreme, or drown in newtypes on the other. The truth, as always, lies somewhere in the middle.

But to tell you anything more specific, I'd need to know the larger design. It's kind of impossible to say just from those definitions. It might be that you actually do need all of them, in which case... well... you do need all of them.

But in my experience, that's usually not the case. Some of the questions to ponder could be:

• Do all of them really need Ring and CommutativeRing? Somehow I doubt that.
• Do all of them really need to be separate, or could some be combined in one type? For example, Row and Column could be a Point together.
• If you want your type to have all characteristics of a number, then perhaps it should actually be a number?
• Could the type safety be achieved by using named parameters (via records) instead?

The way I usually go about these things is to start barebones and then add support for stuff as need arises. You will probably be surprised how little need will arise in practice.

And this point applies to using newtypes in the first place. Is it really that probable that you might mix up rows and columns? Or are you just trying to plug every possible hole just in case? If it's the latter, then yes, you do end up with a ton of hole plugs, there's no surprise there.

To answer your question directly, the way to have a function that works with different types, but a limited set of them (also known as "overloaded function") is type classes. More specifically, such function should be a method of a type class, and then you create an instance for each type (or combination of types) you'd like it to work with.

So the most straightforward approach would be this: