mind2web

Following the CIS-194 course I stombled across the exercice 4 in homework 7:

type Rnd a = Rand StdGen a randomVec :: Random a => Int -> Rnd (Vector a)

Implement the function renadomVec so that it returns a random monad of a vector of the given length.

A quick check in ghci shows us all instances of Random:

class Random a where  randomR :: RandomGen g => (a, a) -> g -> (a, g)  random :: RandomGen g => g -> (a, g)  randomRs :: RandomGen g => (a, a) -> g -> [a]  randoms :: RandomGen g => g -> [a]  randomRIO :: (a, a) -> IO a  randomIO :: IO a        -- Defined in `System.Random' instance Random Word -- Defined in `System.Random' instance Random Integer -- Defined in `System.Random' instance Random Int -- Defined in `System.Random' instance Random Float -- Defined in `System.Random' instance Random Double -- Defined in `System.Random' instance Random Char -- Defined in `System.Random' instance Random Bool -- Defined in `System.Random'

So we might get back a vector of these types packed in the random monad. The class MonadRandom defines some handy functions such as this one:

getRandoms :: Random a => m [a]

The only instance of MonadRandom is “RandT g m“ and Rand g is dfined as

type Rand g = RandT g Identity

So using the getRandom functions we get back a value of type Rnd a.

getRandoms returns an infinite stream of random values of type a. So a solution might look like this:

randomVec :: Random a => Int -> Rnd (Vector a) randomVec i = do rs <- getRandoms return $ V.fromList $ take i rs

rs is an infinite list of values of type a, but we just need i of them -> use the take function. And finally just convert the list to a vector.

The type of a is bound once we use the function, not earlier. So, using the function in ghci:

>evalRandIO $ (randomVec 2 :: Rand StdGen (Vector Int)) [-3465376240042775641,-3862684656236907452] >evalRandIO $ (randomVec 2 :: Rand StdGen (Vector Float)) [0.14833772,0.3634181] >evalRandIO $ (randomVec 2 :: Rand StdGen (Vector Bool)) [True,False]

While working through the exercises of CIS 194 I stumbled on the Ruler sequence.

The assignement states:

Define the stream: ruler :: Stream Integer which corresponds to the ruler function: 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, . . .

These funcitons have been defined previously:

sRepeat :: a -> Stream a sRepeat a = Cons a (sRepeat a)

sIterate :: (a -> a) -> a -> Stream a sIterate f i = Cons i (sIterate f (f i))

sInterleave :: Stream a -> Stream a -> Stream a sInterleave (Cons a s) y = Cons a (sInterleave y s)

sTake :: Int -> Stream a -> [a] sTake i s = take i $ streamToList s

So the question was how to create the ruler function so a call like this sTake 10 $ ruler would return [0,1,0,2,0,1,0,3,0,1]

After taking the list apart I found the following pattern:

Every other line is a constant stream of the same number. First 0, then 1, then 2 and so on.

So the solution would be:

ruler :: Stream Integer ruler = rr 0    where rr i = sInterleave (sRepeat i) (rr (i + 1))

You might ask if variance is just a concept used by type system nerds. Actually no, there is a construct every Scala programmer uses everyday. A function (not to confuse with a method), from the Scala API:

trait Function1[-T1, +R] extends AnyRef

This says, that Function1 is contravariant in T1 and covariant in R. Why?

Lets have a look at the following example:

