okkero

public class Test {

    interface Foo {}

    static abstract class Super {}

    static class Sub1 extends Super implements Foo {}
    static class Sub2 extends Super implements Foo {}

    public static void main(String[] args) {

okkero

#include <iostream>
#include <functional>
#include <optional>

template<template<typename> typename F>
struct Functor
{
  template<typename A, typename B>
  static F<B> map(const F<A> &, const std::function<B (const A &)> &);
};

okkero

#![feature(slice_patterns)]

type PhonebookError = String;

#[derive(Debug)]
struct PhonebookEntry
{
    name: String,
    phone_numbers: Vec<u32>
}

okkero

module Main where

import Control.Monad
import Data.Char
import Data.Either
import Data.List.Split

type PhonebookError = String

data PhonebookEntry = PhonebookEntry

okkero

module Main

import IdrisJvm.FFI
import IdrisJvm.IO
import Java.Lang

%default total


record Java a ret where

okkero

{-# LANGUAGE TypeFamilies, DataKinds #-}

module Main where

import Java

import System.IO

data Command = Command @org.bukkit.command.Command
  deriving Class

okkero

import Data.List

onOdds :: ([a] -> [a]) -> [a] -> [a]
onOdds f xs =
    let
        (odds, evens) = partition (odd . fst) $ zip [0..] xs
    in
        concat $
            zipWith
                (\a b -> [a, b])