Copyright  (C) 20132015, University of Twente 

License  BSD2 (see the file LICENSE) 
Maintainer  Christiaan Baaij <christiaan.baaij@gmail.com> 
Safe Haskell  Safe 
Language  Haskell2010 
Whereas the output of a Moore machine depends on the previous state, the outputof a Mealy machine depends on current transition.
Mealy machines are strictly more expressive, but may impose stricter timing requirements.
 mealy :: (s > i > (s, o)) > s > Signal i > Signal o
 mealyB :: (Bundle i, Bundle o) => (s > i > (s, o)) > s > Unbundled i > Unbundled o
 (<^>) :: (Bundle i, Bundle o) => (s > i > (s, o)) > s > Unbundled i > Unbundled o
 mealy' :: SClock clk > (s > i > (s, o)) > s > Signal' clk i > Signal' clk o
 mealyB' :: (Bundle i, Bundle o) => SClock clk > (s > i > (s, o)) > s > Unbundled' clk i > Unbundled' clk o
Mealy machine synchronised to the system clock
:: (s > i > (s, o))  Transfer function in mealy machine form:

> s  Initial state 
> Signal i > Signal o  Synchronous sequential function with input and output matching that of the mealy machine 
Create a synchronous function from a combinational function describing a mealy machine
mac :: Int  Current state > (Int,Int)  Input > (Int,Int)  (Updated state, output) mac s (x,y) = (s',s) where s' = x * y + s topEntity ::Signal
(Int, Int) >Signal
Int topEntity =mealy
mac 0
>>>
simulate topEntity [(1,1),(2,2),(3,3),(4,4)]
[0,1,5,14...
Synchronous sequential functions can be composed just like their combinational counterpart:
dualMac :: (Signal
Int,Signal
Int) > (Signal
Int,Signal
Int) >Signal
Int dualMac (a,b) (x,y) = s1 + s2 where s1 =mealy
mac 0 (bundle
(a,x)) s2 =mealy
mac 0 (bundle
(b,y))
:: (Bundle i, Bundle o)  
=> (s > i > (s, o))  Transfer function in mealy machine form:

> s  Initial state 
> Unbundled i > Unbundled o  Synchronous sequential function with input and output matching that of the mealy machine 
A version of mealy
that does automatic Bundle
ing
Given a function f
of type:
f :: Int > (Bool, Int) > (Int, (Int, Bool))
When we want to make compositions of f
in g
using mealy
, we have to
write:
g a b c = (b1,b2,i2) where (i1,b1) =unbundle
(mealy
f 0 (bundle
(a,b))) (i2,b2) =unbundle
(mealy
f 3 (bundle
(i1,c)))
Using mealyB
however we can write:
g a b c = (b1,b2,i2) where (i1,b1) =mealyB
f 0 (a,b) (i2,b2) =mealyB
f 3 (i1,c)
:: (Bundle i, Bundle o)  
=> (s > i > (s, o))  Transfer function in mealy machine form:

> s  Initial state 
> Unbundled i > Unbundled o  Synchronous sequential function with input and output matching that of the mealy machine 
Infix version of mealyB
Mealy machine synchronised to an arbitrary clock
:: SClock clk 

> (s > i > (s, o))  Transfer function in mealy machine form:

> s  Initial state 
> Signal' clk i > Signal' clk o  Synchronous sequential function with input and output matching that of the mealy machine 
Create a synchronous function from a combinational function describing a mealy machine
mac :: Int  Current state > (Int,Int)  Input > (Int,Int)  (Updated state, output) mac s (x,y) = (s',s) where s' = x * y + s type ClkA =Clk
"A" 100 clkA ::SClock
ClkA clkA =sclock
topEntity ::Signal'
ClkA (Int, Int) >Signal'
ClkA Int topEntity =mealy'
clkA mac 0
>>>
simulate topEntity [(1,1),(2,2),(3,3),(4,4)]
[0,1,5,14...
Synchronous sequential functions can be composed just like their combinational counterpart:
dualMac :: (Signal'
clkA100 Int,Signal'
clkA100 Int) > (Signal'
clkA100 Int,Signal'
clkA100 Int) >Signal'
clkA100 Int dualMac (a,b) (x,y) = s1 + s2 where s1 =mealy'
clkA100 mac 0 (bundle'
clkA100 (a,x)) s2 =mealy'
clkA100 mac 0 (bundle'
clkA100 (b,y))
:: (Bundle i, Bundle o)  
=> SClock clk  
> (s > i > (s, o))  Transfer function in mealy machine form:

> s  Initial state 
> Unbundled' clk i > Unbundled' clk o  Synchronous sequential function with input and output matching that of the mealy machine 
A version of mealy'
that does automatic Bundle
ing
Given a function f
of type:
f :: Int > (Bool,Int) > (Int,(Int,Bool))
When we want to make compositions of f
in g
using mealy'
, we have to
write:
g clk a b c = (b1,b2,i2) where (i1,b1) =unbundle'
clk (mealy' clk f 0 (bundle'
clk (a,b))) (i2,b2) =unbundle'
clk (mealy' clk f 3 (bundle'
clk (i1,c)))
Using mealyB'
however we can write:
g clk a b c = (b1,b2,i2) where (i1,b1) =mealyB'
clk f 0 (a,b) (i2,b2) =mealyB'
clk f 3 (i1,c)