@nprofile1q... we describe various phenomena using human words and attributes because we are human

(And computers were thinking at least since someone implemented an hourglass icon in them)

@nprofile1q...

Let me start off by saying that I'm impressed by Haskell' s type system and I've long been looking for a nice way to express types in Scheme

So I was familiar with the work by Gary Leavens https://www.cs.ucf.edu/~leavens/ui54/docs/typedscm_toc.html

or with typed-racket

And I didn't like any of them.

When I started using Kawa, it was the first time when I was really satisfied with a type system for Scheme, at least notation-wise. There are certain capabilities, like - in particular - support for generics, or more advanced type inference, that are missing from that type system. But given that type expressions are potentially macro-expanded, I don't find that to be an urgent problem.

Now, when it comes to your proposal, it doesn't address any of those issues. It doesn't provide type-inference. If I'm getting it right, it is perhaps a slightly more compact notation for a particular use of runtime assertions, but it's still much more verbose than lack of type signatures (that Haskell and ML can boast due to type inference) or what Kawa has to offer.

One advantage that I can see is that it can be used with most Scheme implementations. But it requires me to write code that I wouldn't want to write, and that I don't want to have to write.

@nprofile1q... personally I'm not a fan of the concept of multiple values, but if I am to work with them, I much prefer SRFI-72-style let* forms than all alternatives that I've seen.

(Also, the code from lambda-papers doesn't even use the "let" forms - perhaps they weren't yet invented back then? and I personally find it very hard to read)

@nprofile1q...

I think that

(given (((isnt x null?))) something-something)

naturally corresponds to "given that x isn't null" in English, and

(given ((x 5)) blah)

could be read as "given x to be 5", and that those two usages from English correspond nicely to the two fundamental cases of and-let*.

Also, clearly

(given ((something (get-something)))
(do something))

shouldn't do anything when something is nothing (i.e. when it wasn't given) 🤪

@nprofile1q... I know, it's very shocking and it probably takes some time to get used to.

@nprofile1q... I was struck when I saw Scott McCloud's interpretation of Paul Ekman's theory of basic emotions based on facial expressions in "Making Comics"

I tried reading Knuth's "TeX: The Program", and probably (or most certainly) that's subjective, but I find the literate GRASP document so much more engaging to read

@nprofile1q... @nprofile1q...

In cases like this I'd probably go with

(define-syntax-rule (my-when cond body + ...)
(when cond body + ...))

or

(define-syntax-rule (my-when cond body . etc)
(when cond body . etc))

@nprofile1q... how about an on-screen keyboard?

@nprofile1q...

- a piano roll
- something to plot XY charts on CSV and similar data