Voltra

Lightquery - Documentation

lightquery and aliases

You can use lightquery via its many aliases, such as :

• µ
• lq
• lQuery
• lightQuery
• LightQuery

immutableLightQuery and why is it so important

Voltra

#ifndef LINQ_ISLINQCOMPATIBLE_H
#define LINQ_ISLINQCOMPATIBLE_H

#include <type_traits>
#include "../utils/sfinae/type_exists.h"

namespace linq{
	namespace types{
		using namespace linq::utils::sfinae;
		using std::enable_if;

Voltra

#pragma once

#include <functional>
#include <unordered_map>
#include <string>
#include <mutex>
#include <sstream>
#include <locale>
#include <cstdlib>
#include <algorithm>

Voltra

#include "./memory_pool.h"
#include <string.h>

struct memory_pool{
    size_t batchSize, allocSize, elemSize;
    void** available;
    void** inUse;
    int availableCursor, inUseCursor;

    /*

Voltra

alias git-add="git add ."
alias git-commit="git commit -a -m"
alias git-push="git push origin master"
alias git-pull="git pull origin master"
alias git-s="git status"
alias git-rm="git rm -r --cached ."

alias git="'/c/Program Files/Git/bin/git.exe'"
clear

Voltra

#include <iostream>
#include <functional>
#include <utility>

using namespace std;

template <class T>
class property{
  public:
    using setter_type = function<void(T&, const T&)>;

Voltra

template <class Range>
Range firstHalf(const Range& r){
  auto&& begin = std::begin(r);
  auto&& begin_ = begin;
  
  return make<Range>(
    begin,
    std::next(
      begin_,
      std::distance(begin, std::end(r))

Voltra

last([X], X).
last([_|T], R) :- last(T, R).

first([H|_], H).

concat([], X, X).
concat([H|T], Y, [H|R]) :- concat(T, Y, R).

map(_, [], []).
map(F, [H|T], [R|RT]) :- call(F, H, R), map(F, T, RT).

Voltra

alias git-add="git add ."
alias git-commit="git commit -a -m"
alias git-push="git push origin master"
alias git-pull="git pull origin master"

alias git-s="git status"
alias git-rm="git rm -r --cached ."
alias git-ac="git-add && git-commit"

alias gf="git flow"

Voltra

import { Validatueur } from "../api";
import { RuleChain } from "../rules";
import * as I from "./index";

// "module augmentation", magically merges
// why we have to do this and not just extend manually ?
// who knows at this point
declare module "../rules" {
	interface RuleChain<T, U> {
		/****************************************************************************\