so basically it's a select an item from each indexable, then pass it to the mapping function
the idea was, there are specializations up to length of indexables == 4
well, a macro map could generate either the generic map that says "we don't know how many indexables got thrown at us"
or, it could generate a specialization for the amount of indexables if it's a known length
``
(defn mapMap a function over every value in a data structure andreturn an array of the results.`
[f & inds]
(def ninds (length inds))
(if (= 0 ninds) (error "expected at least 1 indexed collection"))
(def res @[])
(def [i1 i2 i3 i4] inds)
(case ninds
1 (each x i1 (array/push res (f x)))
2 (do
(var k1 nil)
(var k2 nil)
(while true
(if (= nil (set k1 (next i1 k1))) (break))
(if (= nil (set k2 (next i2 k2))) (break))
(array/push res (f (in i1 k1) (in i2 k2)))))
3 (do
(var k1 nil)
(var k2 nil)
(var k3 nil)
(while true
(if (= nil (set k1 (next i1 k1))) (break))
(if (= nil (set k2 (next i2 k2))) (break))
(if (= nil (set k3 (next i2 k3))) (break))
(array/push res (f (in i1 k1) (in i2 k2) (in i3 k3)))))
4 (do
(var k1 nil)
(var k2 nil)
(var k3 nil)
(var k4 nil)
(while true
(if (= nil (set k1 (next i1 k1))) (break))
(if (= nil (set k2 (next i2 k2))) (break))
(if (= nil (set k3 (next i2 k3))) (break))
(if (= nil (set k4 (next i2 k4))) (break))
(array/push res (f (in i1 k1) (in i2 k2) (in i3 k3) (in i4 k4)))))
(do
(def iterkeys (array/new-filled ninds))
(var done false)
(def call-buffer @[])
(while true
(forv i 0 ninds
(let [old-key (in iterkeys i)
ii (in inds i)
new-key (next ii old-key)]
(if (= nil new-key)
(do (set done true) (break))
(do (set (iterkeys i) new-key) (array/push call-buffer (in ii new-key))))))
(if done (break))
(array/push res (f ;call-buffer))
(array/clear call-buffer))))
res)
for prsonal use
ah i see
you're right
i wonder why they don't just use the generalization for all lengths
performance?
I imagine the vars are on the stack and the array is on the heap
but that's an internal, and I cannot guarantee with any certainty what I just said was/is true
@Grazfather: the fix you submitted a pull request for? did that fix it for you?
1 reply
sogaiu:matrix.org @sogaiu:matrix.org bets on performance
or... now I'm confused.
never mind, I think it had to do with how I ran the files
so if I do
dofile with an absolute path, I get the absolute path :) that makes sense
iiuc
jpm build runs with relative path on windows, and full path on linux/macos
ahhh, now I get it. iiuc
(dyn :current-file) seems to always use / as the separator, even on windows
Hi. Do we have anybody from the Joy framework here? I'd like to use its html templating without importing the whole package, but I can't exactly find which part of the code is responsible for that. The documentation mentions that they use hiccup, but that seems to be a Clojure project.
I'm not from that project, but reading their project.janet, I think that's what it uses for templating, double check though, I could be wrong
I just wrote a small CLI tool to send some commands via TCP to my speakers, had a super pleasant experience using janet and Conjure :) https://github.com/heyarne/arylic-uart-tcp-cli
1 reply
thanks :) i actually set out to write it in python, but on a whim I thought "didn't janet basically just let you handle strings as arbitrary buffers of data" and that fit really nicely. plus i get a ~600kb executable for free
1 reply
Wrote my first Janet macro today: a verbose version of
if, where you have to explicitly specify the then-case and the else-case. I don't know much about macros yet so if I'm doing something weird let me know!(defmacro ifte
``
ifte = if-then-else
Works just like `if`, but you have to supply `:then` and `:else` keywords for
extra verboseness. This can be helpful when the then-expression of
else-expression is huge and it becomes hard to keep track of things. In
general, you should probably consider creating variables to mitigate that
problem, but sometimes you're better off using `ifte`.
Usage: (ifte true :then true :else false)
``
[if-condition then-keyword then-expression else-keyword else-expression]
(with-syms [$if-condition
$then-keyword
$then-expression
$else-keyword
$else-expression]
~(let [,$if-condition ,if-condition
,$then-keyword ,then-keyword
,$then-expression (when ,$if-condition ,then-expression)
,$else-keyword ,else-keyword
,$else-expression (unless ,$if-condition ,else-expression)]
(assert
(= :then ,$then-keyword)
"The second argument of `ifte` should always be the :then keyword.")
(assert
(= :else ,$else-keyword)
"The fourth argument of `ifte` should always be the :else keyword.")
(if ,$if-condition
,$then-expression
,$else-expression))))
(Not a macro thing, but you could also probably make it shorter using
match, with literal keywords in the appropriate positions in the matching pattern)
Is this what you meant?
(defmacro ifte
[if-condition then-keyword then-expression else-keyword else-expression]
(assert
(= :then then-keyword)
"The second argument of `ifte` should always be the :then keyword.")
(assert
(= :else else-keyword)
"The fourth argument of `ifte` should always be the :else keyword.")
(with-syms [$if-condition
$then-expression
$else-expression]
~(let [,$if-condition ,if-condition
,$then-expression (when ,$if-condition ,then-expression)
,$else-expression (unless ,$if-condition ,else-expression)]
(if ,$if-condition
,$then-expression
,$else-expression))))
Hmm I guess the if-condition doesn't have to have a generated symbol either, as it will always be evaluated?
So I guess this is better:
(defmacro ifte
[if-condition then-keyword then-expression else-keyword else-expression]
(assert
(= :then then-keyword)
"The second argument of `ifte` should always be the :then keyword.")
(assert
(= :else else-keyword)
"The fourth argument of `ifte` should always be the :else keyword.")
(with-syms [$then-expression
$else-expression]
~(let [,$then-expression (when ,if-condition ,then-expression)
,$else-expression (unless ,if-condition ,else-expression)]
(if ,if-condition
,$then-expression
,$else-expression))))
Like this:
repl:1:> (defmacro ifte
repl:2:(> ""
repl:3:(> [& args]
repl:4:(> (match args
repl:5:((> @[if-cond :then then-exp :else else-exp] ~(if ,if-cond ,then-exp ,else-exp)
repl:6:((> (error "Expected (ifte <if> :then <then> :else <else>")))
<function ifte>
repl:7:> (ifte true :then (print "ok") :else (/ 0 0))
ok
nil
repl:8:> (ifte false :then (print "ok") :else (/ 0 0))
-nan
repl:9:> (ifte true (print "ok") :else (/ 0 0))
repl:9:1: compile error: error: (macro) Expected (ifte <if> :then <then> :else <else>
in ifte [repl] on line 6, column 2
repl:10:>
You don't have to bind to additional symbols, because
if is also a macro (or a special form, don't remember). So you can feel free sticking whatever you like in the then and else positions of a normal if form, and they won't be automatically evaluated
1 reply
Just as, when you hand-write an
if, those don't get evaluated
repl:10:> (if false (error "oh nooooo!"))
nilrepl:11:> (ifte true :then (print "ok") :else (error "oh noooo!"))
ok
nil
Anyway, can I update all jpm packages with one jpm command?