
F (2006) - tosh
http://www.nsl.com/k/f/f.htm
======
smabie
In a somewhat similar vein, I made a concatenative array language inspired by
kdb+/q: [https://cryptm.org/xs/](https://cryptm.org/xs/)

Unlike other concatenative languages, the order of operation is right to left,
and it supports infix operators. This gives the language a very conventional
array language feel, while also giving you the power and flexibility of the
stack.

As far as I'm aware, there's really nothing like it. Would love if someone
gave it a try!

Here's an example, the factorial function:

    
    
      xs> fac:(prod 1+til);
      xs> fac 4
      0: 24
    

You can also define new infix operators:

    
    
      xs> add:{+.};
      xs> 3 add 2
      0: 5
    

Here's an example of generating a sequence of values, where n_t=n_{t-1}/2:

    
    
      xs> (x:;x%2) fixes 12
      0: [12 6 3 1 0]
    

Note how when we reach the fixpoint of zero, the recursion stops. These kinds
of implicitly recursive combinators are very powerful. Also, equality on
floats is not strict, so we can also do this with floats, without having to
worry about small differences in precision. This is useful when working with
equation optimizers and root finding methods.

~~~
wvlia5
looks cool, like the ideal language I would like to write

for boosting popularity:

1- would be nice to use in tryit online or repl.it

2- would be nice to have a link to the implementation repo in the docs

3- have you tried winning some golfscript contests on stack overflow?

4- main improvements over K, with small code samples?

~~~
smabie
I do have some examples in the examples section. There's a link to the OCaml
implementation on the page as well. A repl.it would be awesome, I'll
definitely do that.

I hadn't heard of golfscript, but those would make some really great examples.
I do have a couple Advent of Code 2019 solutions though.

Thanks!

------
thirtyseven
Did this jump to the top because the click target for the link is so small
that people are accidentally upvoting it?

~~~
StreamBright
Probably, I accidentally upvoted it too.

------
slartibardfast0
This is a very thought provoking language, thank you.

off topic, is it just me? Or a thing informed by silly memes to see this
letter and immediately think oh man, Rest in Peace?!

~~~
tosh
[https://knowyourmeme.com/memes/press-f-to-pay-
respects](https://knowyourmeme.com/memes/press-f-to-pay-respects)

------
1vuio0pswjnm7
It is often said that K can beat the speed of C for some tasks.

The name of this site is "nsl" for No Stinking Loops.

Here is an array programming challenge for the K programmers reading this
thread.

There are two large files A and B.

    
    
       File A
       AAAbjhOJxxxWXrCHt
       AAAsofxxxLqKbYOAwLMHG
       AAACgxxxOea
       AAAwfHjDtoJc
       AAAiCfYnbVXWhuvtEx
       AAAkzzQwvf
       AAAdjLalKFapoYAcGE
       AAAthGazmnfK
       etc.
    
       File B
       AAAwfHjDtoJc
       AAAbjhOJxxxWXrCHt
       AAAiCfYnbVXWhuvtEx
       AAACgxxxOea
       AAAkzzQwvf
       etc.
    

The task is:

What are the lines in B that are not in A?

Something like

    
    
       grep -vf B A
    

But without the stinking loops!

EDIT: File A,B formatting

~~~
xashor
In J (which might be slower than K) with excessive comments for a one-liner:

    
    
        echo@> (2{ARGV) -.&([: <;._1 LF, 1!:1) (3{ARGV)
        NB.    2nd arg                          3rd arg
        NB.              g&f execute f for each, then g on both
        NB.                              1!:1 read file
        NB.                          LF, prepend newline
        NB.                 [: <;._1 split based on first char
        NB.             -.  remove right elements from left array
        NB. echo@> echo each line
        exit 0
    

On two ~1.6MB files with ~15k lines (both the same except 3) I had lying
around:

    
    
        $ time j9 -c ./pseudo_grep.ijs test_b test_a
        …
        real   0m0.064s
        user   0m0.032s
        sys    0m0.017s
        $ time grep -vf test_b test_a
        …
        real   0m5.815s
        user   0m5.234s
        sys    0m0.576s
    

Note that most of the script is for loading each file into an array of lines.
Most work is done by -. on the two arrays, which is exactly what you asked
for, e.g. 0 1 2 3 4 -. 2 4 is 0 1 3.
[https://code.jsoftware.com/wiki/Vocabulary/minusdot#dyadic](https://code.jsoftware.com/wiki/Vocabulary/minusdot#dyadic)

~~~
DylanDmitri
In loopless Python:

    
    
        set(open('file_b')) - set(open('file_a'))
    

Slower than J by a factor of 2-3, but still 10x faster than grep:

    
    
        real    0m0.128s
        user    0m0.078s
        sys     0m0.063s
    

This would make a good Rosetta Code prompt.

~~~
throwaway_pdp09
I didn't know you could simply open a file and setify it. Interesting. & neat.

~~~
fennecfoxen
You can setify any iterable. File handles are iterables that return a line at
a time. Tada!

~~~
throwaway_pdp09
> File handles are iterables...

I did not know that. Assumed you had to somehow wrap them first. Very useful,
thanks!

------
nlh
Ok, I'll bite:

Can someone ELI5 what this is about, why it's interesting, and why someone
would want to learn or use this language?

(I'm coming from the perspective of someone who builds user-facing web &
mobile applications in Ruby, Crystal, Python, JavaScript, Swift, etc.)

BTW - I'm asking not because I doubt there are good answers to any of those
questions - but because I truly don't understand and wish to.

I read the opening paragraph and without spending an hour looking up the
definition of each term, I'm more confused than when I started :)

Thank you in advance!

~~~
throwaway_pdp09
I've no experience with this language or it's genre of languages, but I doubt
there is a good answer for you.

You're working in a very different space (business oriented, needs networking
protocols, probably no major number crunching, your collection of languages do
fine for your job etc.)

Some languages are just explorations of the language space, disjoint from your
language-using space therefore irrelevant to you directly, and may be
(currently) only of academic interest. I'd learn this if I had time, to
understand different paradigms, and for fun. Sometimes this is useful.
Sometimes not.

~~~
nlh
Thank you! That’s helpful. I had a hunch this was focused on theory /
academia, and if that’s the case, that makes more sense.

------
dang
Discussed a bit in 2015:
[https://news.ycombinator.com/item?id=10776314](https://news.ycombinator.com/item?id=10776314)

------
tosh
implementation (also of g and h):

[http://www.nsl.com/k/f/](http://www.nsl.com/k/f/)

(via comments from 2015)

------
macmac
> There are no side-effects

Yet it prints stuff to the terminal.

~~~
salutis
Also heats up the room.

~~~
Koshkin
Exactly. If the program won't read it (the printout) back, or unless it is
designed specifically to sense the heat, then, strictly speaking, it's not a
side effect (in the particular sense in which a side effect may reflect on the
program execution).

------
tluyben2
Ha! Well deserved but how did this pop up to #1? All of nsl is a great show of
what you kan do with k, an apl.

------
myself248
I think we have a new champion in the unofficial HN useless-headline contest.

~~~
dang
[https://hn.algolia.com/?query=%22work%20a%20little%22%20by:d...](https://hn.algolia.com/?query=%22work%20a%20little%22%20by:dang&dateRange=all&page=0&prefix=true&&sort=byDate&type=comment)

~~~
aidenn0
Yet another link to click on? I don't come to HN to work!

~~~
082349872349872
not labour but leisure: compare
[https://en.wiktionary.org/wiki/σχολή](https://en.wiktionary.org/wiki/σχολή)

------
HenryKissinger
Press F for respects.

~~~
Nginx487
People probably think this is what article about.

------
dhosek
I've periodically thought I should at some point learn all the single-letter
programming languages. Have we covered the whole alphabet yet?

~~~
mjn
At least the English alphabet has been covered:
[https://beza1e1.tuxen.de/one_letter_proglangs.html](https://beza1e1.tuxen.de/one_letter_proglangs.html)

~~~
hardmath123
The N programming language (1990?) is spookily reminiscent of PyTorch!

> Expecting a wide use of neural network algorithms in the near future, our
> objective is to get a complete software development environment for
> programming and testing new applications. We intend to produce a high level
> language for neural network specification, as a part of such an environment.

> The language we propose is characterized by a high degree of modularity,
> based on parameterizable data structures, with functionalities in the form
> of update methods attached to them. Composition rules of structures and
> methods enable to build, step by step, more complex structures from smaller
> ones previously defined. Objects are viewed as autonomous modules which are
> linked through plugs for communications. We particularly cared for the
> parallelization of methods running concurrently on different objects of the
> network. The syntax is largely related to those of the C and C++ languages.

[https://link.springer.com/chapter/10.1007/978-3-642-76153-9_...](https://link.springer.com/chapter/10.1007/978-3-642-76153-9_10)

