#[derive(Clone)]
pub struct Cpu<M: Mmu, O: OutputBus, I: InputBus, H: CallHook> {
    state: State,

    mmu: M,

    run_state: CpuState,
    interrupt_enabled: bool,

    output: O,
    input: I,

    op_code_history: OpCodesHistory,
    hook: H
}

#[derive(Default, Clone, Eq, PartialEq, Debug)]
pub struct State {
    pub a: RegByte,
    pub b: RegByte,
    pub c: RegByte,
    pub d: RegByte,
    pub e: RegByte,
    pub h: RegByte,
    pub l: RegByte,
    pub pc: RegAddress,
    pub sp: RegAddress,

    pub flags: Flags,
}

#[derive(Default, Clone, PartialEq)]
pub struct Flags(Byte);

#[derive(Copy, Clone)]
pub enum Flag {
    Sign,
    Zero,
    AuxCarry,
    Parity,
    Carry,
}

pub trait Mmu {
    fn read_byte(&self, address: Address) 
        -> Result<Byte>;
    fn write_byte(&mut self, address: Address, val: Byte) 
        -> Result<()>;
    ...
}
pub trait OutputBus {
    fn send(&self, id: Byte, data: Byte);
}

pub trait InputBus {
    fn read(&self, id: Byte) -> Byte;
}

pub fn apply(&mut self, instruction: Instruction)
        -> Result<Periods> {
    match instruction {
        Cmc => {
            Ok(self.cmc())
        }
        Stc => {
            Ok(self.stc())
        }
        Inr(r) => {
            self.inr(r)
        }
        Dcr(r) => {
            self.dcr(r)
        }
        Cma => {
            self.cma()
        }
        Daa => {
            self.daa()
        }

        ....
    }
}

pub fn opcode(it: &mut impl 
           Iterator<Item=Result<Byte, CpuError>>) 
        -> Result<Instruction, CpuError> 
{
    Ok(match next_code(it)? {
        0x00 => Nop,
        0x0f => Rrc,
        0x17 => Ral,
        0x1a => Ldax(RegPair::DE),
        0x1f => Rar,
        0x20 => Rim,
        0x27 => Daa,
        0x22 => Shld(u16_data(it)?),
        0x2a => Lhld(u16_data(it)?),
        0x2f => Cma,
        0x30 => Sim,
        0x32 => Sta(u16_data(it)?),
        0x37 => Stc,
        0x3a => Lda(u16_data(it)?),
        0x3c => Inr(Reg::A),
        0x3f => Cmc,
        0x76 => Hlt,
        ...
    }
}

package com.damico;

public interface Action {
	void doAction();
}

package com.damico;

import java.util.ArrayList;
import java.util.List;

public class ActionComposite implements Action {
	private final ArrayList<Action> actions;

	public ActionComposite(List<Action> actions) {
		this.actions = new ArrayList<Action>(actions);
	}

	@Override
	public void doAction() {
		for (Action a: actions) {
			a.doAction();
		}
	}
}

package com.damico;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {
	    Action action = new ActionComposite(
                Arrays.asList(new PrintHello(), 
                              new PrintWorld())
            );

	    action.doAction();
    }

    public static class PrintHello implements Action {
        @Override
        public void doAction() {
            System.out.print("Hello");
        }
    }

    public static class PrintWorld implements Action {
        @Override
        public void doAction() {
            System.out.println(" World");
        }
    }
}

pub trait Action {
    fn do_action(&self);
}

pub struct ActionComposite {
    actions: Vec<Box<Action>>
}

impl ActionComposite {
    pub fn new(actions: Vec<Box<Action>>) -> Self {
        ActionComposite { actions }
    }
}

impl Action for ActionComposite {
    fn do_action(&self) {
        for a in &self.actions {
            a.do_action()
        }
    }
}

struct Hello;
struct World;

impl Action for Hello { 
    fn do_action(&self) { print!("Hello"); } 
}
impl Action for World { 
    fn do_action(&self) { println!(" World"); } 
}

fn main() {
    let t_obj = trait_obj::ActionComposite::new(
        vec![action(Hello {}), action(World {})]
    );

    t_obj.do_action();
}

// Utility Function to wrap a concrete impl in a 
// dynamic trait object
pub fn action<'a, A: Action + 'a >(a: A) -> Box<Action + 'a> {
    Box::new(a)
}

pub trait Action {
    fn do_action(&self);
}

impl<A: Action, B: Action> Action for (A, B) {
    fn do_action(&self) {
        self.0.do_action();
        self.1.do_action();
    }
}

pub trait Compose: Sized {
    fn compose<A>(self, other: A) -> (Self, A) {
        (self, other)
    }
}

impl<A> Compose for A {}

struct Hello;
struct World;

impl Action for Hello { 
    fn do_action(&self) { print!("Hello"); } 
}
impl Action for World { 
    fn do_action(&self) { println!(" World"); } 
}

fn main() {
    let tuple = Hello {}.compose(World {});
    tuplee.do_action();

    println!("... compose by Hello {{}} again:");
    tuple.compose(Hello {}).do_action();
}

#[derive(Debug)]
struct Hello;
#[derive(Debug)]
struct World;

impl Action for Hello { 
    fn do_action(&self) { print!("Hello"); } 
}
impl Action for World { 
    fn do_action(&self) { println!(" World"); } 
}

macro_rules! compose {
( $first:expr ) => ( ($first) );
( $first:expr, $second:expr, ) => ( ($first, $second) );
( $first:expr, $( $x:expr ),* ) => { { ($first, compose!( $($x),*)) } };
}

fn main() {
    println!("{:?}", compose![Hello{}]);
    println!("{:?}", compose![Hello{}, World {}]);
    println!("{:?}", compose![Hello{}, World {}, Hello {}]);

    compose![Hello{}, World {}, Hello {}, World {}].do_action();
}

Hello
(Hello, World)
(Hello, (World, Hello))
Hello World
Hello World