blog/2025-07-31/the-loop-and-more-loops/

[giscus[bot]]

blog/2025-07-31/the-loop-and-more-loops/

Program in YAML — Code is Data

https://yamlscript.org/blog/2025-07-31/the-loop-and-more-loops/

[pwdrysdale]

Hey ingy, I'm very fresh to Yamlscript and clojure.. I have tried for a few hours to write a simple yamlscript isPrime function, and am having no luck (similarly, none of the AI chat bots are having any luck either!).

How would you do it?

I am coming from more of a Javascript / Typescript / Go background.

Trying to assign / reassign variables outside of loops, etc? The whole thing has got me pretty messed up :/

I looked over some of the rosetta stuff too, but still am just missing something

[ingydotnet]

Hi @pwdrysdale !

Apologies for not seeing this sooner!

Here's a quick example of defining and calling a prime? function.

!YS-v0

defn main(*nums):
  each num nums: !:say
    if prime?(num): +
      "$num is prime"
      "$num is not prime"

defn prime?(n):
  (n > 1) &&
  \(zero?(n % _))
    .not-any?(range(2 n))

and run it:

$ ys prime.ys 1 2 3 4 5 6 7 8 9
1 is not prime
2 is prime
3 is prime
4 is not prime
5 is prime
6 is not prime
7 is prime
8 is not prime
9 is not prime

There's a lot to discuss here. How about instead of me trying to tell you the finer points here, let's turn this into a dialog.
Tell me what you understand here and what isn't clear.
Not only would that be a better way to teach/learn, it would be helpful for others in the future.
And maybe others can chime in whilst we discuss it!

Looking forward to your replies...

[ingydotnet]

WRT to functional (FP) versus imperative programming, it's a bit of a mind switch but not a huge one.
YS/Clojure is really pretty simple.
Just remember that variables hold values that are immutable.
And functions take arguments and return a value.

Say you have a variable called m that contains a mapping {"foo" 111} and you want to add a new key/value pair bar and 222 and you want to change the value of foo to 123.
You can't change the mapping because it is immutable. But you can call a function that takes the mapping and the new stuff and returns an entirely new mapping:

$ ys -U -e '
m =:: {foo: 111}
m =: m.assoc("bar" 222)
m =: m.assoc("foo" 123)
say: m
'
{foo 123, bar 222}

You never changed a mapping here. You just created a new one and then re-bound m to the new one.

Another thing to keep in mind is that you can't return early from a function.

Hope this sparks more questions.

[pwdrysdale]

Hey Ingy, thanks for writing back, and sorry, just getting back to this now.

The math is not the problem - Math was my undergraduate degree. I can see that you're simply taking the modulo for all numbers less that the number and down to 2, and checking that there is remainder - a pretty standard programming way of checking for whether or not a number is prime.

Where I get lost is really the syntax and semantics - I am primarily a typescript dev, which is not semantic.

I put some of your code into AI, so we'll see how we go for understanding:

It is mostly here where I got caught / blocked.

\(zero?(n % _))
    .not-any?(range(2 n))

So it looks like \ designates a lambda function to use used by the second line here, which throws all the values into the function? (with _ being the target value for the lambda?)

The zero function returns whether something is zero or not and returns a boolean?

I assume then that the not-any (not a function that I have seen before) loops over the lambda for the range

The rest of the top comment (e.g. the main function) seems fine.

I am fairly used to dealing with immutability thanks to React. The thing about that second comment is just to do with syntax, again. The =:: and the =:, what are each of those doing? Is it that the former is creating a new map and then the later is just adding things to it? In JS/TS world that looks like a mutation (and YS being immutable.. this would not be a good move).

You are right about it being a mind shift!

[vendethiel]

Is it that the former is creating a new map and then the later is just adding things to it? In JS/TS world that looks like a mutation (and YS being immutable.. this would not be a good move).

It's not mutation. Each time, it's a different m variable, if you have an earlier reference to it it won't see the changes.

I assume then that the not-any (not a function that I have seen before) loops over the lambda for the range

not-any is like !.some in JS

[ingydotnet]

Hi again @pwdrysdale. Glad you replied. I didn't get notified so I need to look into that...

Let's break your confusions down in detail.

YS code always translates into the Clojure Lisp. So one good way to understand YS syntax is to use ys -c and look at the Lisp.
YS has many ways to write any given expression, while Lisp generally has one way.
Getting familiar with the translations is a key to learning YS.

Let's compile that expression:

$ ys -c -e '
\(zero?(n % _))
    .not-any?(range(2 n))'
(+not-any? (fn [& [_1]] (zero? (rem n _1))) (range 2 n))

We get (+not-any? (fn [& [_1]] (zero? (rem n _1))) (range 2 n)) Lisp code.
Lisp expressions are a function, followed by 0 or more args, all surrounded by parens.

You were right that \(...) defines a lambda or anonymous function. _ or _1 is bound to the first argument, _2 is bound to the second, etc. Lisp (YS) always returns the last thing evaluated in a function body.

x % y becomes (rem x y). (similar for other binary operators)

range(x y) becomes (range x y). a(b c d) becomes (a b c d) in for any values. you can also use (a b c d) in YS if you want.
a: b c d key value pairs also become (a b c d) as do a b: c d, a b c: d and a b c d:.

b.a(c d) becomes (a b c d). The . operator puts the LHS as the first arg.
You can see that with (+not-any? (fn [& [_1]] (zero? (rem n _1))) (range 2 n)), after
\(zero?(n % _)) expanded to (fn [& [_1]] (zero? (rem n _1))) the whole lambda became the first arg for not-any? function call.

