vorce

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

vorce

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

vorce

-- 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

vorce

# 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

vorce

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:

vorce

(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))

vorce

(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)

vorce

(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])

vorce

/**
 * 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;

vorce

// 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) {