val f: Function1[Int, Any] = new Function1[Any, String] { def apply(a:Any) = "" // Do some usefull stuff }

We declare a immutable variable f of type Function1[Int, Any]. This is a function with one parameter of type Int and a return type of Any. Then we create a new function of type Function1[Any, String] and assign it to f. Why is this possible? Lets dessect it:

The variable f needs a function with a parameter of type Int. But we assign f a function which accepts parameters of type Any, meaning it can handle "more" parameter types as needed (as Int is a suptype of Any).

The function returns a String which is a subtype of Any. That's a simple upcast.

Suppose you have a generic class to write data into a file. The type parameter specifies the type of object you would like to write down:

class Writer[A] { def write(a: A) = (/* implementation */) }

Now somewhere in the code you need a Writer of type String:

val w: Writer[String] = Writer[X]

Consider the now the following possibilities for X:

String: standard case

ClassExtendsString: this implementation could be too specific for String, meaning that it is not fully supported

Object: this implementation knows how to write Objects to file. As a String is a subclass of Object it should be fully supported. But as the variance annotation is "set" to invariant, the compile complains.

Changing variance to contravariance makes the compiler happy again:

Consider this example:

class Container[+T](val a: T) val i: Container[Any] = new Container[String]("TEST") val r: Any = i.a

The "+" variance annotation makes Container covariant in T, therefore the assignment on line 3 is correct, as Container[String] is a subtype of Container[Any]. As i references a Container[String] and String is a subtype of Any, you may call all methods defined in the class Any on r, but not e.g. substring as this method is defined on String and not on Any.

Now make the content of Container mutable (change val to var):

class Container[+T](var a: T)

Why do we get a compile error saying: "covariant type T occurs in contravariant position in type T of value a_="?

Imagine we won't get this error, we could do that:

class Container[+T](var a: T) val i: Container[Any] = new Container[String]("TEST") i.a = 3

After searching the web for how to connect JBoss to a Tibco EMS server and collecting the info. I decided to put it online, might help others.

In order to receive and send messages to Tibco EMS 7.0 I did the following:

Download the Generic JMS JCA Resource Adapter from github and build it.

Add "Dependencies: com.tibco.tibjms,org.jboss.common-core" to generic-jms-ra-1.0.RC2-SNAPSHOT.rar manifest (META-INF/MANIFEST.MF)

Copy the rar into $JBOSS_HOME/standalone/deployments

Copy tibcrypt.jar and tibjms.jar (from $TIBCO_HOME/ems/7.0/lib) to $JBOSS_HOME/modules/com/tibco/tibjms/main (create missing directories).

Create the file $JBOSS_HOME/modules/com/tibco/tibjms/main/module.xml with the following content:

<?xml version='1.0' encoding='UTF-8'?> <module xmlns="urn:jboss:module:1.1" name="com.tibco.tibjms"> <resources> <resource-root path="tibjms.jar"/> <resource-root path="tibcrypt.jar"/> </resources> <dependencies> <module name="javax.api"/> <module name="javax.jms.api"/> </dependencies> </module>

Modify $TIBCO_EMS/ems/7.0/tibemsd.conf so it contains: queues                 = queues.conf factories               = factories.conf

Add the following entries to queues.conf: queue.in queue.out

Add the following entry to factories.conf: [QueueConnectionFactory]      type                = xaqueue      url                   = tcp://7222

Modify $JBOSS_HOME/standalone/configuration/standalone.xml that it contains:

<resource-adapters> <resource-adapter> <archive> generic-jms-ra-1.0.RC2-SNAPSHOT.rar </archive> <transaction-support>NoTransaction</transaction-support> <connection-definitions> <connection-definition class-name="org.jboss.resource.adapter.jms.JmsManagedConnectionFactory" jndi-name="java:/GenericJmsXA" enabled="true" use-java-context="true" pool-name="GenericJmsXA" use-ccm="true"> <config-property name="JndiParameters"> java.naming.factory.initial=com.tibco.tibjms.naming.TibjmsInitialContextFactory;java.naming.provider.url=tcp://0.0.0.0:7222 </config-property> <config-property name="ConnectionFactory"> QueueConnectionFactory </config-property> <pool> <min-pool-size>0</min-pool-size> <max-pool-size>10</max-pool-size> <prefill>false</prefill> <use-strict-min>false</use-strict-min> <flush-strategy>FailingConnectionOnly</flush-strategy> </pool> <security> <application></application> </security> </connection-definition> </connection-definitions> </resource-adapter> </resource-adapters>

Create a MDB which receives messages from the queue.in and sends messages to queue.out:

import javax.annotation.Resource; import javax.ejb.ActivationConfigProperty; import javax.ejb.MessageDriven; import javax.ejb.MessageDrivenContext; import javax.jms.Connection; import javax.jms.ConnectionFactory; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.Message; import javax.jms.MessageListener; import javax.jms.MessageProducer; import javax.jms.Session; import javax.naming.Context; import javax.naming.InitialContext; import org.jboss.ejb3.annotation.ResourceAdapter; @MessageDriven(activationConfig = { @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"), @ActivationConfigProperty(propertyName = "destination", propertyValue = "queue.in"), @ActivationConfigProperty(propertyName = "jndiParameters", propertyValue = "java.naming.factory.initial=com.tibco.tibjms.naming.TibjmsInitialContextFactory;java.naming.provider.url=tcp://0.0.0.0:7222"), @ActivationConfigProperty(propertyName = "connectionFactory", propertyValue = "QueueConnectionFactory") }) @ResourceAdapter("generic-jms-ra-1.0.RC2-SNAPSHOT.rar") public class TestMdb implements MessageListener { @Resource private MessageDrivenContext context; public void onMessage(final Message message) { try { System.out.println("Received message wit JMSMessageID = '" + message.getJMSMessageID() + "'"); Connection connection = null; try { Context context = new InitialContext(); ConnectionFactory cf = (ConnectionFactory) context.lookup("java:/GenericJmsXA"); context.close(); connection = cf.createConnection(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destination = session.createQueue("queue.out"); MessageProducer producer = session.createProducer(destination); Message msg = session.createTextMessage("example text"); producer.send(msg); } catch (Exception e) { context.setRollbackOnly(); } finally { if (connection != null) { connection.close(); } } } catch (JMSException e) { e.printStackTrace(); } } }

If the MDB is embedded in a JAR inside an EAR, make sure the JAR Manifest references the Tibco and JBoss code libraries

Question 2 asks to define a function which shifts all items of a list in a cyclic manner. After playing with the collection api and finding some input on SO, This is a solution for right shifts (and 0).

object CyclePos extends App { def cycle[A](in: List[A], count: Int): List[A] = { Stream.continually(in.toStream).flatten.take(2 * in.size - 1).toList.sliding(in.size).toList(count % in.size) } val l = List(1,2,3,4,5,6,7,'A','B','C','D') val mv3 = List(4,5,6,7,'A','B','C','D',1,2,3) val mv10 = List('D',1,2,3,4,5,6,7,'A','B','C') val mv15 = List(5,6,7,'A','B','C','D',1,2,3,4) assert (mv3 == cycle(l, 3)) assert (mv10 == cycle(l, 10)) assert (mv15 == cycle(l, 15)) assert (l == cycle(l, 0)) }

I wouldn't use it in production code in real applications, as this code

Stream.continually(in.toStream).flatten.take(2 * in.size - 1).toList.sliding(in.size).toList

produces a list containing in.size lists.

EDIT:

A more elegant solution:

As of learning Scala and the CS373 Udacity course I wanted to code the solution to quesiton 12 in Scala ...