c.c0000644000175000017500000000044112372711445012201 0ustar  tacahiroytacahiroy#include <stdio.h>

int main () {
    puts("main");
    return 0;
}

int func1() {
    int a = 0;

    if (a == 1) {
        return 0;
    } else {
        return 0;
    }
}

int func2()
{
    return 0;
}

int
func3() {
    return 0;
}

int
func4(int x,
      int y)
{
    return x + y;
}
clojure.clj0000644000175000017500000000115612651627334013757 0ustar  tacahiroytacahiroy(ns tacahiroy
    (:use [clojure.contrib.str-utils2 :only (chomp blank?)]))

(defn get-user-input []
    (loop []
        (print "> ")
        (flush)

        (def input (chomp (read-line)))
        (if (not(blank? input))
            input
            (recur))))

(def private-fu []
    (print "private-fu"))


(def funky-writer
    (proxy [java.io.Writer] []
          (write [buf] nil)
          (close []    nil)
          (flush []    nil)))

; not supported yet
(defmacro noprint
    "Evaluates the given expressions with all printing to *out* silenced."
    [& f]
    `(binding [*out* funky-writer]
         ~@f))
coffee.coffee0000644000175000017500000000151012240310150014167 0ustar  tacahiroytacahiroyglobal_func_args = (a, b) ->
  true

global_func = ->
  true

@fn = ->

global_func_single = -> true
global_func_single_args = (a, b) -> true
global_func_single_args_fat_arrow = (a, b) => true
global_func_single_args_fat_arrow_deconstruct = ({ @a, @b }) => true

String::prototype_single = -> true
String::prototype_single_args = (a, b) -> true
String::prototype_single_args_empty = () -> true
String::prototype_single_args_deconstruct = ({ @a, @b }) -> true

member_oneline = asd : -> true
member_oneline_args = asd : (a, b) -> true
member_oneline_args_empty = asd : () -> true
member_oneline_deconstruct = asd : ({@a, @b }) -> true
member =
  oneline             : -> true
  oneline_empty_args  : () -> true
  seperated_empty_ags : () ->
    true
  seperated           : ->
    true
  seperated_args_deconstruct : ({@a, @b}) =>
    true

cpp.cpp0000644000175000017500000000060112413503335013070 0ustar  tacahiroytacahiroy#include <stdio.h>

int main () {
    puts("main");
    return 0;
}

int func1() {
    int a = 0;

    if (a == 1) {
        return 0;
    } else {
        return 0;
    }
}

int func2()
{
    return 0;
}

int
func3() {
    return 0;
}

// #51
::nChkL3::tL3ScoreboardEntryPtr cExpectedDataResponses::CheckTransaction(
      const ::nChkL3::tDataResponseConstPtr &transaction
    ) {
}
cs.cs0000644000175000017500000000173412522644531012553 0ustar  tacahiroytacahiroyusing System;
using System.Linq;
using System.Text;

namespace com.foo.bar.baz
{
    public abstract class Foo : IFoo
    {
        public string Program1 { get; set; }
        public string Program2 { get; set; }

        protected double _a = 0;
        protected static double _b = 0;
        protected StringBuilder sb = new StringBuilder();

        public Foo(double a)
        {
          _a = a;
            Program1 = "";
            Program2 = "";
        }

        public Foo(double a, double b)
        {
          // do something
        }

        protected bool ProtectedMethod()
        {
          if (_a < 1.0) {
            reutrn true;
          } else {
            return false;
          }
        }

        #region R1

        public double PublicMethod(int x)
        {
          return x + 1;
        }

        public abstract string PublicAbstractMethod();

        #endregion

        protected abstract double ProtectedAbstractMethod(string y);
    }
}
css.css0000644000175000017500000000012712532327610013111 0ustar  tacahiroytacahiroy#wrapper {
  width: 90%;
}

.col1 {
  width: 30%;
}

table tr td {
  /* something */
}
elixir.ex0000644000175000017500000000140414010233525013432 0ustar  tacahiroytacahiroydefmodule FakeStar do
  def rndnum(len) when is_integer len do
    a = 1
    case a do
      1 -> 'one'
      2 -> 'two'
      _ -> 'more'
    end

    cond do
      1 + 1 == 2 -> 'two'
      1 * 1 == 1 -> 'one'
    end

    if a == 1 do
      IO.puts 'one'
    end

    :crypto.strong_rand_bytes(len)
  end

  def rndstr(len) do
    rndnum(len)
    |> :base64.encode_to_string
    |> to_string
  end

  defp priv_func() do
    IO.puts 'private'
  end

  defmacro this_is_a_macro() do
    IO.puts 'this_is_a_macro'
  end
end

defmodule M do
  def valid_row?(
        %{
          "PHONE" => phone,
          "TOTAL" => total,
          "STATUS" => status
        } = _row
      ) do
    String.length(phone) >= 10 &&
      total > 1000 &&
      status == 'DONE'
  end
end
elm.elm0000644000175000017500000000251112751626147013074 0ustar  tacahiroytacahiroy-- http://elm-lang.org/examples/form
import Html exposing (..)
import Html.App as App
import Html.Attributes exposing (..)
import Html.Events exposing (onInput)


main =
  App.beginnerProgram
    { model = model
    , view = view
    , update = update
    }



-- MODEL


type alias Model =
  { name : String
  , password : String
  , passwordAgain : String
  }


model : Model
model =
  Model "" "" ""



-- UPDATE


type Msg
    = Name String
    | Password String
    | PasswordAgain String


update : Msg -> Model -> Model
update msg model =
  case msg of
    Name name ->
      { model | name = name }

    Password password ->
      { model | password = password }

    PasswordAgain password ->
      { model | passwordAgain = password }



-- VIEW


view : Model -> Html Msg
view model =
  div []
    [ input [ type' "text", placeholder "Name", onInput Name ] []
    , input [ type' "password", placeholder "Password", onInput Password ] []
    , input [ type' "password", placeholder "Re-enter Password", onInput PasswordAgain ] []
    , viewValidation model
    ]


viewValidation : Model -> Html msg
viewValidation model =
  let
    (color, message) =
      if model.password == model.passwordAgain then
        ("green", "OK")
      else
        ("red", "Passwords do not match!")
  in
    div [ style [("color", color)] ] [ text message ]

golang.go0000644000175000017500000000034513272315030013402 0ustar  tacahiroytacahiroypackage main

import "fmt"

type T struct {
	fld int
}

type (
	App struct{}
)

func main() {
	fmt.Printf("Hello, World\n")
	t := T{}
	t.fun()
}

func (t T) fun() {
	fmt.Printf("%d", t.fld)
}

func (t T) fun2() int {
	return 0
}
graphql.graphql0000644000175000017500000000122413272314300014616 0ustar  tacahiroytacahiroytype Query {
  hero(episode: Episode): Character
  droid(id: ID!): Droid
}

schema {
  query: Query
  mutation: Mutation
}

enum Episode {
  NEWHOPE
  EMPIRE
  JEDI
}

interface Character {
  id: ID!
  name: String!
  friends: [Character]
  appearsIn: [Episode]!
}

type Human implements Character {
  id: ID!
  name: String!
  friends: [Character]
  appearsIn: [Episode]!
  starships: [Starship]
  totalCredits: Int
}

type Droid implements Character {
  id: ID!
  name: String!
  friends: [Character]
  appearsIn: [Episode]!
  primaryFunction: String
}

union SearchResult = Human | Droid | Starship

input ReviewInput {
  stars: Int!
  commentary: String
}
haskell.hs0000644000175000017500000000011412745670772013602 0ustar  tacahiroytacahiroysquare :: (Num a) => a -> a
square x = x * x

triangle :: (Num a) => a -> a
java.java0000644000175000017500000000242513010122373013365 0ustar  tacahiroytacahiroypackage com.example.foo;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.*;

public class java {

    private boolean pendulum;
    protected boolean pb = false;
    private static final int CONSTANT1 = 1;

    public static void main() {
      return;
    }

    public static final String to_s() {
      return "";
    }

    public java (int x, int y) {
      // constructor
    }

    public void curly_brace_is_next_line()
    {
      return;
    }

    public int multiline1 (int x,
                           int y) {
      return x + y;
    }

    public int multiline2 (int x,
                           int y)
    {
      return x + y;
    }

    public void each (long index) {
      if (index == 0) {
        return;
      }
      // this shouldn't be detected as a method
      else if (index == 1) {
        return;
      }
      else {
        return;
      }
    }

    public String toString () {
        return "A";
    }

    protected int foo() {
      return 0;
    }

    private void bar() {
      return;
    }

    public void singleThrow() throws IOException {
    }

    // https://github.com/tacahiroy/ctrlp-funky/issues/95
    public void multipleThrows() throws IOException, FileNotFoundException, DirectoryNotEmptyException {
    }
}
jinja.html0000644000175000017500000000131112307354627013574 0ustar  tacahiroytacahiroy<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>{%- block title -%}Web page{% endblock %}</title>
    {% block stylesheet -%}
      <link rel="stylesheet" href="styles.css">
    {% endblock stylesheet %}
  </head>
  <body id="main">
    {%- block nav %}
      <nav id="nav"></nav>
    {% endblock nav %}

    {% block main %}{% endblock main %}
  </body>
</html>

{% macro without_arguments() %}
{% endmacro %}

{% macro with_arguments(args) %}
{% endmacro %}

{% macro has_whitespace_before_brackets () %}
{% endmacro %}

{%- macro supports_ltrim() %}
{% endmacro %}

{% macro supports_rtrim() -%}
{% endmacro %}
js.js0000644000175000017500000000134713010047443012561 0ustar  tacahiroytacahiroyfunction global_func() {
  return true;
}

function global_func2(x, y) {
  return x + y;
}

var f = function() {
  return true;
};

function init(x, y) {
  return function() {
    return x * y;
  };
};

var o = {
  version: 1,
  method1: function() {
    return true;
  }
};

// generator function
function* gfunc(param) {
  // something
}

// ES6 JavaScript style of function/method declaration:
const es6 = {
  func1(p1, p2) {
  }
}

function a ()
{

}

function caller() {
  console.log(o());
  console.log(gfunc(1));
  console.log(a);
}

// Anonymous1
const anonymousFunction1 = () => {
  // ...
}

// Anonymous2
var anonymousFunction2 = props => <span>{props.children}</span>;

// Anonymous3
const a = {};
a.anonymousFunction3 = () => {}
lua.lua0000644000175000017500000000041612220316735013074 0ustar  tacahiroytacahiroyfunction bar_baz(v)
  return v
end

function dot.by_dot()
  return 0
end

local function foo(params)
  return 0
end

local function one_line(value) return 1 end

local local_foo = function()
  return 0
end

local o = {}

o.fun1 = function(client, buffer)
  return 1
end
markdown.md0000644000175000017500000000017512341370237013757 0ustar  tacahiroytacahiroy---
title: title
date: 2014-05-28
---

# head1
## head2
### head3
#### head4
##### head5
###### head6

head1-2
=

head2-2
-

moon.moon0000644000175000017500000000035312476333464013465 0ustar  tacahiroytacahiroyimport concat

tokyo_japan = ->
  for i in ary
    return true

  false

wdc_us = (arg, ...) ->
  return nil

london_uk = (arg=1) ->
  if arg == 1
    return true

  false

{
  _NAME: "moonscript"
  :tokyo_japan, :london_uk, :wdc_us
}
objc.m0000644000175000017500000000017412334434107012704 0ustar  tacahiroytacahiroy// objc
#import <stdoi.h>

@interface IFace : NSObject {
  int f1;
}

- (void) method1 {
}

+ (NSString *) method2 {
}
@end
perl.pl0000644000175000017500000000114612554711553013117 0ustar  tacahiroytacahiroypackage Foo;

use strict;
use warnings;

sub add {
  my $sum = 0;
  map { $sum += $_ } @_;
  $sum;
}

sub multi {
  my $sum = shift;
  map { $sum *= $_ } @_;
  $sum;
}

print add(1, 2, 3), "\n";
print multi(1, 2, 3, 4), "\n";

(sub { print 'anonymous', "\n" })->();
my $s = sub { print 'anon2', "\n" };
&$s;

method _format_response($response) {
  #
}

enum 'Foo::Types' , [qw(
  CH CN CU CY
)];

subtype FooType,
  as Str,
  where {
    my $type = $_;
    grep {/^$type$/} qw( organic mechanical alien )
  },
  message { "[$_] is not a valid Foo type" };

coerce FooFields,
  from Undef,
  via { [] };

sub a {
}
php.php0000644000175000017500000000213412341655500013107 0ustar  tacahiroytacahiroy<?php
/**
 * sample file for ctrlp-funky
 *
 * PHP 5
 *
 */

require 'foo.php';
require('bar.php');
require_once 'baz.php';
require_once('boo.php');
include 'foo.php';
include('bar.php');
include_once 'baz.php';
include_once('boo.php');

class Klass extends Foo {

  /**
   * public variable
   */
	public $public_var = null;

  /**
   * protected variable
   */
  protected $_protected_var = array(
    'foo' => 'bar'
  );

  /**
   * initialization
   *
   * @return void
   */
  public function initialize() {
    $this->public_var = 'init';
  }

  /**
   * public func with args
   *
   * @return void
   */
  public function foo($arg1, $arg2) {
    return null;
  }

  /**
   * protected func
   *
   * @return void
   */
  protected function _bar() {
    return false;
  }

  /**
   * protected func with args
   *
   * @return void
   */
  protected function _bar2($arg1, $arg2) {
    return false;
  }

  protected function &getName()
  {
    return false;
  }

  public static function static_func() {
    return null;
  }

  final private function __final_private() {
  }

  function __funk() {
  }
    
}
plsql.pls0000644000175000017500000000050612740402544013464 0ustar  tacahiroytacahiroyCREATE FUNCTION tst();
CREATE OR REPLACE FUNCTION schema.test();
CREATE OR REPLACE FUNCTION schema.test_args(multi number,
                        line varchar2,
                        arguments number);
CREATE OR REPLACE FUNCTION schema.test_noparens;
CREATE OR REPLACE FUNCTION schema.test_noparens_args(arguments number);
python.py0000644000175000017500000000065313362637177013524 0ustar  tacahiroytacahiroy#!python3
class Vim:
    def editor():
        print("Vi Improved")


class CtrlP:
    def method():
        print("ctrlp!")


class Funky():
    def funk():
        print("funk")

    def saturday(night, fever):
        print("dancing")

    def sleeping():
        print("zzZ")

    def monday():
        print("absent")

    def async_func():
        print('async')


if __name__ == "__main__":
    v = Vim()
    v.editor()
r.r0000644000175000017500000000015713014531235012232 0ustar  tacahiroytacahiroyfunName1 <- function (someVariable) {
  # expression
}

funName2 <- function (someVariable) {
  # expression
}
ruby.rb0000644000175000017500000000025312224546500013114 0ustar  tacahiroytacahiroy#! ruby

require "fileutils"
require_relative "foo"

include Foo

class Bar
  def initialize
    # init
  end
end

class Bar2 < Bar
end

class Klass; end

module Baz

end
scala.scala0000644000175000017500000000056612365157526013721 0ustar  tacahiroytacahiroypackage com.example.foo

import java.io.{File, InputStream}

private[barbaz] object Obj001 {
  def method001: String = {
  }

  /** Merge PYTHONPATHS with the appropriate separator. Ignores blank strings. */
  def method002(arg1: String*): String = {
    return arg1
  }

  private[barbaz] def _method003 {
  }
  private def _method004 {
  }
  public def _method005 {
  }
}
sh.bash0000644000175000017500000000057312220316735013065 0ustar  tacahiroytacahiroy#! /usr/local/bin/bash

function foo() {
  echo "foo"
}
foo

bar() {
  echo "bar"
}
bar

baz() { echo "baz"; }
baz

# -foo() { echo -foo }
# -foo

# /foo() { echo /foo }
# /foo

# +foo() { echo +foo }
# +foo

# _foo() { echo _foo }
# _foo

# 0foo() { echo 0foo }
# 0foo

# 123() { echo 123 }
# 123

# +++() { echo +++ }
# +++

# /+-() { echo /+- }
# /+-

# ?a() { echo ?a }
# ?a
sh.dash0000644000175000017500000000065212220316735013065 0ustar  tacahiroytacahiroy#! /bin/dash
# vim: ft=sh

bar() {
  echo "bar"
}
bar

baz() { echo "baz"; }
baz

_bag() {
  echo "_bag"
}

  bog() {
    echo "bog"
}

	boz() {
  echo "boz"
}


## INVALID BELOW

function foo() {
  echo "function foo"
}
foo

-foo() { echo -foo }
-foo

/foo() { echo /foo }
/foo

+foo() { echo +foo }
+foo

0foo() { echo 0foo }
0foo

123() { echo 123 }
123

+++() { echo +++ }
+++

/+-() { echo /+- }
/+-

?a() { echo ?a }
?a
sh.sh0000644000175000017500000000057112220316735012560 0ustar  tacahiroytacahiroy#! /bin/sh

function foo() {
  echo "foo"
}
foo

bar() {
  echo "bar"
}
bar

# invalid
baz() { echo "baz"; }
baz

# -foo() { echo -foo }
# -foo

# /foo() { echo /foo }
# /foo

# +foo() { echo +foo }
# +foo

# _foo() { echo _foo }
# _foo

# 0foo() { echo 0foo }
# 0foo

# 123() { echo 123 }
# 123

# +++() { echo +++ }
# +++

# /+-() { echo /+- }
# /+-

# ?a() { echo ?a }
# ?a
sh.zsh0000644000175000017500000000105512224552677012763 0ustar  tacahiroytacahiroy#! /usr/local/bin/zsh

function foo() {
  echo "1: foo"
}
foo

bar() {
  echo "2: bar"
}
bar

baz() { echo "3: baz" }
baz

-foo() { echo "4: -foo" }
-foo

/foo() { echo "5: /foo" }
/foo

+foo() { echo "6: +foo" }
+foo

_foo() { echo "7: _foo" }
_foo

0foo() { echo "8: 0foo" }
0foo

123() { echo "9: 123" }
123

+++() { echo "10: +++" }
+++

/+-() { echo "11: /+-" }
/+-

function xyz { echo "12: xyz" }
xyz

function() {
  echo "function() anonymous"
}

function {
  echo "function anonymous"
}

() {
  echo "() anonymous"
}

# INVALID
?a() { echo ?a }
?a
sql.sql0000644000175000017500000000050612740404215013126 0ustar  tacahiroytacahiroyCREATE FUNCTION tst();
CREATE OR REPLACE FUNCTION schema.test();
CREATE OR REPLACE FUNCTION schema.test_args(multi number,
                        line varchar2,
                        arguments number);
CREATE OR REPLACE FUNCTION schema.test_noparens;
CREATE OR REPLACE FUNCTION schema.test_noparens_args(arguments number);
terraform.tf0000644000175000017500000000277514042545511014156 0ustar  tacahiroytacahiroyterraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 1.0.4"
    }
  }
}

variable "aws_region" {}

variable "base_cidr_block" {
  description = "A /16 CIDR range definition, such as 10.1.0.0/16, that the VPC will use"
  default = "10.1.0.0/16"
}

variable "availability_zones" {
  description = "A list of availability zones in which to create subnets"
  type = list(string)
}

provider "aws" {
  region = var.aws_region
}

resource "aws_vpc" "main" {
  # Referencing the base_cidr_block variable allows the network address
  # to be changed without modifying the configuration.
  cidr_block = var.base_cidr_block
}

resource "aws_subnet" "az" {
  # Create one subnet for each given availability zone.
  count = length(var.availability_zones)

  # For each subnet, use one of the specified availability zones.
  availability_zone = var.availability_zones[count.index]

  # By referencing the aws_vpc.main object, Terraform knows that the subnet
  # must be created only after the VPC is created.
  vpc_id = aws_vpc.main.id

  # Built-in functions and operators can be used for simple transformations of
  # values, such as computing a subnet address. Here we create a /20 prefix for
  # each subnet, using consecutive addresses for each availability zone,
  # such as 10.1.16.0/20 .
  cidr_block = cidrsubnet(aws_vpc.main.cidr_block, 4, count.index+1)
}

data "aws_ami" "example" {
  most_recent = true

  owners = ["self"]
  tags = {
    Name   = "app-server"
    Tested = "true"
  }
}
tex.tex0000644000175000017500000000106312513106634013131 0ustar  tacahiroytacahiroy%% Engine needed: LuaTeX ≥ 0.79.1
%% Format needed: LaTeX2ε

% Comment
\input{tex-sample} %% This doc is a sample

\begin{document}
\savegeometry{normal}
\begin{abstract}
Hello World!!

{\centering \Large \hyperref[textextview]{Link for the impatient.}\\[2ex]}
\end{abstract}

\part{Part 1}

\chapter{c1}

\chapter{c2}

\chapter{c3}

\section*{s1}
Here's section 1

\subsection*{ss1}
Here's sub section 1

\subsubsection{sss1}
Sub Sub Sec 1

\subsubsection{sss2}
Sub Sub Sec 2

\paragraph{p1} \hspace{0pt} \\
\end{document}
typescript.ts0000644000175000017500000000134212506367245014376 0ustar  tacahiroytacahiroyenum Game {
  NES,
  SNES,
  Genesis,
  NeoGeo
}

declare module Module1 {
    export class Klass1 {
        constructor (arg1);
    }
    export class Klass2<T> {
        constructor ();
    }
}
interface Interfa1 {
    on(): Module1;
    off(): Module1;
}
declare var bar {
    (v: Value): Module1;
};
declare var : any;


// Person
export class Preson extends SuperKlass {
  private _fname: string;
  private _lname: string;

  constructor(fname, lname) {
    this._fname = fname;
    this._lname = lname;
  }

  public firstName() {
    return this._fname;
  }

  public lastName() {
    return this._lname;
  }

  fullName() {
    return this.firstName() + " " + this.lastName();
  }
}
vb.bas0000644000175000017500000000076412224550375012720 0ustar  tacahiroytacahiroyAttribute VB_Name = "A"
Option Explicit

Function Func1() As Boolean
    gFunc1 = True
End Function

Public Function Func2(ByVal a As Integer) As Boolean
    Func2 = True
End Function

Friend Function Func3() As Boolean

End Function

Private Function Func4() As Boolean

End Function

Sub S1()

End Sub

Private Sub S2()

End Sub

Public Sub S3()

End Sub

Public Property Get P1() As Boolean
End Property

Public Property Let P2(ByVal a As Boolean)
End Property
vb.cls0000644000175000017500000000077012224550266012730 0ustar  tacahiroytacahiroyVERSION 1.0 CLASS
BEGIN
  MultiUse = -1  'True
  Persistable = 0  'NotPersistable
  DataBindingBehavior = 0  'vbNone
  DataSourceBehavior  = 0  'vbNone
  MTSTransactionMode  = 0  'NotAnMTSObject
END
Attribute VB_Name = "klass"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = True
Attribute VB_PredeclaredId = False
Attribute VB_Exposed = False
Option Explicit

Public Enum Status
    OK = 1
    WARN = 2
    CRIT = 3
    UNKN = 3
End Enum

Private m_field1 As String
vim.vim0000644000175000017500000000103114022617042013107 0ustar  tacahiroytacahiroyfu F1()
endfu

fu! F2()
endfu

fun! F3()
endfun

func! Fun4()
endfunc

funct! Fun5()
endfunct

functi! Fun6()
endfuncti

functio! Fun7()
endfunctio

function! Fun8()
endfunction

function! g:Fun9()
endfunction

function! s:Fun10()
endfunction

vim9script
def Vim9NoReturn()
  return
enddef

def Vim9WithReturn(): bool
  return v:true
enddef

def Vim9WithArg(count: number)
  return
enddef

def Vim9WithArgAndReturn(count: number): bool
  return v:true
enddef

export def GlobalVim9Function(): string
  return 'GlobalVim9Function'
enddef
yaml.yml0000644000175000017500000001317012212403654013274 0ustar  tacahiroytacahiroy# http://yaml.org/
%YAML 1.2
---
YAML: YAML Ain't Markup Language

What It Is: YAML is a human friendly data serialization
  standard for all programming languages.

YAML Resources:
  YAML 1.2 (3rd Edition): http://yaml.org/spec/1.2/spec.html
  YAML 1.1 (2nd Edition): http://yaml.org/spec/1.1/
  YAML 1.0 (1st Edition): http://yaml.org/spec/1.0/
  YAML Trac Wiki: http://trac.yaml.org/
  YAML Mailing List: yaml-core@lists.sourceforge.net
  YAML IRC Channel: "#yaml on irc.freenode.net"
  YAML Cookbook (Ruby): http://yaml4r.sourceforge.net/cookbook/ (local)
  YAML Reference Parser: http://yaml.org/ypaste/

Projects:
  C/C++ Libraries:
  - libyaml       # "C" Fast YAML 1.1
  - Syck          # (dated) "C" YAML 1.0
  - yaml-cpp      # C++ YAML 1.1 implementation
  Ruby:
  - psych         # libyaml wrapper (in Ruby core for 1.9.2)
  - RbYaml        # YAML 1.1 (PyYaml Port)
  - yaml4r        # YAML 1.0, standard library syck binding
  Python:
  - PyYaml        # YAML 1.1, pure python and libyaml binding
  - PySyck        # YAML 1.0, syck binding
  Java:
  - JvYaml        # Java port of RbYaml
  - SnakeYAML     # Java 5 / YAML 1.1
  - YamlBeans     # To/from JavaBeans
  - JYaml         # Original Java Implementation
  Perl Modules:
  - YAML          # Pure Perl YAML Module
  - YAML::XS      # Binding to libyaml
  - YAML::Syck    # Binding to libsyck
  - YAML::Tiny    # A small YAML subset module
  - PlYaml        # Perl port of PyYaml
  C#/.NET:
  - yamldotnet      # YamlDotNet
  - yaml-net      # YAML 1.1 library
  - yatools.net   # (in-progress) YAML 1.1 implementation
  PHP:
  - php-yaml      # libyaml bindings (YAML 1.1)
  - syck          # syck bindings (YAML 1.0)
  - spyc          # yaml loader/dumper (YAML 1.?)
  OCaml:
  - ocaml-syck    # YAML 1.0 via syck bindings
  Javascript:
  - JS-YAML       # Native PyYAML port to JavaScript.
  - JS-YAML Online# Browserified JS-YAML demo, to play with YAML in your browser.
  Actionscript:
  - as3yaml       # port of JvYAML (1.1)
  Haskell:
  - YamlReference # Haskell 1.2 reference parser
  Others:
  - yamlvim (src) # YAML dumper/emitter in pure vimscript

Related Projects:
  - Rx            # Multi-Language Schemata Tool for JSON/YAML
  - Kwalify       # Ruby Schemata Tool for JSON/YAML
  - yaml_vim      # vim syntax files for YAML
  - yatools.net   # Visual Studio editor for YAML
  - JSON          # Official JSON Website
  - Pygments      # Python language Syntax Colorizer /w YAML support

News:
  - 20-NOV-2011 -- JS-YAML, a JavaScript YAML parser by Alexey Zapparov and Vitaly Puzrin.
  - 18-AUG-2010 -- Ruby 1.9.2 includes psych, a libyaml wrapper by Aaron Patterson.
  - 17-AUG-2010 -- vimscript parser/emitter was created by Nikolay Pavlov.
  - 01-OCT-2009 -- YAML 1.2 (3rd Edition) was patched.
  - 21-JUL-2009 -- YAML 1.2 (3rd Edition) was released.
  - 28-APR-2009 -- A new version of SnakeYAML was released.
  - 01-APR-2009 -- The YAML 1.2 spec was planned to be finalized by the end of the month.
  - 07-JAN-2009 -- Andrey Somov releases SnakeYAML, a 1.1 YAML Parser
  - 03-JAN-2009 -- Burt Harris announced YAML for .NET and editor for Visual Studio
  - 02-DEC-2008 -- Jesse Beder released YAML for C++
  - 11-MAY-2008 -- Oren Ben-Kiki has released a new YAML 1.2 spec draft
  - 29-NOV-2007 -- Alexey Zakhlestin has updated his Syck (YAML 1.0) binding for PHP
  - 23-NOV-2007 -- Derek Wischusen has release Action Script 3 YAML 1.1
  - 01-AUG-2006 -- Kirill Simonov has released libyaml, a parser and emitter in "C"
  - 06-JUN-2006 -- Ola Bini is at it again, this time with a Java implementation
  - 03-JUN-2006 -- Christophe Lambrechts and Jonathan Slenders announced a .NET parser
  - 07-MAY-2006 -- Ola Bini released a pure-ruby YAML 1.1 parser and emitter
  - 12-APR-2006 -- Kirill's YAML 1.1 parser for Python is now at PyYaml
  - 05-FEB-2006 -- Spyc YAML for PHP is now at version 0.3
  - 17-DEC-2005 -- Makoto Kuwata has released Kwalify 0.5, YAML/JSON schema validator
  - 14-DEC-2005 -- Toby Ho has released Jyaml, a Java library for YAML based on Rolf Veen's work
  - 30-AUG-2005 -- Kirill Simonov has produce a wonderful Python binding for Syck
  - 08-APR-2005 -- As it turns out, YAML is a superset of the JSON serialization language
  - 18-MAY-2005 -- Why has released version 0.55 of Syck
  - 28-DEC-2004 -- Announcing YAML 1.1 Working Draft
  - 01-OCT-2004 -- YAML for Cocoa was released by Will Thimbley
  - 08-FEB-2004 -- Slaven Rezic announced a new version of his Javascript binding
  - 29-JAN-2004 -- Ingy, Oren, and Clark spent 4 days hacking on the spec in Portland.
  - 10-OCT-2003 -- The Syck implementation with bindings for Ruby, Python,
                   and PHP is now at version .41
  - 26-APR-2003 -- Mike Orr has taken over the Pure Python development.
  - 26-APR-2003 -- Brian Ingerson has created a FIT platform for Wiki-like testing.
  - 24-JAN-2003 -- Updates to specification.
  - 25-JUL-2002 -- Both the Ruby and Python parsers have made significant progress.
                   There is an article about YAML by Kendall Grant Clark at xml.com.
                   There is also a draft XML binding.
  - 02-JUL-2002 -- Brian Ingerson will be giving a 45 minute presentation on YAML at the
                   O'Reilly Open Source Conference in San Diego on July 24th 2002.
  - 01-FEB-2002 -- Brian's Perl implementation YAML.pm, has been updated with new documentation.
                   Included in this release is YSH, a test shell for learning how YAML works.
  - 03-JAN-2002 -- YAML(tm) starts the new year with a new name YAML Ain't Markup Language.
  - 17-MAY-2001 -- YAML now has a mailing list at SourceForge.
  - 15-MAY-2001 -- YAML is started with a first pass specification.
# Maintained by Clark C. Evans
...
zig.zig0000644000175000017500000000013314267535642013125 0ustar  tacahiroytacahiroyfn someFunction() !void {
    return 1;
}

pub fn somePublicFunc() !void {
    return 0;
}
carbon.carbon0000644000175000017500000000015614267540205014247 0ustar  tacahiroytacahiroypackage ExplorerTest api;

class Point {
  var x: i32;
  var y: i32;
}

fn Main() -> i32 {
  return 1 as 2;
}