Welcome, I'm happy to see you here! Feel free to pick a function and add a happy example, the more the merrier!
(assertf true "this sentence is %n" false )
# => true
# janet 1.10.1
(all pos? [1 2 3 ]) # => true
(all pos? [1 2 3 -4 ]) # => false
(all pos? [1 2 3 0 ]) # => false
(all (partial string/has-prefix? "a" ) ["aa" "ab" ]) # => true
(all (partial string/has-prefix? "a" ) ["aa" "ab" "bb" ]) # => false
(all truthy? [1 2 ]) # => true
(all truthy? [1 2 3 ]) # => true
(all truthy? [1 2 nil 3 ]) # => false
(all truthy? [1 false 2 nil 3 ]) # => false
(all (fn [x ] x ) [1 2 ]) # => 2
(all (fn [x ] x ) [1 2 3 ]) # => 3
(all (fn [x ] x ) [1 2 nil 3 ]) # => nil
(all (fn [x ] x ) [1 false 2 nil 3 ]) # => false
# Upgrade mutates, but I wasn't sure whether it'd matter using the pure sorted or mutative sort. So I
# did a simple test.
(import spork )
# create data before test
(def d @{:data (range 10000000 0 -1 )})
(spork/test/timeit (update d :data sort )) # 4.32930135726929 seconds and 87.4 MB
(def d @{:data (range 10000000 0 -1 )}) # 87.4 MB
(spork/test/timeit (update d :data sorted )) # 4.49482655525208 seconds and 167 MB
# Where did those memory numbers come from? With only the data, the Janet process
# uses 87.4 MB. Timewise, they take the same amount of time but on starting, sorted
# prepares memory equivalent to its input. To check ram within Janet:
(def pid (os/getpid )) # => "/proc/367537/statm"
(def statm-path (string "/proc/" pid "/statm" )) # => 367537
(slurp statm-path ) # => @"40444 40038 710 82 0 39426 0\n"
# Collecting garbage:
(gccollect )
(slurp statm-path ) # => @"20912 20503 695 82 0 19894 0\n" (math/floor 1.1 ) # => 1
(map math/floor [1.1 1.2 1.3 ]) # => @[1 1 1]
(zero? 0 ) # => true
(map zero? [0 1 2 ]) # => @[true false false] # Interactively read a line from STDIN
(file/read stdin :line )
# Type abcd and then press ENTER
abcd
# Returns:
@"abcd\n" @[1 2 3] # -> @[1 2 3]
(array 1 2 3) # -> @[1 2 3]
(array (splice [1 2 3]) # -> @[1 2 3]
(array ;[1 2 3]) # -> @[1 2 3]
(do
(def coll @[])
(loop [i :down-to [10 1 ]]
(array/push coll i ))
coll )
# => @[10 9 8 7 6 5 4 3 2 1] (disasm (fn []) :bytecode )
# => @[(retn)]
(os/shell "touch foo" )
(os/stat "foo" :modified ) # => 1593836002
(os/touch "foo" )
(os/stat "foo" :modified ) # => 1593836013 (peg/match ~{:main (capture (some :S ))}
"hello world" )
# => @["hello"] # read input at compile-time and create a custom func to check whether a number is in one of the
# given ranges. This turned out to be almost 4x faster than writing it as a func
# from https://abhinavsarkar.net/notes/2025-aoc-1/#day-2
(defmacro in-range? [n & _ ]
(def ranges (parse-input (slurp input-path )))
~(or ,;(map (fn [[s e ]] ~(<= ,s ,n ,e )) ranges )))(seq [v :in (coro
(yield :hi )
(yield :bye ))]
v )
# => @[:hi :bye] # note that os/touch does not create a file if it does not yet exist.
(os/touch "foo" )
error: No such file or directory
in os/touch
in _thunk [repl ] (tailcall ) on line 2 , column 1
# Get a new and different random number each time you run your program.
(math/seedrandom (os/cryptorand 8 ))
(math/random )