list
map
number
string
set
syntax
macro
native
Lisp
CirruText
Cirru
All/WIP
Found 206 entries.
#{}
hashset. it' based on Nim's hashset, might be slower
(#{} 1 2 3 4)
&
argument spread operator, used in function creating or calling
(defn f (x0 & xs) (echo xs))
(f x0 & xs)
&*
native add function which multiples 2 numbers
(&* 2 3)
&+
native add function which adds 2 numbers
(&+ 1 2)
&-
native add function which substracts one number from another
(&+ 2 1)
&/
native add function which divide one number by another
(&/ 10 2)
&<
native < function for 2 numbers
(&< 2 3)
&<=
native implemention of <=, of 2 arguments
(<= 1 2)
&=
native = function for 2 numbers
(&= 2 (+ 1 1))
&>
native > function for 2 numbers
(&> 3 2)
&>=
native implemention of >=, of 2 arguments
(>= 2 1)
&E
get value of e, natural log
(code &E)
&PI
get value of PI, the ratio of a circle's circumference to its diameter
(echo &PI)
&and
native and function for 2 booleans
(&and true true)
&case
internal helper for case
&concat
native list concatenation of 2 lists
(&concat ([] 1 2) ([] 3 4))
&difference
difference of two hashsets
(&difference (#{} 1 2 3 4) (#{} 1 2))
&exclude
exclude an item out of a hashset
(&exclude (#{} 1 2 3 4) 4)
&include
include an item into a hashset
(&include (#{} 1 2 3) 4)
&intersection
intersection of two hashsets
(&intersection (#{} 1 2) (#{} 2 3))
&let
internal operator for let, which only binds 1 variable per expression
(&let (a 1) (+ a 1))
&max
native implemention of max, takes 2 arguments
(&max 1 2)
&min
native implemention of min, takes 2 arguments
(&min 1 2)
&or
native or function for 2 booleans
(&or false true)
&reset-gensym-index!
debugging function for gensym
&str
turn a single item into string
(&str 1)
(= |keyword (&str :keyword))
&str-concat
concat 2 strings
(&str-concat |a |b)
&union
union of two hashsets
(&union (#{} 1 2) (#{} 3 4))
&{}
internal function for {}, creating with arrays
(&{} ([] :a 1) ([] :b 2))
=>
({} (:a 1) (:b 2))
*
multiply numbers
(* 1 2 3)
+
add multiple numbers
(+ 1 2)
(+ 1 2 3)
-
substract numbers from a number
(- 2 1)
(- 10 1 2 3)
->
thread macro for nested functions, argument at head
(-> a (b) (c d))
->>
thread macro for nested functions, argument at tail
(->> a (b) (c d))
/
division of multiple numbers
(/ 12 3 4)
/=
compare 2 numbers
(/= 1 2)
;
adds comments
(; "this will not be evaludated" "more comments")
<
compare multiple numbers
(< 1 2 3 4)
<=
compare multiple numbers
(<= 2 3 4)
=
compare multiple numbers
(= 1 (- 2 1) (- 4 3))
>
compare multiple numbers
(> 4 3 2 1)
>=
compare multiple numbers
(>= 4 3 2)
[,]
macro for creating lists, , children are removed
([,] 1 , 2 , 3)
[]
operator for creating lists, internally it's ternary tree list
([] 1 2 3 4 (+ 1 2))
[][]
defining 2-dimensional list with fewer []s
([][] (2 3) (4 5) (6 7))
=>
([] ([] 2 3) ([] 4 5) ([] 6 7))
This is a macro
\
alias for an anounymous function, use % and %2 for arguments
(map (\ + x 1) (range 10))
(map-indexed (\ [] % %2) (range 10))
add-watch
add a watch function to an atom by keyword
(add-watch *a :log (\ echo |changed %))
and
varadic and operator, false for empty arguments
(either nil 1)
=>
(do 1)
(and)
=>
(do false)
(and true true false)
=>
(do false)
(and true false true)
=>
(do false)
(and true true true)
=>
(do true)
any?
detects if any item in list satisfies function
(any? (fn (x) (> x 1)) ([] 1 2 3 4))
append
returns new list, with new item at tail
(append ([] 1 2 3) 4)
apply
apply a list of arguments to a function
(apply f ([] 1 2 3 4))
assert
like Clojure assert, but string is placed first
(assert "|x > 0" (> x 0))
assert=
debugging macro for comparing a value
(assert= 2 (+ x 1))
assoc
returns a list with new item or key/value associated
(assoc ([] 1 2 3) 1 :a)
(assoc ({} (:a 1) (:b 2)) :c 10)
assoc-after
returns a list with new item associated after specified index
(assoc-after ([] 1 2 3) 1 10)
assoc-before
returns a list with new item associated before specified index
(assoc-before ([] 1 2 3) 1 10)
assoc-in
assoc a field deep inside
(assoc-in data ([] :a :b :c) 10)
(assoc-in data ([] :a 1 2) 10)
(assoc-in nil ([] :a :b) 10)
=>
({} (:a ({} (:b 10))))
assoc data even when operand is nil
bool?
detects a bool
(bool? true)
butlast
slice list without last item, return empty list if nil
(butlast ([] 1 2 3 4))
case
like Clojure case, but using value itself for else case
(case a (:a |a) (:b |b) (a |else))
(macroexpand-all (quote (case (+ 1 2) (1 |one) (2 |two) (3 |three))))
=>
(quote (&let (v__1 (+ 1 2)) (if (&= v__1 1) |one (if (&= v__1 2) |two (if (&= v__1 3) |three nil)))))
ceil
ceil of a float
(ceil 1.1)
concat
concat mutiple lists
(concat ([] 1 2) ([] 3 4) ([] 5 6))
cond
like Clojure cond, but using true for else case
(cond ((> a 10) |>10) ((> a 1) |>1) (true |false))
contains-symbol?
a function for detecting symbol existence in code
(contains-symbol? (quote (+ a b)) 'a)
contains?
check if key is contained in map, should work for sets as well
(contains? ({} (:a 1) (:b 2)) :a)
(contains? |abc |b)
cos
cos of a number
(cos 0.1)
count
just count
(count ([]))
(count ({}))
(count (|abc))
def
def is a macro, just discard the name return the value
(def x 1)
=>
(do 1)
name is totally useless in runtime
(macroexpand (quote (def a b)))
=>
(quote (b))
defatom
creating an atom of states. it requires a name, and currently not atomic, just states
(defatom *a 1)
defmacro
defines macros
(defmacro m1 (a b) (quote-replace (+ (~ a) (~ b))))
defn
create functions on namespaces
(defn (a b) (+ a b))
(defn (a (xs)) echo a xs)
deref
grab data from atom
(deref *a)
difference
return a difference hashset of 2 hashsets
(difference (#{} 1 2 3 4) (#{} 1 2) (#{} 3))
dissoc
returns a list with a key dissociated
(dissoc ({} (:a 1) (:b 2)) :a)
dissoc-in
dissociate data deep in a structure
(dissoc-in data ([] :a 1))
dissoc-in
dissoc a field deep inside
(dissoc-in data ([] :a :b :c))
(dissoc-in data ([] :a 1 2))
do
add multiple numbers
(do (echo 1) (echo 2))
draw-canvas
draw with json-paint shapes
(draw-canvas ({} (:type :polyline) (:from ([] 40 40)) (:stops ([] ([] 100 60) ([] 200 200) ([] 600 60) ([] 500 400))) (:stroke-color ({} (:r 90) (:g 10) (:b 10)))))
drop
take items of a list except for first n items
(drop 2 ([] 1 2 3 4 5))
each
take a list and a function and call each item with function
(each ([] 1 2 3 4) (fn (x) (echo x)))
echo
alias for println
(echo 1 2 3)
either
if x is nil, then return y, else y is never evaludated. or only takes booleans.
(either nil 1)
=>
(do 1)
(either 2 1)
=>
(do 2)
empty?
detects empty list or map, returns true for nil
(empty? nil)
(empty? ([]))
(empty? ({}))
ends-with?
detects if string ends with item
(ends-with? |abc |c)
escape
string escaping
(escape "|a b")
every?
detects if every item in list satisfies function
(every? (fn (x) (> x 1)) ([] 1 2 3 4))
exclude
exclude multiple items from hashset
(exclude (#{} 1 2 3 4) 1 2)
filter
filter a list with a function
(filter (fn (x) (> n 5)) (range 10))
filter-not
filter a list with a function with false return
(filter-not (fn (x) (> n 5)) (range 10))
find
find first item from list that matches the function
(find ([] 1 2 3 4) (fn (x) (> x 2)))
find-index
find index of first item that matches the function, returns -1 when not found
(find-index ([] 1 2 3 4) (fn (x) (> x 2)))
first
return first item of list
(first ([] 1 2 3 4))
floor
floor of a float
(floor 1.1)
fn
create anounymous functions
(fn (a b) (+ a b))
(macroexpand (quote (fn (a (xs)) (echo a xs))))
=>
(quote (defn generated-fn (a (xs)) (echo a xs)))
expands to function
fn?
detects a function or a proc
(fn? (fn () 1))
(fn? &=)
foldl
Haskell's foldl function, implemented i Nim for performance
(foldl + acc 0)
foldl-compare
internal function for generation comparing functions
(foldl-compare &< ([] 2 3 4) 1)
format-number
format a float with specified precision
(format-number 1.2345 2)
=>
(do 1.23)
format-ternary-tree
disply string form of internal ternary tree structure
(format-ternary-tree ([] 1 2 3 4 5 6))
(format-ternary-tree ({} (:a 1) (:b 2) (:c 3)))
format-time
format time with syntax defined in Nim times module
(format-time 1602295800 "|yyyy-MM-dd HH:mm")
=>
(do "|2020-10-10 10:10")
template syntax of Nim `times` module
frequencies
count frequencies of items in list, returns a map
(frequencies ([] 1 1 1 2 2 3))
=>
({} (3 1) (2 2) (1 3))
generate-id!
id generator, currently using nanoid
(generate-id!)
(generate-id! 10)
(generate-id! 10 abcd)
gensym
gensym, generates an unique symbol like Clojure
(gensym)
=>
(G__101)
(gensym |a)
=>
(a__102)
(gensym 'b)
=>
(b__103)
get
like Clojure get
(get ([] 1 2 3) 1)
(get ({} (:a 1) (:b 2)) :a)
get-in
like Clojure get-in function, read property recursively
(get-in data ([] :a 1))
group-by
take a list, return grouped result with a map
(group-by (fn (x) (mod x 3)) (range 10))
has-index?
detects if a list has item on a index
(has-index? (range 10) 4)
identical?
detects if items share the same pointer, mainly for lists and maps
(identical? a b)
identity
takes an item and just return it
(map identity (range 10))
if
if syntax, when ELSE branch is omitted, it will be nil
(if (> a 1) |true |false)
(if (> a 1) |just-true)
inc
add 1 to a number
(inc 10)
include
include multiple items to hashset
(include (#{} 1 2) 3 4)
index-of
native implemention of indexOf function, returns -1 when not found
(index-of ([] 1 2 3 4) 1)
init-canvas
load window of Cairo, see json-paint
(init-canvas ({} (:title "\"DEMO") (:width 800) (:height 600)))
interleave
interleave of two lists, like Clojure
(interleave ([] :a :b :c) ([] 1 2 3 4))
=>
([] :a 1 :b 2 :c 3)
intersection
return a intersection hasset of multiple hashsets
(intersection (#{} 1 2 3) (#{} 2 3 4) (#{} 3 4 5))
join
join list of items with a separator
(join 10 ([] 1 2 3 4))
=>
([] 1 10 2 10 3 10 4)
join-str
join segments into a string
(join-str |- ([] 1 2 3 4))
=>
(do |1-2-3-4)
keys
returns a list of keys of a map
(keys ({} (:a 1) (:b 2)))
keyword?
detects a keyword
(keyword? :key)
last
return last item of list
(last ([] 1 2 3 4))
let
local variable bindings, using Clojure syntax
(let ((a 1) (b (+ a 1))) (+ a b))
let->
syntax sugar on top of &let for reducing nesting
(let-> (let a 1) (let b 2) (+ a b))
list?
detects a list
(list? ([] 1 2 3 4))
loop
like Clojure loop, use tail recursion to loop inside expressions
(loop ((idx 0) (acc ([]))) (if (< idx 10) (recur (+ idx 1) (append acc idx)) acc))
(loop () (echo "|never ends") (recur))
(macroexpand (quote (loop ((acc 0) (x 0)) (if (> x 10) acc (recur (+ acc x) (inc x))))))
=>
(apply (defn generated-loop (acc x) (if (> x 10) acc (recur (+ acc x) (inc x)))) (&[] 0 0))
macro?
detects a macro
(fn? cond)
macroexpand
expand quoted code for debugging purpose, notice that quote is required
(macroexpand (quote (when true 1 2 3)))
=>
(quote (if true (do 1 2 3)))
macroexpand-all
expand quoted code recursively, notice that quote is required
(macroexpand-all (quote (when true 1 2 3)))
=>
(quote (if true (do 1 2 3)))
(macroexpand-all (quote (case (+ 1 2) (1 |one) (2 |two) (3 |three))))
=>
(quote (&let (v__1 (+ 1 2)) (if (&= v__1 1) |one (if (&= v__1 2) |two (if (&= v__1 3) |three nil)))))
map
map items of list into a new list
(map ([] 1 2 3 4) (fn (x) (+ x 1)))
map-indexed
map with index parameter
(map-indexed (fn (idx x) idx) (range 10))
map-kv
map key and value for a map
(map-kv (fn (k v) ([] k (+ v 1))) ({} (:a 1) (:b 2)))
=>
([][] (:a 2) (:b 3))
map?
detects a map
(map? ({} (:a 1) (:b 2)))
mapcat
map item to list and then concat, or just flatmap
(mapcat (fn (x) ([] x (+ x 10))) ([] 1 2 3 4))
max
max function that takes a list of arguments
(max ([] 1 2 3 4))
merge
merge multiple lists
(merge ({} (:a 1)) ({} (:b 2)))
min
max function that takes a list of arguments
(min ([] 1 2 3 4))
mod
function for get a reminder value
(mod 5 3)
=>
(do 2)
nil?
detects a nil
(nil? nil)
not
just not
(not true)
now!
get current time, stored as a float
number?
detects a number
(number? 1)
or
varadic or operator, false for empty arguments
()
(or)
=>
(do false)
(or false false false)
=>
(do false)
(or false true false)
=>
(do true)
(or false false true)
=>
(do true)
pairs-map
create a map from a list of pairs
(pairs-map ([] ([] :a 1) ([] :b 2)))
=>
({} (:a 1) (:b 2))
parse-cirru-edn
parse data from Cirru EDN format
(parse-cirru-edn "{} (:a 1)")
parse-float
get float number from string
(parse-float |1.1)
parse-json
parse JSON string into Cirru data, notice that ":a" will be parsed as keyword
(parse-json "|{\"a\": [1, 2]}")
parse-time
currently time is represented in float in calcit runner
(parse-time |2020-10-10)
=>
(do 1602259200)
default parsing template is yyyy-MM-dd
(parse-time "|2020-10-10 10:10" "|yyyy-MM-dd HH:mm")
=>
(do 1602295800)
template syntax of Nim `times` module
pow
power of a number
(pow 2 2)
pr-str
return string value with more details, string being escaped
(pr-str "|demo with space")
=>
(do "\"|demo with space\"")
(pr-str 1 2 3 4)
=>
(do "|1 2 3 4")
prepend
returns new list, with new item at first
(prepend ([] 1 2 3) 0)
print
write string values to stdout
(print 1 2 3)
println
displays values with newline at end
(println 1 2 3)
quote
return quoted data, mainly lists that are not evaludated
(quote ([] + 1 2 3))
quote-replace
used in defmacro, togather with ~ for replacing in quoted data
(quote-replace (+ 1 2 3 (~ a)))
=>
(quote (+ 1 2 3 a))
raise
raise exception with a message
(raise "|xs has error")
rand
generates a random float number in a area, defaults to 100 when not specified
(rand)
(rand 10)
(rand -10 10)
rand-int
generates a random round number in a area, defaults to 100 when not specified
(rand-int)
(rand-int 10)
(rand-int -10 10)
rand-nth
takes a random item from a list, returns nil for empty list
(rand-nth)
(rand-nth 10)
(rand-nth -10 10)
range
return a list of ranged numbers
(range 10)
(range 1 10)
(range 1 10 2)
read-file
read string from a relative file path
(read-file |demo.md)
recur
operator for tail recursion, can be used in a function or a loop
(defn f (acc n) (if (< n 10) (recur (+ acc n) (+ n 1)) acc))
remove-watch
remove a watch function from an atom by keyword
(remove-watch *a :log)
repeat
repeat an item n times
(repeat 5 :a)
=>
([] :a :a :a :a :a)
replace
replace segments in a string
(replace "|looks good" |good |bad)
reset!
update data from atom
(reset! *a 2)
rest
slice list without first item, return empty list if nil
(rest ([] 1 2 3 4))
reverse
return a list with order reversed
(reverse ([] 1 2 3 4))
round
round a float number
(round 1.1)
section-by
turn list into a list of lists of n sizes, remaining items also in a list
(section-by 3 (range 5))
=>
([] ([] 0 1 2) ([] 3 4))
set-trace-fn!
set a ns/def for debug tracing, arguments and results will be printed. unstable
(set-trace-fn! |app.main |f1)
sin
sin of a number
(sin 0.1)
slice
return a slice of list, item at last index is not included
(slice ([] 1 2 3 4) 1 2)
some?
detects something not nil
(some? 1)
sort
sort list with given comparator function
(sort (fn (x y) (&- x y)) ([] 1 3 4 2))
=>
([] 1 2 3 4)
value returned from comparator function should be a number
split
split string into a list of segments
(split |1,2,3,4 |,)
split-lines
split lines(currently with \n)
(split-lines "|a\nb\nc")
sqrt
square root of number
(sqrt 9)
starts-with?
detects if string starts with item
(starts-with? |abc |a)
str
string concatenation
(str |a 1 :k)
str-find
find index of item in a string
(str-find |abcd |a)
string?
detects a string
(string? |demo)
stringify-json
stringify Cirru data into JSON string
(stringify-json ({} (:a ([] 1 2))))
(stringify-json ({} (:a ([] 1 2))) true)
substr
get sub string by indexes
(substr |abcd 1)
(substr |abcd 1 3)
swap!
update data from atom with a function, syntax from Clojure
(swap! *a inc)
symbol?
detects a symbol
(symbol? 'a)
take
take n items from list
(take 2 ([] 1 2 3 4 5))
to-pairs
returns pairs of a map as a list of lists
(to-pairs ({} (:a 1) (:b 2)))
=>
([] ([] :a 1) ([] :b 2))
trim
trim spaces or characters from string
(trim "| a ")
(trim |__a__ |_)
turn-keyword
turn something into a keyword
(turn-keyword |k)
(turn-keyword 'k)
turn-str
turn something into a string
(turn-str :key)
(turn-str 'key)
(turn-str 1)
turn-symbol
turn something into a symbol
(turn-symbol |a)
(turn-symbol :a)
type-of
gets type of a value, returns in a keyword
(type-of a)
union
return a union hashset of 2 hashsets
(union (#{} 1 2) (#{} 3 4) (#{} 5 6))
unless
if-not syntax
(unless false |false |true)
(unless false |false)
update
update map or list
(update ({} (:a 1)) :a (\ + % 1))
(update (range 4) 1 (\ + % 1))
update-in
update data deep in a structure
(update-in data ([] :a 1) (fn (x) (x + 1)))
update-in
update a field deep inside
(update-in data ([] :a :b :c))
(update-in data ([] :a 1 2))
vals
returns a list of values of a map
(vals ({} (:a 1) (:b 2)))
when
if with no false branch
(when true (echo 1) (echo 2))
(macroexpand (quote (when true 1 2 3)))
=>
(quote (if true (do 1 2 3)))
with-log
for debug purpose, add log to an expression
(macroexpand (quote (with-log (+ 1 2))))
=>
(&let (v__1 (+ 1 2)) (echo (quote (+ 1 2)) |=> v__1) v__1)
write-file
write string content to a relative file path
(write-file |demo.md "|some content")
zipmap
create a map with two lists, one for keys and one for values
(zipmap ([] :a :b :c :d) ([] 1 2 3 4))
=>
({} (:a 1) (:b 2) (:c 3) (:d 4))
{,}
quicker way for creating literal maps, seperated with comma
(macroexpand (quote ({,} :a 1 , :b 2 , :c 3)))
=>
(pairs-map (section-by 2 ([] :a 1 :b 2 :c 3)))
commas are just removed after macro expansion
({,} :a 1 , :b 2 , :c 3)
=>
({} (:a 1) (:b 2) (:c 3))
{}
operator for creating maps based on &{}, internally it's ternary tree map
({} (:a 1) (:b (+ 2 3)))
(macroexpand (quote ({} (:a 1) (:b (+ 2 3)))))
=>
(quote (&{} ([] :a 1) ([] :b (+ 2 3))))
expands to &{}, which creates a map
~
replaces variables in quoted data
(quote-replace (+ 1 2 (~ a)))
=>
(quote (+ 1 2 a))
~@
like ~ but turns a list into multiple symbols beforing inserting
(quote-replace (+ 1 2 (~@ xs)))
(quote-replace (+ 1 2 (~@ (quote ([] a b)))))
=>
(quote (+ 1 2 a b))