[tines]

This is fantastic! Forth's simplicity is a great fit for exploratory programming on resource-constrained systems, and I'm a fan of anything homoiconic.

Maybe one day I'll get my dream of having a forth or lisp with the type system of haskell.

[vanderZwan]

Have you looked at Kitten? It's statically typed[0], and a descendant of Cat[1], which is a descendant of Joy[2]. So those might also be interesting languages to investigate

> The Kitten Programming Language

> Kitten is a statically typed, stack-based functional programming language designed to be simple and fast. It is a concatenative language, combining aspects of imperative and pure functional programming. There is an introduction available and a tutorial in progress.

http://kittenlang.org/

[0] http://evincarofautumn.blogspot.se/search/label/Concatenativ...

[1] http://www.codecommit.com/blog/cat/the-joy-of-concatenative-...

http://www.codecommit.com/blog/cat/the-joy-of-concatenative-...

http://www.codecommit.com/blog/cat/the-joy-of-concatenative-...

[2] https://en.wikipedia.org/wiki/Joy_(programming_language)

[eggy]

Maybe Shen would work for you? [1] A Lisp with optional static type checking, optional lazy evaluation, pattern matching, a built-in Prolog, and more.

[1] http://www.shenlanguage.org/

[jstimpfle]

Aren't these conflicting ideas? To me a big advantage of dynamic type systems is that specifying behaviour and specifying what parts of the behaviour are statically computed are separate tasks.

[david-given]

There are some strongly typed Forths --- although I've never seen one that was out of prototype. Here's one I had a brief look at:

http://www.arestlessmind.org/2009/02/03/intro.html

Of course, since Forths are built around a REPL, to do type checking you need to keep the type objects around at run time, so it may not be suitable for very small systems.

[tines]

Yes, but they are not conflicting in the sense that they are competing to serve the same purpose.

For exploratory programming, dynamic type systems are nice. For building reliable long-running systems or ones where failure is extremely costly, I like static.

[thurn]

Yes. For example, the powerful "transducers" concept from Clojure essentially cannot be represented in the Haskell type system.

[eru]

Here's an attempt: http://hypirion.com/musings/haskell-transducers

[nine_k]

Did you see the Factor language?

[throwaway7645]

Factor is cool, but never really took off or got much attention. The creator, Slava has moved on to other things (Swift compiler I think). I posted something on another concatenative language (kitten) on here recently and the author jumped on and the conversation was good (Factor was brought up as well).