darkf

merchant Tom
  inventory: 3x Pistol Rounds @ $5, 1x SMG Rounds @ $10

  on talk {
    say "Hello! Welcome to Tom's Ammunition Supply!"
  }
end

enemy Boar
  inventory: 1x Boar Meat

darkf

# Objects are values with at least the methods {init, update, draw}.
# state describes properties shared by all game states.
# game states can transition into others, or call methods by others.
# there is a global event system that can emit (dispatch) events (by string), and catch (observe) them.

state {
	player : player
	objects : [Object]
}

darkf

import random

def say(msg):
	print ":", msg

def rnd(min, max):
	return random.randint(min, max)

class Player:
	def __init__(self):

darkf

type actor = {mutable hp : int; name : string}
type battle = {enemy : actor; mutable turn : int}
type attack = Slash of int

let player = {hp=100; name="Player"}

let runAttack by who atk =
  match atk with
  | Slash dmg -> printfn "%s slashes %s for %d" by.name who.name dmg; who.hp <- who.hp - dmg

darkf

struct vec2 (x, y);

def vec2_add(a, b) {
  vec2(a.x + b.x, a.y + b.y);
}

def main() {
  x = [1, 2, 3];
  print("hi! length of x is #{len(x)}");

darkf

#include <stdio.h>
#include <stdbool.h>
#include <math.h>
#include <string.h>

#define n 100
static bool A[n];

int main() {
  int i, j;

darkf

def parse(expr):
  lst = []

  for line in expr.split('\n'):
    s = line.split(' -> ')
    if len(s) == 1:
      lst.append(('def', line))
    else:
      lst.append(('imply', s[0], s[1]))

darkf

type Atom =
  | Num of int
  | Op of char

let opToProc = function
  | '+' -> (+)
  | '*' -> (*)
  | _ -> failwith "invalid operation"

let rec evalRPN (expr : Atom list) (stack : int list) =

darkf

-module(prog).
-export([fact/2, worker/3, manager/1, main/0]).

fact(N, Start) -> lists:foldl(fun(L, R) -> L*R end, 1, lists:seq(Start, N)).

worker({Start, End}, I, Pid) ->
  R = fact(End, Start),
  Pid ! {finished, I, R}.

manager(Queue) ->

darkf

-module(prog).
-export([main/0, take/2, drop/2, par/2, splitAt/2, product/1, manager/3, worker/3, fact/2]).

take(0, _) -> [];
take(_, []) -> [];
take(N, Lst) ->
  [hd(Lst) | take(N-1, tl(Lst))].

drop(0, Lst) -> Lst;
drop(_, []) -> [];