xudifsd

(defn qsort [l]
  (if (empty? l) '()
    (let [f (first l)
          smaller (filter #(<= % f) (rest l))
          bigger (filter #(> % f) (rest l))]
      (concat (qsort smaller) [f] (qsort bigger)))))

xudifsd

#!/bin/bash

while :
do
    git add .
    sleep 1
done

xudifsd

#include <iostream>
#include <time.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>

#define SIZE (40 * 1024 * 1024 * 1024L)

static inline double get_time_diff_double(struct timeval end, struct timeval start)
{

xudifsd

case class ListNode[+T](data: T, next: Option[ListNode[T]])                                                                                                                                                                                   object List {
  def newList[T](data: T) = newListFromNode(new ListNode(data, None))

  def newListFromNode[T](node: ListNode[T]) = new List(node)

  private def travse_iter[A](head:Option[ListNode[A]], fn: (ListNode[A]) => Unit): Unit = {
    head match {
      case Some(node) => {
        fn(node)
        List.travse_iter(node.next, fn)

xudifsd

(defn self-is-active?
  [{{:keys [uid]} :params :as req}]
  (when-not (nil? uid)
    (let [user-id (u/->int uid)
          user (*get-user-by-id* user-id)]
      (when-not (nil? user)
        (not (:inactive user))))))

(defn self-belongs-to-team?
  [{{:keys [uid subdomain]} :params :as req}]

xudifsd

(defn self-is-active?
  [{{:keys [uid]} :params :as req}]
  (when-not (nil? uid)
    (let [user-id (u/->int uid)
          user (users/get-user-by-id user-id)]
      (when-not (nil? user)
        (not (:inactive user))))))

(defn self-belongs-to-team?
  [{{:keys [uid subdomain]} :params :as req}]

xudifsd

(defmacro defasync [name args & body]
  (if config/in-test?
    `(defn ~name ~args ~@body)
    (let [name-str (str name)]
      `(defn ~name ~args
         (future
           (try
             ~@body
             (catch Exception e#
               (log/error (str ~name-str

xudifsd

; It's been a long time that Typed Clojure couldn't annotate `hash-map` using
; first class type. Because these functions require even number of arguments,
; and also have some special type constrain on its arguments.
; So we used to check these functions using special handler in checker.
; One of my GSOC goal is to make it possible to type check these kind of
; function without special handler.
; And now I made it. Thanks Sam Tobin-Hochstadt and Asumu Takikawa who inspired
; us.
; You can try it at my fork of Typed Clojure
; https://github.com/xudifsd/core.typed/tree/repeat-support

xudifsd

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import java.lang.NoSuchMethodException;

public class T {
    public static void main(String[] args) throws Exception {
        executeWithAnnotationSupport(T.class, "doSomething");

xudifsd

import java.io.*;

public class ClassLoaderTest {
    public static void main(String[] args) throws Exception {
        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                try {
                    String fileName = "foo/" + name.replace('.', '/') + ".class";
                    System.out.println(fileName);