Keybase proof
I hereby claim:
- I am vorce on github.
- I am vorce (https://keybase.io/vorce) on keybase.
- I have a public key ASB3SC08McO8-tJmvv3Mg3UbfhXyQKHZi_xXORoKAxVukwo
To claim this, I am signing this object:
defmodule AbsintheHelper do | |
@moduledoc """ | |
A way to `import_fields` from a specific module. | |
The idea is to make it more explicit in your schema where | |
object fields are coming from at a glance. | |
Usage in your schema: | |
``` | |
require EvaticContractsApi.AbsintheHelper |
import Cocoa | |
import Foundation | |
// Move around and click automatically at random places in macos, kinda human like in a cheap way. | |
// Moves the mouse pointer to `moves` random locations on the screen and runs the `action` function at | |
// each point with the point as argument. | |
func mouseMoveWithAction(moves: Int, action: (CGPoint) -> Void = defaultAction) { | |
let screenSize = NSScreen.main?.visibleFrame.size |
-- functional programming utilities | |
-- usage: local fn = require "fn" | |
NAME = "fn" | |
local M = { } | |
-- Invokes the reducer function for each element in the collection with the accumulator. | |
-- The initial value of the accumulator is initial. The function is invoked for each | |
-- element in the enumerable with the accumulator. The result returned by the |
# show top memory using processes | |
:erlang.processes() | |
|> Enum.map(fn pid -> | |
[:erlang.process_info(pid, :memory), :erlang.process_info(pid, :current_function)] | |
end) | |
|> Enum.sort() | |
|> Enum.reverse() | |
|> Enum.take(25) | |
# show top memory using ETS tables |
I hereby claim:
To claim this, I am signing this object:
(defn _henon [x y] | |
(let [x1 (* 1.4 (Math/pow x 2))] | |
[(+ y (- 1 x1)), (* x 0.3)])) | |
(defn henon [x y] | |
(let [[hx hy] (_henon x y)] | |
(lazy-seq (cons [hx hy] (henon hx hy))))) | |
; Example usage: (take 100 (henon 1 1)) |
(ns vorce.procedural.simplex) | |
; Direct translation of | |
; https://github.com/mikera/clisk/blob/develop/src/main/java/clisk/noise/Simplex.java | |
; to clojure. | |
; ...... friday night fun. | |
; Only supports 2d right now. | |
(defstruct grad :x :y :z :w) |
(ns symmetri.core | |
(:use quil.core | |
raev.core)) | |
(def mid-x 400) | |
(def mid-y 300) | |
(defrecord Point [x y z]) | |
(defrecord Sym [s1 s2 col]) | |
(defrecord Colors [r g b a]) |
/** | |
* Observes an {@link Observable<T>} and returns a new Observable<R> that emits | |
* items based on the predicate<T> and the <R> onTrue and <R> onFalse functions. | |
*/ | |
public class ObservableCondition<R, T> { | |
private final rx.Observable<T> condition; | |
private Func0<? extends R> onTrue = {} | |
private Func0<? extends R> onFalse = {} | |
private Predicate<T> predicate; |
// First sketch, with just functions. | |
// Usage: | |
// Observable<Boolean> myCondition = ... | |
// Observable<List<Foo>> foos = onCondition(myCondition, | |
// fetchFoos(a1, a2, a3), // returns a Func0<Observable<List<Foo>>> | |
// { empty() }) | |
// .flatMap({it}) | |
public final static <R> Observable<R> onCondition(Observable<Boolean> observable, | |
final Func0<? extends R> onTrue, | |
final Func0<? extends R> onFalse) { |