fcard

@generated function _Generic(t1::Type{T1}, args...) where T1
    for i in 1:2:length(args)
        T2 = args[i].parameters[1]
        Ex = args[i+1].parameters[1].parameters[1]
        
        isa(T2,Type) || throw(ArgumentError("$T2 is not a type"))
        
        if Ex == :_
            T1 <: T2 && return T1
        else

fcard

#!/bin/sh

DconfUserFile="$HOME/.config/dconf/user/"
CompizSchema="org.compiz.composite:$DconfUserFile"

compiz_unredirect_match() {
  case $1 in
    get) gsettings $1 "$CompizSchema" unredirect-match; ;;
    set) gsettings $1 "$CompizSchema" unredirect-match "$2"; ;;
    *)   exit 1; ;;

fcard

Mathematical model

We have a base file F0, and all files considered here are F0 repeated a number of times (Natural, >0). We shall treat these files as numbers, each one can be represented by the number of characters it contains. Any other aspect of them can be ignored. Concerning these files we have two functions:

CF such that CF(F,X) is the file F concatenated with itself X times, i.e.

   CF(F,X) = CF(F,X-1) + CF(F,X-1)
   CF(F,0) = F

We also have a function AF such that AF(F,X) is the file with its initial contents repeated X times, i.e.

fcard

function OptLets(name,default)
  let a:let1 = "let a:__OPT_ARGNUM__ = get(a:, '__OPT_ARGNUM__', 0)+1"
  let a:let2 = "let a:".a:name." = get(a:, a:__OPT_ARGNUM__, ".a:default.")"
  
  return a:let1."\n".a:let2
endfunction

command -nargs=+ Optional execute OptLets(<f-args>)

fcard

macro muladd(ex)
  esc(to_muladd(ex))
end

function to_muladd(ex)
  is_add_operation(ex) || return ex

  all_operands = ex.args[2:end]
  mul_operands = filter(is_mul_operation, all_operands)
  odd_operands = filter(x->!is_mul_operation(x), all_operands)

fcard

module MuladdMacro
export @muladd, UnexpectedMuladdExpression

macro muladd(add)
  validate_muladd(add)
  esc(to_muladd(add))
end

function to_muladd(add)
  mul = operands(add)[1]

fcard

module Muladd

macro muladd(ex)
  @assert ex.head == :call
  @assert ex.args != [:+]
  @assert ex.args[1] == :+
  esc(_muladd_meta(ex))
end

function _muladd_meta(ex)

fcard

module LetMacro
export @letmacro

macro letmacro(def, block)
  sign = def.args[1]
  body = def.args[2]
  name = Symbol("@$(sign.args[1])")
  args = sign.args[2:end]
  
  newname = Symbol("@$(gensym(name))")

fcard

# All expressions must evaluate to true

# Swap the first two arguments of a call expression
@swap_arguments(1 - 2) == 2 - 1

# "Invert" the operator of an expression
@invert_op(1 - 2) == 1 + 2
@invert_op(1 + 2) == 1 - 2
@invert_op(1 * 2) == 1 / 2
@invert_op(1 / 2) == 1 * 2

fcard

module BenchmarkWith
using  BenchmarkTools
export @benchmark_with
export @benchmark_function

macro benchmark_with(args...)
  esc(benchmark_with(args...))
end

macro benchmark_function(name, args...)