Zolomon

#define _BSD_SOURCE /* Get getpass() declaration from <unistd.h> */
#define _XOPEN_SOURCE /* Get crypt() declaration from <unistd.h> */
#include <unistd.h>
#include <limits.h>
#include <pwd.h>
#include <shadow.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <string.h>

Zolomon

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DerivedPropertyDemo
{
    class Program
    {

Zolomon

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using Artemis;
using Microsoft.Xna.Framework;
using Roguelike.components;

namespace Roguelike.utils

Zolomon

fn main() {
	
	struct GoalExplore {
		name: ~str
	}

	struct GoalRest {
		name: ~str
	}

Zolomon

➜  rust git:(master) make   
cfg: build triple x86_64-unknown-linux-gnu
cfg: host triples x86_64-unknown-linux-gnu
cfg: target triples x86_64-unknown-linux-gnu
cfg: host for x86_64-unknown-linux-gnu is x86_64
cfg: os for x86_64-unknown-linux-gnu is unknown-linux-gnu
cfg: using gcc
cfg: no pandoc found, omitting docs
cfg: no node found, omitting docs
cfg: no llnextgen found, omitting grammar-verification

Zolomon

data FileSystem = File Name
                | Directory Name [FileSystem]

search :: String -> FileSystem -> String
search target (Directory name (x:xs)) = ""

Zolomon

module Rearrange where

import Control.Applicative
import Data.List

main :: IO ()
main = do
  putStrLn $ show (getMaxStats maPo)

data Stats = Stats { str :: Int,

Zolomon

import java.io._

import com.github.tototoshi.csv.CSVReader

import scala.collection.mutable.ListBuffer
import scala.io.Source

case class Publisher(name: String)

case class Book(isbn: String, publishers: Option[List[Publisher]])

Zolomon

import argparse
import random
import time

class Repeater(object):
    def __init__(self, filename, minTimeToNextLine, maxTimeToNextLine):
        self.filename = filename
        self.minTime = minTimeToNextLine
        self.maxTime = maxTimeToNextLine

Zolomon

func = \f g x -> f (g x)

func2 = \g x -> (.) (g x)

func3 = \g x -> (\g2 x2 -> g x (g2 x2))


f1 = (($)$($))

f2 = (($)($))