assert-combinators

This can't be solved by static analysis - anything that crosses i/o boundary has to be asserted, refuted or predicated at runtime and you have libraries for it ie. [0] which doesn't throw (based on refutations which can be mapped to predicates without much cost and assertions) or [1] which throws (based on assertions). Predicates are the most performant but won't give you any indication on why it failed (ie. some nested field was null but was expected to be number etc). Refutations is great sweet spot as it's fast while giving information about error. Assertions are slow, but more often than not you don't care. You can map between any of them, but it doesn't make much sense for mapping ie. assertion to predicate as you'd be paying cost for nested try/catch while dropping error information. Refutation is great base for all 3. [0] https://g

We use in prod variant of no 1. [0]. Why? Because: * it's sql * it's extremely lightweight (built on pure, functional combinators) * it allows us to use more complex patterns ie. convention where every json field ends with Json which is automatically parsed; which, unlike datatype alone, allows us to create composable query to fetch arbitrarily nested graphs and promoting single [$] key ie. to return list of emails as `string[]` not `{ email: string }[]` with `select email as [$] from Users` etc. * has convenience combinators for things like constructing where clauses from monodb like queries * all usual queries like CRUD, exists etc. and some more complex sql-wise but simple function-api-wise ie. insertIgnore list of objects, merge1n, upsert etc all have convenient function apis and allow for composing whatever more is needed for the pro

I'm fan of point-free combinators [0] [1] which compose in intuitive way. [0] https://github.com/appliedblockchain/assert-combinators [1] https://github.com/preludejs/refute/

We use not so much frameworks but combination of lightweight libraries: - runtime assertions [0] - to map unknown values at i/o boundary into statically typed code (rpc input parameters, sql results etc) - template based sql combinators to sanitize sql/generate sql [1] - jsonrpc over websockets - for bidirectional comms between f/e and b/e It works very well for us for hundreds of rpcs - it's easy to manage things like permissioning/narrowing visibility and other aspects you need in business/enterprise-like setting ie. performance monitoring is very easy/straight forward. [0] https://github.com/appliedblockchain/assert-combinators [1] https://github.com/appliedblockchain/tsql

In js/ts-land going from unknown type to known one normally means: 1. JSON.parse(...) string to json value 2. runtime assert it ie. with [0] which is a form of parsing but on json input as opposed to string parsing In other words, when dealing with jsons, it's better to work on combinators over json values than combinators over string – the code is much more terse, natural and performant. [0] https://github.com/appliedblockchain/assert-combinators

Parser combinators are great ie. in TypeScript [0]. Combinators in general are concise and practical ie. runtime type assertions [1] or generators [2] etc. We use them in several places in production. [0] https://github.com/preludejs/parser [1] https://github.com/appliedblockchain/assert-combinators [2] https://github.com/preludejs/generator/tree/master/src

Types can be asserted at runtime (parsed) at IO boundaries (reading http request or response, websocket message, parsing json file etc). Once they enter statically type system they don't need to be asserted again. The difference it makes is illusion of type-safety vs type-safety this article touches on. It's basically mapping of an `unknown` type into known one, at runtime. You can try to bind service with client (types) somehow but in many cases this will fail in production as you can't guarantee paired versioning, due to normal situations by design of your architecture or temporary mid-deployment state or other team doing something they were not suppose to do (new client is deployed connecting to old service or vice versa) etc. It's hard to avoid runtime parsing/type assertion in general. Functional combinator approaches like [0] or fas

from a look at the readme, you combine those `$.TYPE` things to build a validation function that checks if its argument matches some pattern (and throws an exception if it doesn't). import * as $ from '@appliedblockchain/assert-combinators' const validateFooBar = ( $.object({ foo: $.string, bar: $.boolean }) ) // probably roughly equivalent to /* const validateFooBar = (x) => { console.assert( typeof x === 'object' && typeof x.foo === 'string' && typeof x.bar === 'boolean' ) return x } */ const test1 = { foo: "abc", bar: false } const test2 = { foo: 0, quux: true } const { foo, bar } = validateFooBar(test1) // ok const oops = validateFooBar(test2) // throws error the source is pretty readable too if you want to get an idea how it works. https://github.com/appli

In typescript parsing/asserting types with combinators works very well merging runtime with static type system [0], it has to be used at i/o boundary, then it enters static type system guarantee and no assertions are necessary, makes very nice codebase. [0] https://github.com/appliedblockchain/assert-combinators

Imagine you're writing typescript project. You type everything and have type safety. This type safety is an illusion on I/O boundaries – whenever ie. JSON.parse(...) from file/websocket/http happens. To preserve type safety, you want to use something like [0] to do runtime type assertions. Once i/o boundaries are parsing unknown types at runtime into what is defined as static types, your type safety is guaranteed. [0] https://github.com/appliedblockchain/assert-combinators

We do for for managing stuff with many $1... zeros for serious top fortune companies in business critical projects. Java/Go type systems are primitive compared to typescript. Shallow or no dependencies, functional, ocaml like modules, pervasive use of algebraic types provided by ts (previously flow), several years in production, nice codebase, several successful, non-trivial major releases, constant updates with codebase worked on every day by many people, several deployments per month. Problems I personally have with it: 1. no exact object types in ts as in flow - means they have to be emulated by destructing, sad, but you can live with it/you have to be careful 2. transpile times - but recent experiments with swc for tranpilation and deferring typecheck to run concurrently while tests are kicked off after swc finishes look promising 3.

It's true, I like the feel of Haskell type annotations as well, but I'm working with js/flow in day-to-day job; finding mysqlf moving towards those one-line-type-annoations to mimick Haskell, I'm surprised flow actually handles most of the code, even not so trivial ones; inference is good enough that those one liners are most of the time all that's needed, examples are here [1] [2] [3] if somebody wants to peek. [1] https://github.com/appliedblockchain/tsql/ [2] https://github.com/appliedblockchain/parser-combinators [3] https://github.com/appliedblockchain/assert-combinators

Something similar, but for flow and focused more on functional combinators https://github.com/appliedblockchain/assert-combinators