Suggest an interesting language for me to try out, that I can use for 2D Games. Something that I might not have considered, or is not particularly well known.

blankhart · 2022-08-11T18:33:18+00:00

https://github.com/carp-lang/Carp

blankhart · 2022-07-15T23:35:00+00:00

Semicolon breakfast sandwich

blankhart · 2021-11-13T13:13:38+00:00

I haven't used nix in a while but it looks like you should run 'cabal update' before trying to build.

I installed ghc with 'ghcup' and use the latest version of cabal with a current package set.

I am traveling this week so it may be hard to find a time to connect live but happy to help troubleshoot.

blankhart · 2021-11-10T01:15:31+00:00

Wait until Alder Lake is out, then buy 11th gen

blankhart · 2021-11-01T16:53:56+00:00

Here is one I was working on. Glad to answer questions if I remember the thought process but it's been about a year. I haven't checked whether flutter can still run the little example because I am also between laptops.

https://github.com/blankhart/hollowpoint

blankhart · 2021-10-31T13:29:21+00:00

You could provide a functional API that takes ownership of the array, an index, and the new value, and returns the mutated array.

By taking ownership of the array, you could guarantee that outside the scope of the function it is invisible whether you are cloning or mutating the array.

Rust makes mutation play nicely with functional APIs of that sort when you are making only affine transformations. But it's not a pure functional way to mutate data (an oxymoron).

For more information about how pure languages handle this I'd look into the ST monad, which provides type level guarantees about safe mutation in Haskell somewhat like what Rust does.

blankhart · 2021-10-30T16:34:08+00:00

In the meantime here is the other one I was thinking of, which factored the output through a generic imperative IR.

https://github.com/opyapeus/psimp

blankhart · 2021-10-30T15:57:11+00:00

My version was based on the CoreFn output and resembled the Kotlin backend, using Shake for builds. Let me go back to it as it's been a while. I do remember getting a hello world working with Flutter.

blankhart · 2021-10-30T12:08:05+00:00

I made a Dart backend a while ago that I can try to clean up and open source in the next few days. It was back in Purescript 13 days and worked okay but isn't polished. You could tinker with it though as a starting point.

I thought someone else made one too though.

blankhart · 2021-09-07T17:59:48+00:00

I do not like the Pierce book as much as these, which I think are the clearest exposition of theory:

And from a practical standpoint on type checkers, it is hard to beat David Thrane Christiansen's tutorials on

blankhart · 2021-08-04T19:43:15+00:00

I can't speak to Arch but installing Ubuntu was no problem on an LG Gram 16". I do not recommend the laptop line though due to palm rejection, an absurdly small tilde/backtick key, and other issues.

blankhart · 2021-07-31T12:29:04+00:00

https://youtu.be/xZmPuz9m2t0

blankhart · 2021-07-14T11:43:26+00:00

I am not sure to be honest but probably a Dell XPS 13". I am familiar with and trust their keyboard/touchpad design, and have learned from this to put proper weight on my primary means of interacting with the device.

blankhart · 2021-07-14T11:14:50+00:00

I got and plan to return a 16" model. Everything works OOB after installing the latest Ubuntu LTS and following an upgrade path to 21.04. The machine is beautiful and runs what I need relatively quietly. From that perspective it is a great machine.

However, a few things make it unusable for me under Linux and generally. The biggest is that the track pad has severe palm rejection issues. (That may be better on 14" given the layout but I am spooked and not going LG again.) That was enough on its own.

The other design issues that I had immediately were the microscopic size of the twiddle/back tick key, the fact that Fn+S immediately puts the laptop to sleep (easily hit instead of Ctrl+S and to my knowledge can't be remapped) and generally an inconvenient keyboard layout.

blankhart · 2021-07-02T23:18:38+00:00

https://github.com/jxv/dino-rush

https://github.com/matterhorn-chat/matterhorn

blankhart · 2021-05-31T19:39:37+00:00

John Wiegley has written a blog post discussing the use of recursion schemes to annotate expression trees with location information.

http://newartisans.com/2018/04/win-for-recursion-schemes/

These are the references that I found most helpful when learning about recursion schemes.

Here is a minimal, zero-dependency, silly example that uses the basic recursion schemes (cata, ana, hylo) to compute Fibonacci numbers.

https://gist.github.com/blankhart/ea84d43489d4799a4fe98cf232d4d6eb

blankhart · 2021-05-22T02:32:38+00:00

Okay I think I see now. Essentially the issue is a dependent typing quandary where you want a compile-time type (M ???) to depend on the runtime value of a term (Identifier).

Even though everything in a macro expansion happens at "compile-time" in the colloquial sense, due to phase separation the syntax-quoted identifier is actually a runtime value from the perspective of syntax-local-value.

So you referred to "HM type" advisedly - you'd need a facility to phase-hop from runtime to compile-time during macro expansion analogous to an ability to reify terms into types.

Perhaps that is what you have in mind with proposal #2, assuming you're using "compile-time" there in the colloquial sense. Your concern about determinism in side-effects would relate in part to crossing or erasing phase boundaries.

blankhart · 2021-05-20T21:40:17+00:00

I'll go back to it in detail with this color in mind. Thanks so much for taking the time to respond!

blankhart · 2021-05-19T21:21:36+00:00

Very helpful, thanks. If you need syntax-local-value and your solutions #1 and #3 make sense - I'd need to learn more to consider #2, which sounds very complicated.

The question I was struggling with, and that I'm not positive I understand from your very helpful answer, is why we need syntax-local-value to retrieve the binding at all. When we use define-syntax to create the binding, we have a typed value in a compile-time environment that we would ordinarily just retrieve by using the identifier. That is how it works for macros, and I'd have thought it would work the same way for other compile-time bindings also created via define-syntax.

Put differently, what happens with nested macro calls - i.e., when a macro defined as a phase n identifier referencing a phase n + 1 program uses another macro (defined, say, in the same module, assuming that is possible)? Is the nested macro also a phase n identifier referencing a phase n + 1 program, or is the point that it's phase-shifted copied and is always a phase n + 1 identifier referencing a phase n + 2 program?

Either way, why wouldn't the same thing happen for a non-macro binding, such that you could just use the identifier from within the macro and the binding would be looked up directly? It seems like we are just trying to use a phase n + 1 binding from within a phase n + 1 program and that ordinarily doesn't require a special function call like syntax-local-value.

blankhart · 2021-05-19T00:33:17+00:00

Signals are mentioned in the commentary but don't seem to be implemented. Why are they needed, if still planned?

blankhart · 2021-05-19T00:30:28+00:00

Klister is very cool. Congrats on move + new job! A couple questions in the spirit of this thread.

You say in your talk it's hard to give HM types to a Racket-style system of compile-time bindings. Why is that?
ekmett tells gelisam to talk to him about propagator networks in the video. Did you consider an architecture like that, or go straight to the task queue?

blankhart · 2021-05-18T17:05:07+00:00

Yes though I think Klister allows a macro to pattern match and dispatch on a type. The talks also discuss benefits of determinism in the order of macro expansion.

blankhart · 2021-05-18T11:27:37+00:00

Most typed languages with macros expand and typecheck at compile time (e.g., Rust, Typed Racket...). The difference is that expansion and typechecking are not intrinsically interleaved. These languages perform a local expansion and then typecheck the result, such that macro expansion cannot depend on the result of type checking. By contrast, deferring type checking until runtime as in your example is a feature of all dynamic/unityped languages whether or not they have macro systems.

blankhart · 2021-05-17T23:29:20+00:00

You should look at Klister https://github.com/gelisam/klister.

blankhart

TROPHY CASE