The function name is actually not-any?. You seemed to interpret that as not-any followed by ?.
Symbol names can end with ?, ! or + in YS.

It actually compiled to +not-any? which is a YS function wrapper of not-any? that gets generated by the . operator to put args in the right position for common functions.

For example:

$ ys -pe '(1 .. 10).drop(5)'
(6 7 8 9 10)
$ ys -pe '5.drop(1 .. 10)'
(6 7 8 9 10)
$ ys -pe 'drop(5 (1 .. 10))'
(6 7 8 9 10)
$ ys -pe 'drop((1 .. 10) 5)'
Error: Don't know how to create ISeq from: java.lang.Long
$ ys -ce '(1 .. 10).drop(5)'
(+drop (rng 1 10) 5)

+drop makes sure the number comes first and the collection second.

There are many ways to write:

\(zero?(n % _))
    .not-any?(range(2 n))

It could have been one line:

\(zero?(n % _)).not-any?(range(2 n))

or

\(zero?(n % _)) . not-any?(range(2 n))

YAML joins multiline scalars joining lines with a space. I just split the expr before the .not-any?(... because felt like a good place to do it.

You also could have done it in a more (YAMLy) block form:

not-any? _ range(2 .. n):
  fn(x):
    zero?: n % x

There the _ means to put the value (the function) in that position.

---

Regarding =: and =:: they are both variable bindings. The extra : means the the value part is normal YAML syntax (data mode), not a YS expression (code mode). Search for "mode" in the yamlscript.org site.

m =:: {foo: 111}

could be done as:

m =: + {foo 111}

or:

m := hash-map('foo' 111)

or many other ways.

Using normal YAML flow mapping syntax felt cleanest there.

Keep the questions coming. It's useful for me to explain things publicly for others, and know where docs need improving.

PS the Clojure docs for not-any?, zero?, range, rem, drop etc are really informational:

Start at https://clojuredocs.org/clojure.core/not-any_q and use ctl-s to search for the others. :)
YS exposes all the Clojure common functions and also has a lot of its own in ys::std.

[pwdrysdale]

@ingydotnet I think I generally get the idea, but am a long way from mastering it.

On the subject of loops, I set myself the goal of completing 50% of the exercism course by EoY, so am working through that. For the longest while I have been trying to discover / write a while loop, and have not been having much fun with it. I hobbled together this for a working solution to nthPrime:

!YS-v0
defn isPrime(n):
  (n > 1) &&
  \(zero?(n % _))
    .not-any?(range(2 (+ 1 (floor (sqrt n)))))

defn prime(n):
   range(2 (* n 20))
     .filter(isPrime)
     .nth((- n 1))

Certainly not the greatest code, but it works. Some mathematical trickery got us over the line.

I had a look at the community solutions and noticed some heavy use of recur in people solutions. Is that pretty well standard practice in lieu of while loops?

Just interesting. I like @kenokabe's solution, reads very well and @vendethiel's solution seems very clean and concise and like the closest thing to a while loop - extract below:

defn prime(number):
  nth _ (dec number):
    filter: isprime range()

Just wanted to see if anyone wanted to shed some light on things. Thank you for all the help / feedback.

[ingydotnet]

Here's a variation of vendethiel's solution that's pretty nice.
Here we use forms that are more YAML looking than YS expression syntax.
prime can come before is-prime in YS.
range() is a lazy infinite list starting at 0.
We filter that into an infinite list of primes and take the n-1 one (since the 10th prime is index 9; zero based indexing).
To check if it's prime we make sure it's greater than or equal to 2 and no numbers less than it divide into it.

!YS-v0

defn prime(n):
  nth _ n.--:
    filter is-prime: range()

defn is-prime(n):
  and:
    gt n: 1
    not-any? _ 2.range(n):
      fn(x):
        zero?: n % x

We can get rid of the check for greater than or equal to 2 by using the range or 2 to infinity.
We do that by dropping the first 2 elements of range() (0 and 1):

defn prime(n):
  nth _ n.--:
    filter is-prime:
      drop 2: range()

defn is-prime(n):
  not-any? _ 2.range(n):
    fn(x):
      zero?: n % x

We can run this program to find the 10th prime like this:

$ ys -e 'say: prime(10)' nth-prime.ys 
29

The 10000th prime takes a while:

$ time ys -e 'say: prime(10000)' nth-prime.ys 
104729

real	0m28.545s

A quick improvement is to only check up to the square root of the number:

!YS-v0

defn prime(n):
  nth _ n.--:
    filter is-prime:
      drop 2: range()

defn is-prime(n):
  not-any? _ 2.range(n:sqrt:I.++):
    fn(x):
      zero?: n % x

and then:

$ time ys -e 'say: prime(10000)' nth-prime.ys 
104729

real	0m0.227s

I'm sure you can think of several optimizations but I leave them to you.

[ingydotnet]

@pwdrysdale about looping...

loop is the only function that does looping where you can leave at some condition. You leave by not calling recur.
In other words you continue looping by calling recur (which must be in the tail position of the loop body).

loop is most capable but also the more complicated. There are dozens of looping functions like: map, filter, reduce, not-any? etc that are preferable.

Getting good at thinking about list manipulations is a key to getting good at functional programming.

Note: for lets you specify a :while condition that gives you a bit of control there.

$ ys -pe 'for i (0 .. 5): +[i sqr(i)]'
([0 0] [1 1] [2 4] [3 9] [4 16] [5 25])
$ ys -pe 'for i range() :while (i <= 5): +[i sqr(i)]'
([0 0] [1 1] [2 4] [3 9] [4 16] [5 25])

[ingydotnet]

@pwdrysdale (and anyone else). Join us on our Discord chat: https://discord.gg/GYuCq6Au