JanetDocs is a community documentation site for the Janet programming language

(seq [i :range [0 3]
      j :range [0 3]
      :let [c (string/format "%c" (+ 97 i))]
      :when (and (even? i) (even? j))]
  [(keyword c) j])
# => '@[(:a 0) (:a 2) (:c 0) (:c 2)]

(seq [i :range [0 3]
      j :range [0 3]
      :let [c (string/format "%c" (+ 97 i))]]
  [(keyword c) j])
# => '@[(:a 0) (:a 1) (:a 2) (:b 0) (:b 1) (:b 2) (:c 0) (:c 1) (:c 2)]

(seq [i :range [0 3]
      j :range [0 3]]
  [(keyword (string/format "%c" (+ 97 i)))
   j])
# => '@[(:a 0) (:a 1) (:a 2) (:b 0) (:b 1) (:b 2) (:c 0) (:c 1) (:c 2)]

(var a nil)

(var b nil)

(varfn a
  [x]
  (if (zero? x)
    0
    (b x)))
    
(varfn b
  [y]
  (if (pos? y)
    1
    (a y)))
    
(a 1)
# => 1

(b 0)
# => 0

(cmp 0.0 0)
# => 0

(cmp [1 2] [1 2 3])
# => -1

(cmp 1.0 2)
# => -1

(table/clear @{:a 1 :b 2})
# => @{}

(->> ["small" "cuddly" "creature"]
     (interpose "-")
     splice
     keyword)
# => :small-cuddly-creature

(keyword :)
# => :

(keyword)
# => :

(keyword "")
# => :

(let [x false]
  (var y 0)
  (unless x
    (++ y)
    (++ y))
  y)
# => 2

(-> @{:a 0 :b 0}
    (update :a inc)
    (update :b inc))
# => @{:a 1 :b 1}

(update @{:a 1} :a inc)
# => @{:a 2}

(let [c (ev/chan 1)
      before (ev/count c)]
  (ev/give c :hi)
  [before (ev/count c)])
# => '(0 1)

(/ 0)
# => inf

(/ 1 2 3)
# => 0.166667

(/ 2)
# => 0.5

(/)
# => 1

(peg/replace ~(sequence :s (thru "t")) 
             " duck"
             "smiling cat sleeps")
# => @"smiling duck sleeps"

(comment

  # the content actually has to parse as janet

  # this is ok
  (+ 1 1)
  # => 2

  # if there is something with missing delimiters though...

  )

(scan-number "1_000_000")
# => 1000000

(scan-number "111" 2)
# => 7

(= (brushift 2r1000 1 1 1) 2r0001)
# => true

(do
  (def before (dyn :expression))
  (setdyn :expression :smile)
  [before (dyn :expression)])
# => '(nil :smile)

(let [p @{:a 1}
      t @{:b 2}]
  (table/setproto t p)
  [(get t :a) (table/rawget t :a)])
# => '(1 nil)

(empty? :)
# => true

(empty? {})
# => true

(empty? [])
# => true