Examples

Example code written in the Occult programming language.

Fibonacci

Examples for Fibonacci Sequence.

Recursive

occult 
fn fib_recursion(i64 n) i64 {
  if n == 0 {
    return n;
  }
  else if n == 1 {
    return n;
  }
  else {
    return fib_recursion(n - 1) + fib_recursion(n - 2);
  }
}

fn main() i64 {
  i64 n = fib_recursion(40);
  print_integer(n);
  print_string("\n");

  return 0;
}

While Loop

occult 

fn fib_while(i64 n) i64 {
  i64 n1 = 0;
  i64 n2 = 1;

  i64 i = 0;
  while i < n {
    i64 next = n1 + n2;
    n1 = n2;
    n2 = next;

    i = i + 1;
  }

  return n1;
}

fn main() i64 {
  i64 n = fib_while(40);
  print_integer(n);
  print_string("\n");

  return 0;
}

Factorial

Example for factorial in Occult.

occult 
fn factorial(i64 n) i64 {
  if n == 0 || n == 1 {
    return 1;
  }

  return n * factorial(n - 1);
}

fn main() i64 {
  i64 n = factorial(5);

  print_integer(n);
  print_string("\n");

  return 0;
}

Sum

Using Pointers

Using pointers to sum an array of values {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

occult 
fn sum_arr(i64* p, i64 size) i64 {
    i64 sum = 0;
    for i64 i = 0 when i < size do i = i + 1 {
        sum = sum + $(p + (i * 8));
    }
    return sum;
}

fn main() i64 {
    i64* arr = alloc(80);

    for i64 i = 0 when i < 10 do i = i + 1 {
        $(arr + (i * 8)) = i;
    }

    print_integer(sum_arr(arr, 10)); // 45 
    print_string("\n");

    del(arr);

    return 0;
}

Using Arrays

Same thing using arrays.

Arrays aren't supported in function arguments, this will likely change in the near future.
occult 
fn main() i64 {
  array[10] i64 arr;
  for i64 i = 0 when i < 10 do i = i + 1 {
    arr[i] = i;
  }   

  i64 sum = 0;
  for i64 j = 0 when j < 10 do j = j + 1 { // Using j because scope isn't implemented yet.
    sum = sum + arr[j];
  }

  print_integer(sum);
  print_string("\n");

  return 0;
}

Linked List

Example of a linked list in Occult.

occult 
struct node {
    i64 val;
    node* next;
}

fn alloc_node(i64 val) node* {
    node* n = alloc(16);

    n.val = val;
    n.next = 0;

    return n;
}

fn alloc_next_node(node* prev_node, i64 val) node* {
    node* new_node = alloc_node(val);

    node* current = prev_node;
    while current.next != 0 {
        current = current.next;
    }

    current.next = new_node;

    return new_node;
}

fn free_list(node* head) i64 {
    node* current = head;

    while current != 0 {
        node* next_node = current.next;
        del(current);
        current = next_node;
    }

    return 0;
}

fn print_all_elems(node* head) i64 {
    node* current = head;

    while current != 0 {
        print_integer(current.val);
        print_string("\n");
        current = current.next;
    }

    return 0;
}

fn sum_list(node* head) i64 {
    i64 sum = 0;
    node* current = head;

    while current != 0 {
        sum = sum + current.val;
        current = current.next;
    }

    return sum;
}

fn main() i64 {
    node* head = alloc_node(10);
    alloc_next_node(head, 20);
    alloc_next_node(head, 30);
    alloc_next_node(head, 40);

    i64 total = sum_list(head);
    print_string("Sum: ");
    print_integer(total);
    print_string("\n");

    print_all_elems(head);

    free_list(head);

    return 0;
}
×