Welcome, I'm happy to see you here! Feel free to pick a function and add a happy example, the more the merrier!
(mod 13 5 ) # 3 (let [p (parser/new )
src ``
(defn x
[y]
(+ 3 (* 4
(- 2 3)
`` ]
(parser/consume p src )
((parser/state p ) :delimiters ))
# => "(((" (def b @"" )
(def v (* 1000 (math/random )))
# => 912.753 can differ for you
(xprintf b "Value reached level %f" v )
# => nil
b
# => @"Value reached level 912.752790\n" (defn capitalize [str ]
(string (string/ascii-upper (string/slice str 0 1 )) (string/slice str 1 )))trampoline should work at some callback method which will match these code. most provide callback should be like these!
```c
// liba.so
void call_mul_at_callback(int i, void (*on_complete) (void*,void*), void* user_data) {
// user_data = ctx
// work_code
int v = i * i + i* i * i << 12 - 5 *i;
printf("from janet ffi\n");
on_complete(&i, user_data);
printf("FFI CALLBACK COMPLETE\n");
}
```
```janet
(ffi/context "liba.so")
(ffi/defbind call-mul-at-callback :void (i :int callback :ptr data :ptr))
(def cb (delay (ffi/trampoline :default)))
(call-mul-at-callback 15
(cb)
(fn[ptr]
(let [args (ffi/read (ffi/struct :int) ptr)]
(print (string/format "got value %d from ffi"
(first args))))))
``` (defmacro timeit [& body ]
# generate unique symbols to use in the macro so they can't conflict with anything used in `body`
(with-syms [$t0 $t1 ]
~(do
(def $t0 (os/clock :monotonic :double ))
(do ,;body )
(def $t1 (os/clock :monotonic :double ))
(- $t1 $t0 ))))
(def time-taken (timeit (os/sleep 0.5 )))
(printf "Took %.3f seconds" time-taken )
(int/u64 "18446744073709551615" )
# => <core/u64 18446744073709551615> (update-in @{:a @{:b 1 }} [:a :b ] (fn [x ] (+ 1 x )))
# @{:a @{:b 2}}
(sorted-by > @[1 2 3 4 5 6 7 8 9 10 11 12 ]) # => @[8 7 9 11 10 12 2 1 3 5 4 6]
(sorted-by < @[1 2 3 4 5 6 7 8 9 10 11 12 ]) # => @[8 7 9 11 10 12 2 1 3 5 4 6]
(sorted-by = @[1 2 3 4 5 6 7 8 9 10 11 12 ]) # => @[8 7 9 11 10 12 2 1 3 5 4 6]
(map bytes? [ 'ab :ab "ab" @"ab" [97 98 ] @[97 98 ] {0 97 1 98 } @{0 97 1 98 } ])
# => @[ true true true true false false false false ]
(map symbol? [ 'ab :ab "ab" @"ab" [97 98 ] @[97 98 ] {0 97 1 98 } @{0 97 1 98 } ])
# => @[ true false false false false false false false ]
(map keyword? [ 'ab :ab "ab" @"ab" [97 98 ] @[97 98 ] {0 97 1 98 } @{0 97 1 98 } ])
# => @[ false true false false false false false false ]
(map string? [ 'ab :ab "ab" @"ab" [97 98 ] @[97 98 ] {0 97 1 98 } @{0 97 1 98 } ])
# => @[ false false true false false false false false ]
(map buffer? [ 'ab :ab "ab" @"ab" [97 98 ] @[97 98 ] {0 97 1 98 } @{0 97 1 98 } ])
# => @[ false false false true false false false false ] (math/rng-uniform (math/rng 0 ))
# => 0.487181
(drop 1 [1 1 2 3 5 8 ])
# => '(1 2 3 5 8) (os/shell "echo bar > /tmp/foo" )
(with
[file-handle
(file/open "/tmp/foo" )
(fn [fd ] (file/close fd ))]
(file/read file-handle :all )) # => @"bar\n"
(def b @"" )
(xprint b "HOHOHO" )
# => nil
b
# => @"HOHOHO\n" (def error-levels {:red 3 :orange 2 :yellow 1 })
# Create a new prototype object called ErrorProto with one method, :compare
(def ErrorProto
@{:level nil
# Returns -1, 0, 1 for x < y, x = y, x > y respectively.
:compare (fn [self other ]
(let [lx (error-levels (self :level ))
ly (error-levels (other :level ))]
(cond
(< lx ly ) -1
(> lx ly ) 1
:else 0 )))})
# Factory function to create new Error objects
(defn make-error
[level ]
(table/setproto @{:level level } ErrorProto ))
(def err-red (make-error :red ))
(def err-yell (make-error :yellow ))
(def err-orange (make-error :orange ))
# calls of the polymorphic compare function
(compare err-red err-orange ) # 1
(compare err-orange err-red ) # -1
(compare err-red err-red ) # 0
# These following functions call internally
# the polymorphic compare function, but return a boolean value
(compare> err-red err-orange ) # true
(compare> err-yell err-orange ) # false
(compare= err-yell err-yell ) # true
#-------------------------------------------------------------------------------
# sort the objects with compare> and compare<
(def errors-unsorted @[err-red err-yell err-orange ])
# ascending order
(sort errors-unsorted compare< )
# => @[@{:level :yellow} @{:level :orange} @{:level :red}]
# descending order
(sort errors-unsorted compare> )
# => @[@{:level :red} @{:level :orange} @{:level :yellow}]
# without compare
(sort-by |(error-levels ($ :level )) errors-unsorted )
# => @[@{:level :yellow} @{:level :orange} @{:level :red}]
# Note!!!, the following does not work as expected.
# sort alone does not automatically use the compare function (the comparator)
(sort errors-unsorted ) # result is not sorted!