Hi:
Liying Sui and I recently came across the following typing problem:
Consider an actor, say "factors" which computes for a given int I, all
the prime factors of I. For example factors(20) = [2,2,5]
Thus, the signature of factors is:
factors :: int --> [int]
Now assume factors is to be applied on a stream <x1, x2, x3, ...> of
integers, denoted <int>
It seems tempting to view the *process* Factors that is so created as
applying the higher-order map function to factors, i.e.,
Factors = map(factors)
There are some interesting typing issues. Let's say map has the
following type on streams:
map :: (a-->b) --> <a> --> <b>
That is, map takes a function of type (a-->b) and a stream of a's
(denoted <a>) and returns a stream of b's.
Therefore the type of the Factors process can be determined to be
Factors :: <int> --> < [int] >
Example: Factors( <4, 6, 10, ... > ) = < [2,2], [2,3], [2,5], ... >
So far so good -- no information is lost.
It seems, however, that in practise sometimes another process is
created:
Factors'( <4, 6, 10, ... > ) = < 2,2,2,3,2,5, ... >
Clearly this process Factors' does lose some information (the grouping
of result tuples into list of prime factors). While for this specific
example, Factors' is not desirable, such a "flattening" behavior seems
to be used in practise:
Let say we change our original function factors to produce not a list
of ints, but a stream of them:
factors' :: int --> <int>
This correspond to a token consumption/production pattern of " 1:* "
(for each input token, we might get multiple output tokens).
Is it correct that in Ptolemy II using factors' with an SDF director
produces a process Factors' on streams that has the signature:
Factors' :: <int> --> <int>
In order to make this behavior type-correct it seems we may have to
say that <<int>> = <int>, because we get
map(factors') = Factors'
and the former has the type
map(factors') :: <int> --> < <int> >
Note that the type of map(factors') is obtained by using the general
type of map above:
map :: (a-->b) --> <a> --> <b>
and the applying this to factors' :: int --> <int>
(hence a = int and b = <int>)
So if indeed Factors' is of the said type we must accept (whether we
like it or not ;-) that <<int>> = <int> (or in general, nesting
streams in this way yields a "flat" stream).
Comments??
Does Ptolemy II with an SDF director and an actor of type
myactor :: a --> <b>
produce a process
MYACTOR :: <a> --> <b>
which thus can be explained as a "special map" over streams with the
type identity <<b>> = <b> ??
Thanks in advance!
Bertram and Liying
----------------------------------------------------------------------------
Posted to the ptolemy-hackers mailing list. Please send administrative
mail for this list to: [EMAIL PROTECTED]
