leifericf

{:paths ["src"]
 :deps {org.babashka/json {:mvn/version "0.1.1"}}}

kstrempel

(ns pyclojure.core
  (:gen-class)
  (:require [libpython-clj.require :refer [require-python]]
            [libpython-clj.python :as py]))

; import gym
; env = gym.make('CartPole-v0')
; for i_episode in range(20):
;     observation = env.reset()
;     for t in range(100):

pjstadig

The Pledge

One thing that always made me a little sad about transducers was how map lost its ability to iterate multiple collections in parallel. This is actually my favorite feature of map. For example:

(map + (range 5) (range 5 10))
=> (5 7 9 11 13)

One somewhat practical use of this is if you want to compare two sequences, pairwise, using a comparator. Though I wish that every? took multiple collections, this is an adequate substitute:

evren

/*
 * Copyright (c) 2017 Stardog Union. <http://www.stardog.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

aphyr

(defrecord Retry [bindings])

(defmacro with-retry
  "It's really fucking inconvenient not being able to recur from within (catch)
  expressions. This macro wraps its body in a (loop [bindings] (try ...)).
  Provides a (retry & new bindings) form which is usable within (catch) blocks:
  when this form is returned by the body, the body will be retried with the new
  bindings."
  [initial-bindings & body]
  (assert (vector? initial-bindings))

cgrand

(defmulti transmogrify 
  "Rewrites the last form of a thread-last to use transducer (if possible)."
  (fn [f xform src & args] f))

(defmacro transmogrify->>
  "Like ->> but uses transducers"
  ([x] x)
  ([src & xs]
    (let [end (last xs)
          xforms (butlast xs)

favila

(ns favila.async-util
  "Some missing pieces of core.async.

   as-transducer: Make a transducer function easily without Clojure 1.7.
   go-pipe: async/pipe, but returns the go-loop.
   fast-pipeline-blocking: faster than async/pipeline-blocking, but unordered results.
   blocking-consumer: consume a channel with multiple worker threads."
  (:require [clojure.core.async :as async
             :refer [go go-loop <! >! <!! >!! close! take! put! chan]]))

gigasquid

(defn fizzbuzz [n]
  (let [all-nums (range 0 n)
        folder (fn [fb-str p-num fb-coll]
                 (mapcat (fn [x] (cons fb-str (rest x)))
                         (partition-all p-num fb-coll)))
        fizz (folder "fizz" 3 all-nums)
        buzz (folder "buzz" 5 fizz)
        fizzbuzz (folder "fizzbuzz" 15 buzz)]
    fizzbuzz))

kachayev

Parsing CSS file with monadic parser in Clojure

Inspired by "Parsing CSS with Parsec".

Just quick notes and code that you can play with in REPL.

By @kachayev

0. Intro

brunoborges

if (arguments.length != 2) {
    print("Usage: jjs -cp lib/kvclient.jar oracle-nosql-put.js -- <key> <value>");
    exit(1);
}

var oracle = Packages.oracle;

var KVStore = oracle.kv.KVStore;
var KVStoreConfig = oracle.kv.KVStoreConfig;
var KVStoreFactory = oracle.kv.KVStoreFactory;