module Main where

sine :: Double -> Double
sine x 
  | x < -pi = sine (x + 2*pi)

print (0.1 + 0.2 == 0.3)

module Main where

qs :: Ord a => [a] -> [a]
qs [] = []
qs (pivot:xs) = qs lhs ++ pivot : qs rhs

#include <stdio.h>

static void
qs (int *i, int *j)
{

module Main where

import Control.Monad.State.Strict

data ManInTown = Customer | SelfShaver | Barber

module Main where

(|>) :: a -> (a -> b) -> b
(|>) = flip ($)

module Main where

data Suit = Hearts | Diamonds | Clubs | Spades
    deriving (Show)

module Main where

-- [2**x | x <- [1 .. 10], x > 5]
ls = do
    x <- filter (>5) [1 .. 10]

module Main where

import Data.List
import Data.Maybe

module Main where

x = 0 : y
  where y = 1 : x

#include <assert.h>
#include <malloc.h>
#include <memory.h>
#include <stdlib.h>
#include <string.h>

module Main where

import Data.List

-- | Minimally exclusive member of a set (i.e., list)

module Main where

import Network.Libev
import Foreign.C.Types

{-# LANGUAGE OverloadedStrings #-}

module Url ( Login
           , Url(..)
           , UrlScheme

module Main where

import Data.Foldable as F
import Control.Monad
import Control.Applicative

module Main where

import Control.Applicative
import Control.Monad

#include <stdlib.h>
#include <malloc.h>
#include <assert.h>

#ifndef BOOL

module Main where
 
data Pnomial = Pnomial [Int] deriving Show
 
----------------------------------------------------------------

module Main where

newt x i n | i == 0    = n
           | otherwise = let f = newt x (pred i) n in (f + x/f) / 2

module Main where

choose n 0 = 1
choose 0 k = 0
choose n k = choose (n-1) (k-1) * n `div` k 

module Main where

import Data.List

insort :: (Ord a) => [a] -> [a]

void insertion_sort(int *n, size_t s)
{
   int *i, *j, *top, t;
   i = n;
   top = n + s - 1;

#include <iostream.h>
#include <boost/scoped_array.hpp>

void reverse(char *str, unsigned int n)
{

#include <iostream.h>
#include <boost/scoped_array.hpp>

void reverse(char *str, unsigned int n)
{

#include <iostream.h>

void reverse(char *str, unsigned int n)
{
    if (n < 2) return;

#include <iostream>

int main()
{
    int *p[2];

#include <iostream>
#include <assert.h>

static int five = 5;
static int nine = 9;

class SomeClass
{
public:
    void func1(int x) const { std::cout << "calling func 1 with arg. " << x << std::endl; }
    void func2(int x) const { std::cout << "calling func 2 with arg. " << x << std::endl; }

#include <iostream>

int takeThisInt()
{
    return 123;

#include <iostream>

int main()
{
    int n[2];

#include <iostream>

int main()
{
    int *p[2];

class A
{
public:
    A(const char *info)
        : m_info(new std::string(info))

class A
{
public:
    A(const char *info)
        : m_info(new std::string(info))

#include <boost/shared_ptr.hpp>
 
class SmartPimplPrivate
{
public:

class PimplPrivate
{
public:
    PimplPrivate()
        : count(1)

class Stuff
{
public:
    Stuff()
        : m_count(new long unsigned),

class Stuff
{
public:
    Stuff()
        : m_count(new long unsigned),

#include <boost/shared_ptr.hpp>

class Stuff
{
public:

class Stuff
{
public:
    Stuff() {}
    ~Stuff() {}

class K
{
public:
    K() {}
    ~K() {}

class Fruit
{
public:
    Fruit()
        : m_color("fruit-colored"),

#include <iostream.h>

class Base
{
public:

module Main where

fn3 f = \x -> \y -> if (y == 0) then x else f y (rem x y)
fpc f = f (fpc f)

module Main where

fn2 f = \x -> if (x == 0 || x == 1) then x else f (x-1) + f (x-2)
fpc f = f (fpc f)

module Main where

fn f = \x -> if (x == 0) then 1 else x * f (x - 1)

fpc f = f (fpc f)

module Main where

doubled (x:xs) = x+x : doubled xs
numbers = [1..]
doubledNumbers = doubled numbers

module Main where

n = [1..]

main = print (n!!8)

module Main where

fn x = "lazy"
n = n

module Main where

f x = 1
x = f x

module Main where

f fx = \n -> 5
x = f x

module Main where

n = 5 : n

main = print (take 3 n)

module Main where

zero = \f -> \x -> x
one  = \f -> \x -> f x
two  = \f -> \x -> f (f x)

module Main where

fn x = "lazy"
numbers = [1..]             -- a list of integers 1 to ∞

module Main where

fn1 x = "lazy"
fn2 = [1..]

#include <iostream.h>

void count(int n)
{
    std::cout << "Counting: " << n << "\n";

module Main where

main = print ("hello")