Type System

[OAGr]

It would be useful to have simple type declarations. The main purpose of this is for "estimation declarations".

foo(t:float):float => t+2 //simple types
ff(t:float<-min(10)<-max(20)):float => t+2 //type constraint: t has a minimum of 10 and a maximum of 20.
concat(a:(string|number), b:(string|number)):string //Allows OR operation to accept multiple types.

[umuro]

What I understand is that you also need min max operators for the Number type.
I decided to write a type parser to build types easier and more readable. Trying to make a DSL for a type system is much more much effort. And it is not readable.
So far I have

->  // returns operator. Like in Haskell
{}    // record
[]    // array
|     // or operator
<-  // type modifier

BigName() // Constructor name like in Haskell, Rescript and OCAML. We are in the need of creating opaque data types utilizing other types. And a record is not a new type so we need data constructors like in all functional languages.
basicTypeName // string, number or a previously declared type name
( ) // paranthesis, as usual.
Examples:

map:  [a]->(a->b)->[b]  // Yes there is type binding like in Haskell
concat: (string|number)->(string|number)->string
person: Person({age: number, name: string}) // opaque type declaration
numberWithUnit: WithUnit([number, string])  // arrays work like tuples also
age: Age(number<-min(0)<-max(200))
list: Cons([a, list]) | EmptyList()

I have been designing this to create the function bindings. Example:
BindingsFactory.register("map: [a]->(a->b)->[b]", {args=>doMap(args)})
Polymorphism will be resolved in Squiggle itself. Not with outside switches. Therefore I am adding a "typecheck(type, value)" function to the language.

Those declarations are not accessories. Because to resolve the correct function in bindings, we have to do type checking.
After creating the data constructor, I will remove Ev values other than EvNumber and EvString. Everything should be constructable from basics. Otherwise we will have an ever changing type language and tests going on forever.
A working preview of this will be available Friday or next Monday, I guess.
I was planning this only for the sake of creating bindings for all functions. As I am already writing a type parser, I can put it in the core language as well.
This work and your suggestion is already intersecting 100% with your type DSL. Those are declarations will be usable both in Rescript and Squiggle.

One more note. I am bringing in full type expressions because of lambda functions. I even need the type binding like in Haskell. The simple idea of having simple inputs, outputs is not sufficient for them.
Of course you can go on to come up with something quicker... But we will have a lot of removing the redundancies work.
However, the important detail is that I need to build type expressions inside Squiggle and do type checking inside Squiggle. Therefore this is mainly a Squiggle implementation. Apart from BindingsFactory.register (will will create Squiggle code)

Another suggestion. I can change the type syntax not to be Haskelish:
map: ([a], (a: b)): [b]
But somehow this seems to be less readable...

The main reason I wanted to have it in the language syntax instead of a type DSL is that I need to write a ton of tests. Test wont be readable and will take much more time to write. Adding just a little bit of syntax is much less work.

(edited)

[umuro]

Just one thing bugs me. As long as it is us that build all the functions on opaque types, there is no problem. However, the user should have the ability too if necessary. This might be the reason to create a module keyword in the future. Opaque types are transparent in their own module... This is not an urgency... Just a visualization of future...

All types that use a Constructor will be opaque