I wanted to map over a nested array in factor so I created a helper function:

: nested-map ( a quote -- a' ) swap [ over map ] map nip ;

which i then called with

{ { 1 2 } { 3 4 } } [ 1 + ] nested-map

But when I call it I get the error from the title.

If I just paste the body of the function it works as intended:

{ { 1 2 } { 3 4 } } [ 1 + ] swap [ over map ] map nip

So I guess I have two questions: is there a better way to achieve the original goal, but also how am I supposed to create higher order functions without getting this error?

Discussion on hacker news: https://news.ycombinator.com/item?id=40804122

I'm posting this mostly for the new hacker news discussion: https://news.ycombinator.com/item?id=40736174

F is a pure functional concatenative language originally designed as an extension of False. F contains the list-operations of K3 and the dip combinator of Joy. Floating-point and symbolic datatypes are supported. One-time assignment is enforced in syntax. A theory of function-valence and -charge is outlined. F also contains a general continuation primitive $, and the pattern sublanguage of XY. G is a variant of F in which the K3 adverbs are implemented as primitives.

Discussion on lobsters: https://lobste.rs/s/m9xv5y/f_functional_false

Factor gains a quit function (and preserves history)!

This is already in the sidebar, but now there's a fresh post on Lobsters, so maybe some good discussion will come of it.

Discussion on lobsters: https://lobste.rs/s/mwbsed/first_class_contexts

• Discussion on lobsters: https://lobste.rs/s/l8o4j8/forsp_forth_lisp_hybrid_lambda_calculus
• Repo: https://github.com/xorvoid/forsp/

Discussion on lobsters: https://lobste.rs/s/fxkhfk/failing_at_combinatorics_with_haskell

Discussion on lobsters: https://lobste.rs/s/oxjvv0/0_1_0_2

It's not that Roc only supports base-10 arithmetic. It also supports the typical base-2 floating-point numbers, because in many situations the performance benefits are absolutely worth the cost of precision loss. What sets Roc apart is its choice of default; when you write decimal literals like 0.1 or 0.2 in Roc, by default they're represented by a 128-bit fixed-point base-10 number that never loses precision, making it reasonable to use for calculations involving money.

In Roc, floats are opt-in rather than opt-out.

lobsters discussion: https://lobste.rs/s/mnuhwc/go_s_concurrency_dynamic_language_rye

From the STOMP homepage:

What is it?

STOMP is the Simple (or Streaming) Text Orientated Messaging Protocol.

STOMP provides an interoperable wire format so that STOMP clients can communicate with any STOMP message broker to provide easy and widespread messaging interoperability among many languages, platforms and brokers.

Simple Design

STOMP is a very simple and easy to implement protocol, coming from the HTTP school of design; the server side may be hard to implement well, but it is very easy to write a client to get yourself connected. For example you can use Telnet to login to any STOMP broker and interact with it!

From John's blog post:

In the interest of learning Factor, I thought I would write a bit about parsing the STOMP protocol, and then about how to implement a client library using connection-oriented networking, interacting with it using mailboxes, and then building a command-line interface using the command-loop vocabulary.

There are many STOMP servers and clients available in different languages. I tried a few and decided that Apache ActiveMQ was one of the most convenient to setup and reliable to work with, but others are available as well.